lael-labs/linux

.clang-format+11−2

   - 'css_for_each_child'
   - 'css_for_each_descendant_post'
   - 'css_for_each_descendant_pre'
-  - 'cxl_for_each_cmd'
   - 'device_for_each_child_node'
+  - 'displayid_iter_for_each'
   - 'dma_fence_chain_for_each'
   - 'do_for_each_ftrace_op'
   - 'drm_atomic_crtc_for_each_plane'
   - 'drm_mm_for_each_node_in_range'
   - 'drm_mm_for_each_node_safe'
   - 'flow_action_for_each'
+  - 'for_each_acpi_dev_match'
   - 'for_each_active_dev_scope'
   - 'for_each_active_drhd_unit'
   - 'for_each_active_iommu'
   - 'for_each_dapm_widgets'
   - 'for_each_dev_addr'
   - 'for_each_dev_scope'
-  - 'for_each_displayid_db'
   - 'for_each_dma_cap_mask'
   - 'for_each_dpcm_be'
   - 'for_each_dpcm_be_rollback'
   - 'for_each_dpcm_fe'
   - 'for_each_drhd_unit'
   - 'for_each_dss_dev'
+  - 'for_each_dtpm_table'
   - 'for_each_efi_memory_desc'
   - 'for_each_efi_memory_desc_in_map'
   - 'for_each_element'
   - 'for_each_migratetype_order'
   - 'for_each_msi_entry'
   - 'for_each_msi_entry_safe'
+  - 'for_each_msi_vector'
   - 'for_each_net'
   - 'for_each_net_continue_reverse'
   - 'for_each_netdev'
   - 'for_each_prime_number_from'
   - 'for_each_process'
   - 'for_each_process_thread'
+  - 'for_each_prop_codec_conf'
+  - 'for_each_prop_dai_codec'
+  - 'for_each_prop_dai_cpu'
+  - 'for_each_prop_dlc_codecs'
+  - 'for_each_prop_dlc_cpus'
+  - 'for_each_prop_dlc_platforms'
   - 'for_each_property_of_node'
   - 'for_each_registered_fb'
   - 'for_each_requested_gpio'
   - 'queue_for_each_hw_ctx'
   - 'radix_tree_for_each_slot'
   - 'radix_tree_for_each_tagged'
+  - 'rb_for_each'
   - 'rbtree_postorder_for_each_entry_safe'
   - 'rdma_for_each_block'
   - 'rdma_for_each_port'

.mailmap+3−0

 Mayuresh Janorkar <mayur@ti.com>
 Michael Buesch <m@bues.ch>
 Michel Dänzer <michel@tungstengraphics.com>
+Michel Lespinasse <michel@lespinasse.org>
+Michel Lespinasse <michel@lespinasse.org> <walken@google.com>
+Michel Lespinasse <michel@lespinasse.org> <walken@zoy.org>
 Miguel Ojeda <ojeda@kernel.org> <miguel.ojeda.sandonis@gmail.com>
 Mike Rapoport <rppt@kernel.org> <mike@compulab.co.il>
 Mike Rapoport <rppt@kernel.org> <mike.rapoport@gmail.com>

Documentation/devicetree/bindings/connector/usb-connector.yaml+15−0

@@ -149,6 +149,17 @@ properties: · 148 unmodified lines
149	maxItems: 6	149	maxItems: 6
150	$ref: /schemas/types.yaml#/definitions/uint32-array	150	$ref: /schemas/types.yaml#/definitions/uint32-array
151		151
		152	sink-vdos-v1:
		153	description: An array of u32 with each entry, a Vendor Defined Message Object (VDO),
		154	providing additional information corresponding to the product, the detailed bit
		155	definitions and the order of each VDO can be found in
		156	"USB Power Delivery Specification Revision 2.0, Version 1.3" chapter 6.4.4.3.1 Discover
		157	Identity. User can specify the VDO array via VDO_IDH/_CERT/_PRODUCT/_CABLE/_AMA defined in
		158	dt-bindings/usb/pd.h.
		159	minItems: 3
		160	maxItems: 6
		161	$ref: /schemas/types.yaml#/definitions/uint32-array
		162
152	op-sink-microwatt:	163	op-sink-microwatt:
153	description: Sink required operating power in microwatt, if source can't	164	description: Sink required operating power in microwatt, if source can't
154	offer the power, Capability Mismatch is set. Required for power sink and	165	offer the power, Capability Mismatch is set. Required for power sink and
@@ -207,6 +218,10 @@ properties: · 52 unmodified lines
207	SNK_READY for non-pd link.	218	SNK_READY for non-pd link.
208	type: boolean	219	type: boolean
209		220
		221	dependencies:
		222	sink-vdos-v1: [ 'sink-vdos' ]
		223	sink-vdos: [ 'sink-vdos-v1' ]
		224
210	required:	225	required:
211	- compatible	226	- compatible
212		227

Documentation/devicetree/bindings/hwmon/ti,ads7828.yaml+1−1

@@ -49,7 +49,7 @@ examples: · 48 unmodified lines
49	#size-cells = <0>;	49	#size-cells = <0>;
50		50
51	adc@48 {	51	adc@48 {
52	comatible = "ti,ads7828";	52	compatible = "ti,ads7828";
53	reg = <0x48>;	53	reg = <0x48>;
54	vref-supply = <&vref>;	54	vref-supply = <&vref>;
55	ti,differential-input;	55	ti,differential-input;

Documentation/devicetree/bindings/media/renesas,drif.yaml+1−3

@@ -67,9 +67,7 @@ properties: · 66 unmodified lines
67	maxItems: 1	67	maxItems: 1
68		68
69	clock-names:	69	clock-names:
70	maxItems: 1	70	const: fck
71	items:
72	- const: fck
73		71
74	resets:	72	resets:
75	maxItems: 1	73	maxItems: 1

Documentation/devicetree/bindings/sound/amlogic,gx-sound-card.yaml+2−2

@@ -57,7 +57,7 @@ patternProperties: · 56 unmodified lines
57	rate	57	rate
58		58
59	sound-dai:	59	sound-dai:
60	$ref: /schemas/types.yaml#/definitions/phandle	60	$ref: /schemas/types.yaml#/definitions/phandle-array
61	description: phandle of the CPU DAI	61	description: phandle of the CPU DAI
62		62
63	patternProperties:	63	patternProperties:
@@ -71,7 +71,7 @@ patternProperties: · 7 unmodified lines
71		71
72	properties:	72	properties:
73	sound-dai:	73	sound-dai:
74	$ref: /schemas/types.yaml#/definitions/phandle	74	$ref: /schemas/types.yaml#/definitions/phandle-array
75	description: phandle of the codec DAI	75	description: phandle of the codec DAI
76		76
77	required:	77	required:

Documentation/virt/kvm/mmu.rst+2−2

@@ -171,8 +171,8 @@ Shadow pages contain the following information: · 170 unmodified lines
171	shadow pages) so role.quadrant takes values in the range 0..3. Each	171	shadow pages) so role.quadrant takes values in the range 0..3. Each
172	quadrant maps 1GB virtual address space.	172	quadrant maps 1GB virtual address space.
173	role.access:	173	role.access:
174	Inherited guest access permissions in the form uwx. Note execute	174	Inherited guest access permissions from the parent ptes in the form uwx.
175	permission is positive, not negative.	175	Note execute permission is positive, not negative.
176	role.invalid:	176	role.invalid:
177	The page is invalid and should not be used. It is a root page that is	177	The page is invalid and should not be used. It is a root page that is
178	currently pinned (by a cpu hardware register pointing to it); once it is	178	currently pinned (by a cpu hardware register pointing to it); once it is

MAINTAINERS+16−5

 S:	Maintained
 W:	http://btrfs.wiki.kernel.org/
 Q:	http://patchwork.kernel.org/project/linux-btrfs/list/
+C:	irc://irc.libera.chat/btrfs
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git
 F:	Documentation/filesystems/btrfs.rst
 F:	fs/btrfs/
 FANOTIFY
 M:	Jan Kara <jack@suse.cz>
 R:	Amir Goldstein <amir73il@gmail.com>
+R:	Matthew Bobrowski <repnop@google.com>
 L:	linux-fsdevel@vger.kernel.org
 S:	Maintained
 F:	fs/notify/fanotify/
 NFC SUBSYSTEM
 M:	Krzysztof Kozlowski <krzysztof.kozlowski@canonical.com>
-L:	linux-nfc@lists.01.org (moderated for non-subscribers)
+L:	linux-nfc@lists.01.org (subscribers-only)
 L:	netdev@vger.kernel.org
 S:	Maintained
 F:	Documentation/devicetree/bindings/net/nfc/
 NFC VIRTUAL NCI DEVICE DRIVER
 M:	Bongsu Jeon <bongsu.jeon@samsung.com>
 L:	netdev@vger.kernel.org
-L:	linux-nfc@lists.01.org (moderated for non-subscribers)
+L:	linux-nfc@lists.01.org (subscribers-only)
 S:	Supported
 F:	drivers/nfc/virtual_ncidev.c
 F:	tools/testing/selftests/nci/
 NXP-NCI NFC DRIVER
 R:	Charles Gorand <charles.gorand@effinnov.com>
-L:	linux-nfc@lists.01.org (moderated for non-subscribers)
+L:	linux-nfc@lists.01.org (subscribers-only)
 S:	Supported
 F:	drivers/nfc/nxp-nci
 PCI ENDPOINT SUBSYSTEM
 M:	Kishon Vijay Abraham I <kishon@ti.com>
 M:	Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
+R:	Krzysztof Wilczyński <kw@linux.com>
 L:	linux-pci@vger.kernel.org
 S:	Supported
 F:	Documentation/PCI/endpoint/*
 PCI NATIVE HOST BRIDGE AND ENDPOINT DRIVERS
 M:	Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
 R:	Rob Herring <robh@kernel.org>
+R:	Krzysztof Wilczyński <kw@linux.com>
 L:	linux-pci@vger.kernel.org
 S:	Supported
 Q:	http://patchwork.ozlabs.org/project/linux-pci/list/
 SAMSUNG S3FWRN5 NFC DRIVER
 M:	Krzysztof Kozlowski <krzysztof.kozlowski@canonical.com>
 M:	Krzysztof Opasiak <k.opasiak@samsung.com>
-L:	linux-nfc@lists.01.org (moderated for non-subscribers)
+L:	linux-nfc@lists.01.org (subscribers-only)
 S:	Maintained
 F:	Documentation/devicetree/bindings/net/nfc/samsung,s3fwrn5.yaml
 F:	drivers/nfc/s3fwrn5
 TI TRF7970A NFC DRIVER
 M:	Mark Greer <mgreer@animalcreek.com>
 L:	linux-wireless@vger.kernel.org
-L:	linux-nfc@lists.01.org (moderated for non-subscribers)
+L:	linux-nfc@lists.01.org (subscribers-only)
 S:	Supported
 F:	Documentation/devicetree/bindings/net/nfc/trf7970a.txt
 F:	drivers/nfc/trf7970a.c
 F:	drivers/usb/host/isp116x*
 F:	include/linux/usb/isp116x.h
+USB ISP1760 DRIVER
+M:	Rui Miguel Silva <rui.silva@linaro.org>
+L:	linux-usb@vger.kernel.org
+S:	Maintained
+F:	drivers/usb/isp1760/*
+F:	Documentation/devicetree/bindings/usb/nxp,isp1760.yaml
 USB LAN78XX ETHERNET DRIVER
 M:	Woojung Huh <woojung.huh@microchip.com>
 M:	UNGLinuxDriver@microchip.com

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 13	3	PATCHLEVEL = 13
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc4	5	EXTRAVERSION = -rc6
6	NAME = Frozen Wasteland	6	NAME = Frozen Wasteland
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm/boot/dts/imx6dl-yapp4-common.dtsi+5−1

 	phy-reset-gpios = <&gpio1 25 GPIO_ACTIVE_LOW>;
 	phy-reset-duration = <20>;
 	phy-supply = <&sw2_reg>;
-	phy-handle = <&ethphy0>;
 	status = "okay";
+	fixed-link {
+		speed = <1000>;
+		full-duplex;
+	};
 	mdio {
 		#address-cells = <1>;
 		#size-cells = <0>;

arch/arm/boot/dts/imx6q-dhcom-som.dtsi+12−0

@@ -406,6 +406,18 @@ · 405 unmodified lines
406	vin-supply = <&sw1_reg>;	406	vin-supply = <&sw1_reg>;
407	};	407	};
408		408
		409	&reg_pu {
		410	vin-supply = <&sw1_reg>;
		411	};
		412
		413	&reg_vdd1p1 {
		414	vin-supply = <&sw2_reg>;
		415	};
		416
		417	&reg_vdd2p5 {
		418	vin-supply = <&sw2_reg>;
		419	};
		420
409	&uart1 {	421	&uart1 {
410	pinctrl-names = "default";	422	pinctrl-names = "default";
411	pinctrl-0 = <&pinctrl_uart1>;	423	pinctrl-0 = <&pinctrl_uart1>;

arch/arm/boot/dts/imx6qdl-emcon-avari.dtsi+1−1

@@ -126,7 +126,7 @@ · 125 unmodified lines
126	compatible = "nxp,pca8574";	126	compatible = "nxp,pca8574";
127	reg = <0x3a>;	127	reg = <0x3a>;
128	gpio-controller;	128	gpio-controller;
129	#gpio-cells = <1>;	129	#gpio-cells = <2>;
130	};	130	};
131	};	131	};
132		132

arch/arm/boot/dts/imx7d-meerkat96.dts+1−1

@@ -193,7 +193,7 @@ · 192 unmodified lines
193	pinctrl-names = "default";	193	pinctrl-names = "default";
194	pinctrl-0 = <&pinctrl_usdhc1>;	194	pinctrl-0 = <&pinctrl_usdhc1>;
195	keep-power-in-suspend;	195	keep-power-in-suspend;
196	tuning-step = <2>;	196	fsl,tuning-step = <2>;
197	vmmc-supply = <&reg_3p3v>;	197	vmmc-supply = <&reg_3p3v>;
198	no-1-8-v;	198	no-1-8-v;
199	broken-cd;	199	broken-cd;

arch/arm/boot/dts/imx7d-pico.dtsi+1−1

@@ -351,7 +351,7 @@ · 350 unmodified lines
351	pinctrl-2 = <&pinctrl_usdhc1_200mhz>;	351	pinctrl-2 = <&pinctrl_usdhc1_200mhz>;
352	cd-gpios = <&gpio5 0 GPIO_ACTIVE_LOW>;	352	cd-gpios = <&gpio5 0 GPIO_ACTIVE_LOW>;
353	bus-width = <4>;	353	bus-width = <4>;
354	tuning-step = <2>;	354	fsl,tuning-step = <2>;
355	vmmc-supply = <&reg_3p3v>;	355	vmmc-supply = <&reg_3p3v>;
356	wakeup-source;	356	wakeup-source;
357	no-1-8-v;	357	no-1-8-v;

arch/arm/include/asm/cpuidle.h+3−2

 #ifdef CONFIG_CPU_IDLE
 extern int arm_cpuidle_simple_enter(struct cpuidle_device *dev,
 		struct cpuidle_driver *drv, int index);
+#define __cpuidle_method_section __used __section("__cpuidle_method_of_table")
 #else
 static inline int arm_cpuidle_simple_enter(struct cpuidle_device *dev,
 		struct cpuidle_driver *drv, int index) { return -ENODEV; }
+#define __cpuidle_method_section __maybe_unused /* drop silently */
 #endif
 /* Common ARM WFI state */
 #define CPUIDLE_METHOD_OF_DECLARE(name, _method, _ops)			\
 	static const struct of_cpuidle_method __cpuidle_method_of_table_##name \
-	__used __section("__cpuidle_method_of_table")			\
+	__cpuidle_method_section = { .method = _method, .ops = _ops }
-	= { .method = _method, .ops = _ops }
 extern int arm_cpuidle_suspend(int index);

arch/arm/mach-imx/pm-imx27.c+1−0

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <linux/suspend.h>	12	#include <linux/suspend.h>
13	#include <linux/io.h>	13	#include <linux/io.h>
14		14
		15	#include "common.h"
15	#include "hardware.h"	16	#include "hardware.h"
16		17
17	static int mx27_suspend_enter(suspend_state_t state)	18	static int mx27_suspend_enter(suspend_state_t state)

arch/arm/mach-omap1/board-ams-delta.c+0−14

@@ -458,20 +458,6 @@ static struct gpiod_lookup_table leds_gpio_table = { · 457 unmodified lines
458		458
459	#ifdef CONFIG_LEDS_TRIGGERS	459	#ifdef CONFIG_LEDS_TRIGGERS
460	DEFINE_LED_TRIGGER(ams_delta_camera_led_trigger);	460	DEFINE_LED_TRIGGER(ams_delta_camera_led_trigger);
461
462	static int ams_delta_camera_power(struct device *dev, int power)
463	{
464	/*
465	* turn on camera LED
466	*/
467	if (power)
468	led_trigger_event(ams_delta_camera_led_trigger, LED_FULL);
469	else
470	led_trigger_event(ams_delta_camera_led_trigger, LED_OFF);
471	return 0;
472	}
473	#else
474	#define ams_delta_camera_power NULL
475	#endif	461	#endif
476		462
477	static struct platform_device ams_delta_audio_device = {	463	static struct platform_device ams_delta_audio_device = {

arch/arm/mach-omap1/board-h2.c+3−1

 {
 	if (!IS_BUILTIN(CONFIG_TPS65010))
 		return -ENOSYS;
 	tps65010_config_vregs1(TPS_LDO2_ENABLE | TPS_VLDO2_3_0V |
 				TPS_LDO1_ENABLE | TPS_VLDO1_3_0V);
 	BUG_ON(gpio_request(H2_NAND_RB_GPIO_PIN, "NAND ready") < 0);
 	gpio_direction_input(H2_NAND_RB_GPIO_PIN);
+	gpiod_add_lookup_table(&isp1301_gpiod_table);
 	omap_cfg_reg(L3_1610_FLASH_CS2B_OE);
 	omap_cfg_reg(M8_1610_FLASH_CS2B_WE);

arch/arm/mach-omap1/pm.c+7−3

@@ -655,9 +655,13 @@ static int __init omap_pm_init(void) · 654 unmodified lines
655	irq = INT_7XX_WAKE_UP_REQ;	655	irq = INT_7XX_WAKE_UP_REQ;
656	else if (cpu_is_omap16xx())	656	else if (cpu_is_omap16xx())
657	irq = INT_1610_WAKE_UP_REQ;	657	irq = INT_1610_WAKE_UP_REQ;
658	if (request_irq(irq, omap_wakeup_interrupt, 0, "peripheral wakeup",	658	else
659	NULL))	659	irq = -1;
660	pr_err("Failed to request irq %d (peripheral wakeup)\n", irq);	660
		661	if (irq >= 0) {
		662	if (request_irq(irq, omap_wakeup_interrupt, 0, "peripheral wakeup", NULL))
		663	pr_err("Failed to request irq %d (peripheral wakeup)\n", irq);
		664	}
661		665
662	/* Program new power ramp-up time	666	/* Program new power ramp-up time
663	* (0 for most boards since we don't lower voltage when in deep sleep)	667	* (0 for most boards since we don't lower voltage when in deep sleep)

arch/arm/mach-omap2/board-n8x0.c+1−1

 static void n8x0_mmc_callback(void *data, u8 card_mask)
 {
+#ifdef CONFIG_MMC_OMAP
 	int bit, *openp, index;
 	if (board_is_n800()) {
 	else
 		*openp = 0;
-#ifdef CONFIG_MMC_OMAP
 	omap_mmc_notify_cover_event(mmc_device, index, *openp);
 #else
 	pr_warn("MMC: notify cover event not available\n");

arch/arm64/Kconfig.platforms+1−0

@@ -165,6 +165,7 @@ config ARCH_MEDIATEK · 164 unmodified lines
165		165
166	config ARCH_MESON	166	config ARCH_MESON
167	bool "Amlogic Platforms"	167	bool "Amlogic Platforms"
		168	select COMMON_CLK
168	select MESON_IRQ_GPIO	169	select MESON_IRQ_GPIO
169	help	170	help
170	This enables support for the arm64 based Amlogic SoCs	171	This enables support for the arm64 based Amlogic SoCs

arch/arm64/boot/dts/freescale/fsl-ls1028a-kontron-sl28-var1.dts+2−1

@@ -46,7 +46,8 @@ · 45 unmodified lines
46	eee-broken-100tx;	46	eee-broken-100tx;
47	qca,clk-out-frequency = <125000000>;	47	qca,clk-out-frequency = <125000000>;
48	qca,clk-out-strength = <AR803X_STRENGTH_FULL>;	48	qca,clk-out-strength = <AR803X_STRENGTH_FULL>;
49	vddio-supply = <&vddh>;	49	qca,keep-pll-enabled;
		50	vddio-supply = <&vddio>;
50		51
51	vddio: vddio-regulator {	52	vddio: vddio-regulator {
52	regulator-name = "VDDIO";	53	regulator-name = "VDDIO";

arch/arm64/boot/dts/freescale/fsl-ls1028a-kontron-sl28-var4.dts+2−3

@@ -31,11 +31,10 @@ · 30 unmodified lines
31	reg = <0x4>;	31	reg = <0x4>;
32	eee-broken-1000t;	32	eee-broken-1000t;
33	eee-broken-100tx;	33	eee-broken-100tx;
34
35	qca,clk-out-frequency = <125000000>;	34	qca,clk-out-frequency = <125000000>;
36	qca,clk-out-strength = <AR803X_STRENGTH_FULL>;	35	qca,clk-out-strength = <AR803X_STRENGTH_FULL>;
37		36	qca,keep-pll-enabled;
38	vddio-supply = <&vddh>;	37	vddio-supply = <&vddio>;
39		38
40	vddio: vddio-regulator {	39	vddio: vddio-regulator {
41	regulator-name = "VDDIO";	40	regulator-name = "VDDIO";

arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi+2−2

@@ -197,8 +197,8 @@ · 196 unmodified lines
197	ddr: memory-controller@1080000 {	197	ddr: memory-controller@1080000 {
198	compatible = "fsl,qoriq-memory-controller";	198	compatible = "fsl,qoriq-memory-controller";
199	reg = <0x0 0x1080000 0x0 0x1000>;	199	reg = <0x0 0x1080000 0x0 0x1000>;
200	interrupts = <GIC_SPI 144 IRQ_TYPE_LEVEL_HIGH>;	200	interrupts = <GIC_SPI 17 IRQ_TYPE_LEVEL_HIGH>;
201	big-endian;	201	little-endian;
202	};	202	};
203		203
204	dcfg: syscon@1e00000 {	204	dcfg: syscon@1e00000 {

arch/arm64/boot/dts/freescale/imx8mq-zii-ultra-rmb3.dts+5−5

@@ -88,11 +88,11 @@ · 87 unmodified lines
88	pinctrl-0 = <&pinctrl_codec2>;	88	pinctrl-0 = <&pinctrl_codec2>;
89	reg = <0x18>;	89	reg = <0x18>;
90	#sound-dai-cells = <0>;	90	#sound-dai-cells = <0>;
91	HPVDD-supply = <&reg_3p3v>;	91	HPVDD-supply = <&reg_gen_3p3>;
92	SPRVDD-supply = <&reg_3p3v>;	92	SPRVDD-supply = <&reg_gen_3p3>;
93	SPLVDD-supply = <&reg_3p3v>;	93	SPLVDD-supply = <&reg_gen_3p3>;
94	AVDD-supply = <&reg_3p3v>;	94	AVDD-supply = <&reg_gen_3p3>;
95	IOVDD-supply = <&reg_3p3v>;	95	IOVDD-supply = <&reg_gen_3p3>;
96	DVDD-supply = <&vgen4_reg>;	96	DVDD-supply = <&vgen4_reg>;
97	reset-gpios = <&gpio3 4 GPIO_ACTIVE_HIGH>;	97	reset-gpios = <&gpio3 4 GPIO_ACTIVE_HIGH>;
98	};	98	};

arch/arm64/boot/dts/freescale/imx8mq-zii-ultra.dtsi+7−16

 	reg_12p0_main: regulator-12p0-main {
 		compatible = "regulator-fixed";
 		regulator-name = "12V_MAIN";
-		regulator-min-microvolt = <5000000>;
+		regulator-min-microvolt = <12000000>;
-		regulator-max-microvolt = <5000000>;
+		regulator-max-microvolt = <12000000>;
 		regulator-always-on;
 	};
 		regulator-always-on;
 	};
-	reg_3p3v: regulator-3p3v {
-		compatible = "regulator-fixed";
-		vin-supply = <&reg_3p3_main>;
-		regulator-name = "GEN_3V3";
-		regulator-min-microvolt = <3300000>;
-		regulator-max-microvolt = <3300000>;
-		regulator-always-on;
-	};
 	reg_usdhc2_vmmc: regulator-vsd-3v3 {
 		pinctrl-names = "default";
 		pinctrl-0 = <&pinctrl_reg_usdhc2>;
 		pinctrl-0 = <&pinctrl_codec1>;
 		reg = <0x18>;
 		#sound-dai-cells = <0>;
-		HPVDD-supply = <&reg_3p3v>;
+		HPVDD-supply = <&reg_gen_3p3>;
-		SPRVDD-supply = <&reg_3p3v>;
+		SPRVDD-supply = <&reg_gen_3p3>;
-		SPLVDD-supply = <&reg_3p3v>;
+		SPLVDD-supply = <&reg_gen_3p3>;
-		AVDD-supply = <&reg_3p3v>;
+		AVDD-supply = <&reg_gen_3p3>;
-		IOVDD-supply = <&reg_3p3v>;
+		IOVDD-supply = <&reg_gen_3p3>;
 		DVDD-supply = <&vgen4_reg>;
 		reset-gpios = <&gpio3 3 GPIO_ACTIVE_LOW>;
 	};

arch/arm64/boot/dts/ti/k3-am64-main.dtsi+6−5

 		};
 	};
-	dmss: dmss {
+	dmss: bus@48000000 {
 		compatible = "simple-mfd";
 		#address-cells = <2>;
 		#size-cells = <2>;
 		dma-ranges;
-		ranges;
+		ranges = <0x00 0x48000000 0x00 0x48000000 0x00 0x06400000>;
 		ti,sci-dev-id = <25>;
 		};
 	};
-	dmsc: dmsc@44043000 {
+	dmsc: system-controller@44043000 {
 		compatible = "ti,k2g-sci";
 		ti,host-id = <12>;
 		mbox-names = "rx", "tx";
 			#power-domain-cells = <2>;
 		};
-		k3_clks: clocks {
+		k3_clks: clock-controller {
 			compatible = "ti,k2g-sci-clk";
 			#clock-cells = <2>;
 		};
 		clocks = <&k3_clks 145 0>;
 	};
-	main_gpio_intr: interrupt-controller0 {
+	main_gpio_intr: interrupt-controller@a00000 {
 		compatible = "ti,sci-intr";
+		reg = <0x00 0x00a00000 0x00 0x800>;
 		ti,intr-trigger-type = <1>;
 		interrupt-controller;
 		interrupt-parent = <&gic500>;

arch/arm64/boot/dts/ti/k3-am64-mcu.dtsi+2−1

 		clocks = <&k3_clks 148 0>;
 	};
-	mcu_gpio_intr: interrupt-controller1 {
+	mcu_gpio_intr: interrupt-controller@4210000 {
 		compatible = "ti,sci-intr";
+		reg = <0x00 0x04210000 0x00 0x200>;
 		ti,intr-trigger-type = <1>;
 		interrupt-controller;
 		interrupt-parent = <&gic500>;

arch/arm64/boot/dts/ti/k3-am65-main.dtsi+6−4

 		#phy-cells = <0>;
 	};
-	intr_main_gpio: interrupt-controller0 {
+	intr_main_gpio: interrupt-controller@a00000 {
 		compatible = "ti,sci-intr";
+		reg = <0x0 0x00a00000 0x0 0x400>;
 		ti,intr-trigger-type = <1>;
 		interrupt-controller;
 		interrupt-parent = <&gic500>;
 		ti,interrupt-ranges = <0 392 32>;
 	};
-	main-navss {
+	main_navss: bus@30800000 {
 		compatible = "simple-mfd";
 		#address-cells = <2>;
 		#size-cells = <2>;
-		ranges;
+		ranges = <0x0 0x30800000 0x0 0x30800000 0x0 0xbc00000>;
 		dma-coherent;
 		dma-ranges;
 		ti,sci-dev-id = <118>;
-		intr_main_navss: interrupt-controller1 {
+		intr_main_navss: interrupt-controller@310e0000 {
 			compatible = "ti,sci-intr";
+			reg = <0x0 0x310e0000 0x0 0x2000>;
 			ti,intr-trigger-type = <4>;
 			interrupt-controller;
 			interrupt-parent = <&gic500>;

arch/arm64/boot/dts/ti/k3-am65-mcu.dtsi+2−2

@@ -116,11 +116,11 @@ · 115 unmodified lines
116	};	116	};
117	};	117	};
118		118
119	mcu-navss {	119	mcu_navss: bus@28380000 {
120	compatible = "simple-mfd";	120	compatible = "simple-mfd";
121	#address-cells = <2>;	121	#address-cells = <2>;
122	#size-cells = <2>;	122	#size-cells = <2>;
123	ranges;	123	ranges = <0x00 0x28380000 0x00 0x28380000 0x00 0x03880000>;
124	dma-coherent;	124	dma-coherent;
125	dma-ranges;	125	dma-ranges;
126		126

arch/arm64/boot/dts/ti/k3-am65-wakeup.dtsi+7−6

  */
 &cbass_wakeup {
-	dmsc: dmsc {
+	dmsc: system-controller@44083000 {
 		compatible = "ti,am654-sci";
 		ti,host-id = <12>;
-		#address-cells = <1>;
-		#size-cells = <1>;
-		ranges;
 		mbox-names = "rx", "tx";
 		mboxes= <&secure_proxy_main 11>,
 			<&secure_proxy_main 13>;
+		reg-names = "debug_messages";
+		reg = <0x44083000 0x1000>;
 		k3_pds: power-controller {
 			compatible = "ti,sci-pm-domain";
 			#power-domain-cells = <2>;
 		};
-		k3_clks: clocks {
+		k3_clks: clock-controller {
 			compatible = "ti,k2g-sci-clk";
 			#clock-cells = <2>;
 		};
 		power-domains = <&k3_pds 115 TI_SCI_PD_EXCLUSIVE>;
 	};
-	intr_wkup_gpio: interrupt-controller2 {
+	intr_wkup_gpio: interrupt-controller@42200000 {
 		compatible = "ti,sci-intr";
+		reg = <0x42200000 0x200>;
 		ti,intr-trigger-type = <1>;
 		interrupt-controller;
 		interrupt-parent = <&gic500>;

arch/arm64/boot/dts/ti/k3-am654-base-board.dts+0−31

@@ -85,12 +85,6 @@ · 84 unmodified lines
85	gpios = <&wkup_gpio0 27 GPIO_ACTIVE_LOW>;	85	gpios = <&wkup_gpio0 27 GPIO_ACTIVE_LOW>;
86	};	86	};
87	};	87	};
88
89	clk_ov5640_fixed: clock {
90	compatible = "fixed-clock";
91	#clock-cells = <0>;
92	clock-frequency = <24000000>;
93	};
94	};	88	};
95		89
96	&wkup_pmx0 {	90	&wkup_pmx0 {
@@ -287,23 +281,6 @@ · 190 unmodified lines
287	pinctrl-names = "default";	281	pinctrl-names = "default";
288	pinctrl-0 = <&main_i2c1_pins_default>;	282	pinctrl-0 = <&main_i2c1_pins_default>;
289	clock-frequency = <400000>;	283	clock-frequency = <400000>;
290
291	ov5640: camera@3c {
292	compatible = "ovti,ov5640";
293	reg = <0x3c>;
294
295	clocks = <&clk_ov5640_fixed>;
296	clock-names = "xclk";
297
298	port {
299	csi2_cam0: endpoint {
300	remote-endpoint = <&csi2_phy0>;
301	clock-lanes = <0>;
302	data-lanes = <1 2>;
303	};
304	};
305	};
306
307	};	284	};
308		285
309	&main_i2c2 {	286	&main_i2c2 {
@@ -496,14 +473,6 @@ · 186 unmodified lines
496	};	473	};
497	};	474	};
498		475
499	&csi2_0 {
500	csi2_phy0: endpoint {
501	remote-endpoint = <&csi2_cam0>;
502	clock-lanes = <0>;
503	data-lanes = <1 2>;
504	};
505	};
506
507	&mcu_cpsw {	476	&mcu_cpsw {
508	pinctrl-names = "default";	477	pinctrl-names = "default";
509	pinctrl-0 = <&mcu_cpsw_pins_default &mcu_mdio_pins_default>;	478	pinctrl-0 = <&mcu_cpsw_pins_default &mcu_mdio_pins_default>;

arch/arm64/boot/dts/ti/k3-j7200-main.dtsi+6−2

 		};
 	};
-	main_gpio_intr: interrupt-controller0 {
+	main_gpio_intr: interrupt-controller@a00000 {
 		compatible = "ti,sci-intr";
+		reg = <0x00 0x00a00000 0x00 0x800>;
 		ti,intr-trigger-type = <1>;
 		interrupt-controller;
 		interrupt-parent = <&gic500>;
 		#size-cells = <2>;
 		ranges = <0x00 0x30000000 0x00 0x30000000 0x00 0x0c400000>;
 		ti,sci-dev-id = <199>;
+		dma-coherent;
+		dma-ranges;
-		main_navss_intr: interrupt-controller1 {
+		main_navss_intr: interrupt-controller@310e0000 {
 			compatible = "ti,sci-intr";
+			reg = <0x00 0x310e0000 0x00 0x4000>;
 			ti,intr-trigger-type = <4>;
 			interrupt-controller;
 			interrupt-parent = <&gic500>;

arch/arm64/boot/dts/ti/k3-j7200-mcu-wakeup.dtsi+4−3

  */
 &cbass_mcu_wakeup {
-	dmsc: dmsc@44083000 {
+	dmsc: system-controller@44083000 {
 		compatible = "ti,k2g-sci";
 		ti,host-id = <12>;
 			#power-domain-cells = <2>;
 		};
-		k3_clks: clocks {
+		k3_clks: clock-controller {
 			compatible = "ti,k2g-sci-clk";
 			#clock-cells = <2>;
 		};
 		clock-names = "fclk";
 	};
-	wkup_gpio_intr: interrupt-controller2 {
+	wkup_gpio_intr: interrupt-controller@42200000 {
 		compatible = "ti,sci-intr";
+		reg = <0x00 0x42200000 0x00 0x400>;
 		ti,intr-trigger-type = <1>;
 		interrupt-controller;
 		interrupt-parent = <&gic500>;

arch/arm64/boot/dts/ti/k3-j721e-main.dtsi+6−4

 		};
 	};
-	main_gpio_intr: interrupt-controller0 {
+	main_gpio_intr: interrupt-controller@a00000 {
 		compatible = "ti,sci-intr";
+		reg = <0x00 0x00a00000 0x00 0x800>;
 		ti,intr-trigger-type = <1>;
 		interrupt-controller;
 		interrupt-parent = <&gic500>;
 		ti,interrupt-ranges = <8 392 56>;
 	};
-	main-navss {
+	main_navss: bus@30000000 {
 		compatible = "simple-mfd";
 		#address-cells = <2>;
 		#size-cells = <2>;
-		ranges;
+		ranges = <0x00 0x30000000 0x00 0x30000000 0x00 0x0c400000>;
 		dma-coherent;
 		dma-ranges;
 		ti,sci-dev-id = <199>;
-		main_navss_intr: interrupt-controller1 {
+		main_navss_intr: interrupt-controller@310e0000 {
 			compatible = "ti,sci-intr";
+			reg = <0x0 0x310e0000 0x0 0x4000>;
 			ti,intr-trigger-type = <4>;
 			interrupt-controller;
 			interrupt-parent = <&gic500>;

arch/arm64/boot/dts/ti/k3-j721e-mcu-wakeup.dtsi+6−5

  */
 &cbass_mcu_wakeup {
-	dmsc: dmsc@44083000 {
+	dmsc: system-controller@44083000 {
 		compatible = "ti,k2g-sci";
 		ti,host-id = <12>;
 			#power-domain-cells = <2>;
 		};
-		k3_clks: clocks {
+		k3_clks: clock-controller {
 			compatible = "ti,k2g-sci-clk";
 			#clock-cells = <2>;
 		};
 		clock-names = "fclk";
 	};
-	wkup_gpio_intr: interrupt-controller2 {
+	wkup_gpio_intr: interrupt-controller@42200000 {
 		compatible = "ti,sci-intr";
+		reg = <0x00 0x42200000 0x00 0x400>;
 		ti,intr-trigger-type = <1>;
 		interrupt-controller;
 		interrupt-parent = <&gic500>;
 		};
 	};
-	mcu-navss {
+	mcu_navss: bus@28380000 {
 		compatible = "simple-mfd";
 		#address-cells = <2>;
 		#size-cells = <2>;
-		ranges;
+		ranges = <0x00 0x28380000 0x00 0x28380000 0x00 0x03880000>;
 		dma-coherent;
 		dma-ranges;

arch/mips/mm/cache.c+14−16

@@ -158,31 +158,29 @@ unsigned long _page_cachable_default; · 157 unmodified lines
158	EXPORT_SYMBOL(_page_cachable_default);	158	EXPORT_SYMBOL(_page_cachable_default);
159		159
160	#define PM(p) __pgprot(_page_cachable_default \| (p))	160	#define PM(p) __pgprot(_page_cachable_default \| (p))
161	#define PVA(p) PM(_PAGE_VALID \| _PAGE_ACCESSED \| (p))
162		161
163	static inline void setup_protection_map(void)	162	static inline void setup_protection_map(void)
164	{	163	{
165	protection_map[0] = PM(_PAGE_PRESENT \| _PAGE_NO_EXEC \| _PAGE_NO_READ);	164	protection_map[0] = PM(_PAGE_PRESENT \| _PAGE_NO_EXEC \| _PAGE_NO_READ);
166	protection_map[1] = PVA(_PAGE_PRESENT \| _PAGE_NO_EXEC);	165	protection_map[1] = PM(_PAGE_PRESENT \| _PAGE_NO_EXEC);
167	protection_map[2] = PVA(_PAGE_PRESENT \| _PAGE_NO_EXEC \| _PAGE_NO_READ);	166	protection_map[2] = PM(_PAGE_PRESENT \| _PAGE_NO_EXEC \| _PAGE_NO_READ);
168	protection_map[3] = PVA(_PAGE_PRESENT \| _PAGE_NO_EXEC);	167	protection_map[3] = PM(_PAGE_PRESENT \| _PAGE_NO_EXEC);
169	protection_map[4] = PVA(_PAGE_PRESENT);	168	protection_map[4] = PM(_PAGE_PRESENT);
170	protection_map[5] = PVA(_PAGE_PRESENT);	169	protection_map[5] = PM(_PAGE_PRESENT);
171	protection_map[6] = PVA(_PAGE_PRESENT);	170	protection_map[6] = PM(_PAGE_PRESENT);
172	protection_map[7] = PVA(_PAGE_PRESENT);	171	protection_map[7] = PM(_PAGE_PRESENT);
173		172
174	protection_map[8] = PM(_PAGE_PRESENT \| _PAGE_NO_EXEC \| _PAGE_NO_READ);	173	protection_map[8] = PM(_PAGE_PRESENT \| _PAGE_NO_EXEC \| _PAGE_NO_READ);
175	protection_map[9] = PVA(_PAGE_PRESENT \| _PAGE_NO_EXEC);	174	protection_map[9] = PM(_PAGE_PRESENT \| _PAGE_NO_EXEC);
176	protection_map[10] = PVA(_PAGE_PRESENT \| _PAGE_NO_EXEC \| _PAGE_WRITE \|	175	protection_map[10] = PM(_PAGE_PRESENT \| _PAGE_NO_EXEC \| _PAGE_WRITE \|
177	_PAGE_NO_READ);	176	_PAGE_NO_READ);
178	protection_map[11] = PVA(_PAGE_PRESENT \| _PAGE_NO_EXEC \| _PAGE_WRITE);	177	protection_map[11] = PM(_PAGE_PRESENT \| _PAGE_NO_EXEC \| _PAGE_WRITE);
179	protection_map[12] = PVA(_PAGE_PRESENT);	178	protection_map[12] = PM(_PAGE_PRESENT);
180	protection_map[13] = PVA(_PAGE_PRESENT);	179	protection_map[13] = PM(_PAGE_PRESENT);
181	protection_map[14] = PVA(_PAGE_PRESENT);	180	protection_map[14] = PM(_PAGE_PRESENT \| _PAGE_WRITE);
182	protection_map[15] = PVA(_PAGE_PRESENT);	181	protection_map[15] = PM(_PAGE_PRESENT \| _PAGE_WRITE);
183	}	182	}
184		183
185	#undef _PVA
186	#undef PM	184	#undef PM
187		185
188	void cpu_cache_init(void)	186	void cpu_cache_init(void)

arch/powerpc/include/asm/pte-walk.h+29−0

@@ -31,6 +31,35 @@ static inline pte_t find_init_mm_pte(unsigned long ea, unsigned hshift) · 30 unmodified lines
31	pgd_t *pgdir = init_mm.pgd;	31	pgd_t *pgdir = init_mm.pgd;
32	return __find_linux_pte(pgdir, ea, NULL, hshift);	32	return __find_linux_pte(pgdir, ea, NULL, hshift);
33	}	33	}
		34
		35	/*
		36	* Convert a kernel vmap virtual address (vmalloc or ioremap space) to a
		37	* physical address, without taking locks. This can be used in real-mode.
		38	*/
		39	static inline phys_addr_t ppc_find_vmap_phys(unsigned long addr)
		40	{
		41	pte_t *ptep;
		42	phys_addr_t pa;
		43	int hugepage_shift;
		44
		45	/*
		46	* init_mm does not free page tables, and does not do THP. It may
		47	* have huge pages from huge vmalloc / ioremap etc.
		48	*/
		49	ptep = find_init_mm_pte(addr, &hugepage_shift);
		50	if (WARN_ON(!ptep))
		51	return 0;
		52
		53	pa = PFN_PHYS(pte_pfn(*ptep));
		54
		55	if (!hugepage_shift)
		56	hugepage_shift = PAGE_SHIFT;
		57
		58	pa \|= addr & ((1ul << hugepage_shift) - 1);
		59
		60	return pa;
		61	}
		62
34	/*	63	/*
35	* This is what we should always use. Any other lockless page table lookup needs	64	* This is what we should always use. Any other lockless page table lookup needs
36	* careful audit against THP split.	65	* careful audit against THP split.

arch/powerpc/kernel/eeh.c+1−22

@@ -346,28 +346,7 @@ void eeh_slot_error_detail(struct eeh_pe *pe, int severity) · 345 unmodified lines
346	*/	346	*/
347	static inline unsigned long eeh_token_to_phys(unsigned long token)	347	static inline unsigned long eeh_token_to_phys(unsigned long token)
348	{	348	{
349	pte_t *ptep;	349	return ppc_find_vmap_phys(token);
350	unsigned long pa;
351	int hugepage_shift;
352
353	/*
354	* We won't find hugepages here(this is iomem). Hence we are not
355	* worried about _PAGE_SPLITTING/collapse. Also we will not hit
356	* page table free, because of init_mm.
357	*/
358	ptep = find_init_mm_pte(token, &hugepage_shift);
359	if (!ptep)
360	return token;
361
362	pa = pte_pfn(*ptep);
363
364	/* On radix we can do hugepage mappings for io, so handle that */
365	if (!hugepage_shift)
366	hugepage_shift = PAGE_SHIFT;
367
368	pa <<= PAGE_SHIFT;
369	pa \|= token & ((1ul << hugepage_shift) - 1);
370	return pa;
371	}	350	}
372		351
373	/*	352	/*

arch/powerpc/kernel/io-workarounds.c+3−13

@@ -55,7 +55,6 @@ static struct iowa_bus *iowa_pci_find(unsigned long vaddr, unsigned long paddr) · 54 unmodified lines
55	#ifdef CONFIG_PPC_INDIRECT_MMIO	55	#ifdef CONFIG_PPC_INDIRECT_MMIO
56	struct iowa_bus *iowa_mem_find_bus(const PCI_IO_ADDR addr)	56	struct iowa_bus *iowa_mem_find_bus(const PCI_IO_ADDR addr)
57	{	57	{
58	unsigned hugepage_shift;
59	struct iowa_bus *bus;	58	struct iowa_bus *bus;
60	int token;	59	int token;
61		60
@@ -65,22 +64,13 @@ struct iowa_bus *iowa_mem_find_bus(const PCI_IO_ADDR addr) · 3 unmodified lines
65	bus = &iowa_busses[token - 1];	64	bus = &iowa_busses[token - 1];
66	else {	65	else {
67	unsigned long vaddr, paddr;	66	unsigned long vaddr, paddr;
68	pte_t *ptep;
69		67
70	vaddr = (unsigned long)PCI_FIX_ADDR(addr);	68	vaddr = (unsigned long)PCI_FIX_ADDR(addr);
71	if (vaddr < PHB_IO_BASE \|\| vaddr >= PHB_IO_END)	69	if (vaddr < PHB_IO_BASE \|\| vaddr >= PHB_IO_END)
72	return NULL;	70	return NULL;
73	/*	71
74	* We won't find huge pages here (iomem). Also can't hit	72	paddr = ppc_find_vmap_phys(vaddr);
75	* a page table free due to init_mm	73
76	*/
77	ptep = find_init_mm_pte(vaddr, &hugepage_shift);
78	if (ptep == NULL)
79	paddr = 0;
80	else {
81	WARN_ON(hugepage_shift);
82	paddr = pte_pfn(*ptep) << PAGE_SHIFT;
83	}
84	bus = iowa_pci_find(vaddr, paddr);	74	bus = iowa_pci_find(vaddr, paddr);
85		75
86	if (bus == NULL)	76	if (bus == NULL)

arch/powerpc/kernel/iommu.c+5−6

 	unsigned int order;
 	unsigned int nio_pages, io_order;
 	struct page *page;
-	size_t size_io = size;
 	size = PAGE_ALIGN(size);
 	order = get_order(size);
 	memset(ret, 0, size);
 	/* Set up tces to cover the allocated range */
-	size_io = IOMMU_PAGE_ALIGN(size_io, tbl);
+	nio_pages = size >> tbl->it_page_shift;
-	nio_pages = size_io >> tbl->it_page_shift;
+	io_order = get_iommu_order(size, tbl);
-	io_order = get_iommu_order(size_io, tbl);
 	mapping = iommu_alloc(dev, tbl, ret, nio_pages, DMA_BIDIRECTIONAL,
 			      mask >> tbl->it_page_shift, io_order, 0);
 	if (mapping == DMA_MAPPING_ERROR) {
 			 void *vaddr, dma_addr_t dma_handle)
 {
 	if (tbl) {
-		size_t size_io = IOMMU_PAGE_ALIGN(size, tbl);
+		unsigned int nio_pages;
-		unsigned int nio_pages = size_io >> tbl->it_page_shift;
+		size = PAGE_ALIGN(size);
+		nio_pages = size >> tbl->it_page_shift;
 		iommu_free(tbl, dma_handle, nio_pages);
 		size = PAGE_ALIGN(size);
 		free_pages((unsigned long)vaddr, get_order(size));

arch/powerpc/kernel/kprobes.c+2−2

 	int ret = 0;
 	struct kprobe *prev;
 	struct ppc_inst insn = ppc_inst_read((struct ppc_inst *)p->addr);
-	struct ppc_inst prefix = ppc_inst_read((struct ppc_inst *)(p->addr - 1));
 	if ((unsigned long)p->addr & 0x03) {
 		printk("Attempt to register kprobe at an unaligned address\n");
 	} else if (IS_MTMSRD(insn) || IS_RFID(insn) || IS_RFI(insn)) {
 		printk("Cannot register a kprobe on rfi/rfid or mtmsr[d]\n");
 		ret = -EINVAL;
-	} else if (ppc_inst_prefixed(prefix)) {
+	} else if ((unsigned long)p->addr & ~PAGE_MASK &&
+		   ppc_inst_prefixed(ppc_inst_read((struct ppc_inst *)(p->addr - 1)))) {
 		printk("Cannot register a kprobe on the second word of prefixed instruction\n");
 		ret = -EINVAL;
 	}

arch/powerpc/kvm/book3s_hv.c+0−1

@@ -4455,7 +4455,6 @@ static int kvmppc_vcpu_run_hv(struct kvm_vcpu *vcpu) · 4454 unmodified lines
4455	mtspr(SPRN_EBBRR, ebb_regs[1]);	4455	mtspr(SPRN_EBBRR, ebb_regs[1]);
4456	mtspr(SPRN_BESCR, ebb_regs[2]);	4456	mtspr(SPRN_BESCR, ebb_regs[2]);
4457	mtspr(SPRN_TAR, user_tar);	4457	mtspr(SPRN_TAR, user_tar);
4458	mtspr(SPRN_FSCR, current->thread.fscr);
4459	}	4458	}
4460	mtspr(SPRN_VRSAVE, user_vrsave);	4459	mtspr(SPRN_VRSAVE, user_vrsave);
4461		4460

arch/powerpc/kvm/book3s_hv_rm_mmu.c+2−13

@@ -23,20 +23,9 @@ · 22 unmodified lines
23	#include <asm/pte-walk.h>	23	#include <asm/pte-walk.h>
24		24
25	/* Translate address of a vmalloc'd thing to a linear map address */	25	/* Translate address of a vmalloc'd thing to a linear map address */
26	static void real_vmalloc_addr(void x)	26	static void real_vmalloc_addr(void addr)
27	{	27	{
28	unsigned long addr = (unsigned long) x;	28	return __va(ppc_find_vmap_phys((unsigned long)addr));
29	pte_t *p;
30	/*
31	* assume we don't have huge pages in vmalloc space...
32	* So don't worry about THP collapse/split. Called
33	* Only in realmode with MSR_EE = 0, hence won't need irq_save/restore.
34	*/
35	p = find_init_mm_pte(addr, NULL);
36	if (!p \|\| !pte_present(*p))
37	return NULL;
38	addr = (pte_pfn(*p) << PAGE_SHIFT) \| (addr & ~PAGE_MASK);
39	return __va(addr);
40	}	29	}
41		30
42	/* Return 1 if we need to do a global tlbie, 0 if we can use tlbiel */	31	/* Return 1 if we need to do a global tlbie, 0 if we can use tlbiel */

arch/powerpc/kvm/book3s_hv_rmhandlers.S+7−0

 #define STACK_SLOT_UAMOR	(SFS-88)
 #define STACK_SLOT_DAWR1	(SFS-96)
 #define STACK_SLOT_DAWRX1	(SFS-104)
+#define STACK_SLOT_FSCR		(SFS-112)
 /* the following is used by the P9 short path */
 #define STACK_SLOT_NVGPRS	(SFS-152)	/* 18 gprs */
 	std	r6, STACK_SLOT_DAWR0(r1)
 	std	r7, STACK_SLOT_DAWRX0(r1)
 	std	r8, STACK_SLOT_IAMR(r1)
+	mfspr	r5, SPRN_FSCR
+	std	r5, STACK_SLOT_FSCR(r1)
 END_FTR_SECTION_IFSET(CPU_FTR_ARCH_207S)
 BEGIN_FTR_SECTION
 	mfspr	r6, SPRN_DAWR1
 	ld	r7, STACK_SLOT_HFSCR(r1)
 	mtspr	SPRN_HFSCR, r7
 ALT_FTR_SECTION_END_IFCLR(CPU_FTR_ARCH_300)
+BEGIN_FTR_SECTION
+	ld	r5, STACK_SLOT_FSCR(r1)
+	mtspr	SPRN_FSCR, r5
+END_FTR_SECTION_IFSET(CPU_FTR_ARCH_207S)
 	/*
 	 * Restore various registers to 0, where non-zero values
 	 * set by the guest could disrupt the host.

arch/riscv/Kconfig+9−9

@@ -61,11 +61,11 @@ config RISCV · 60 unmodified lines
61	select GENERIC_TIME_VSYSCALL if MMU && 64BIT	61	select GENERIC_TIME_VSYSCALL if MMU && 64BIT
62	select HANDLE_DOMAIN_IRQ	62	select HANDLE_DOMAIN_IRQ
63	select HAVE_ARCH_AUDITSYSCALL	63	select HAVE_ARCH_AUDITSYSCALL
64	select HAVE_ARCH_JUMP_LABEL	64	select HAVE_ARCH_JUMP_LABEL if !XIP_KERNEL
65	select HAVE_ARCH_JUMP_LABEL_RELATIVE	65	select HAVE_ARCH_JUMP_LABEL_RELATIVE if !XIP_KERNEL
66	select HAVE_ARCH_KASAN if MMU && 64BIT	66	select HAVE_ARCH_KASAN if MMU && 64BIT
67	select HAVE_ARCH_KASAN_VMALLOC if MMU && 64BIT	67	select HAVE_ARCH_KASAN_VMALLOC if MMU && 64BIT
68	select HAVE_ARCH_KGDB	68	select HAVE_ARCH_KGDB if !XIP_KERNEL
69	select HAVE_ARCH_KGDB_QXFER_PKT	69	select HAVE_ARCH_KGDB_QXFER_PKT
70	select HAVE_ARCH_MMAP_RND_BITS if MMU	70	select HAVE_ARCH_MMAP_RND_BITS if MMU
71	select HAVE_ARCH_SECCOMP_FILTER	71	select HAVE_ARCH_SECCOMP_FILTER
@@ -80,9 +80,9 @@ config RISCV · 8 unmodified lines
80	select HAVE_GCC_PLUGINS	80	select HAVE_GCC_PLUGINS
81	select HAVE_GENERIC_VDSO if MMU && 64BIT	81	select HAVE_GENERIC_VDSO if MMU && 64BIT
82	select HAVE_IRQ_TIME_ACCOUNTING	82	select HAVE_IRQ_TIME_ACCOUNTING
83	select HAVE_KPROBES	83	select HAVE_KPROBES if !XIP_KERNEL
84	select HAVE_KPROBES_ON_FTRACE	84	select HAVE_KPROBES_ON_FTRACE if !XIP_KERNEL
85	select HAVE_KRETPROBES	85	select HAVE_KRETPROBES if !XIP_KERNEL
86	select HAVE_PCI	86	select HAVE_PCI
87	select HAVE_PERF_EVENTS	87	select HAVE_PERF_EVENTS
88	select HAVE_PERF_REGS	88	select HAVE_PERF_REGS
@@ -231,11 +231,11 @@ config ARCH_RV64I · 142 unmodified lines
231	bool "RV64I"	231	bool "RV64I"
232	select 64BIT	232	select 64BIT
233	select ARCH_SUPPORTS_INT128 if CC_HAS_INT128 && GCC_VERSION >= 50000	233	select ARCH_SUPPORTS_INT128 if CC_HAS_INT128 && GCC_VERSION >= 50000
234	select HAVE_DYNAMIC_FTRACE if MMU && $(cc-option,-fpatchable-function-entry=8)	234	select HAVE_DYNAMIC_FTRACE if !XIP_KERNEL && MMU && $(cc-option,-fpatchable-function-entry=8)
235	select HAVE_DYNAMIC_FTRACE_WITH_REGS if HAVE_DYNAMIC_FTRACE	235	select HAVE_DYNAMIC_FTRACE_WITH_REGS if HAVE_DYNAMIC_FTRACE
236	select HAVE_FTRACE_MCOUNT_RECORD	236	select HAVE_FTRACE_MCOUNT_RECORD if !XIP_KERNEL
237	select HAVE_FUNCTION_GRAPH_TRACER	237	select HAVE_FUNCTION_GRAPH_TRACER
238	select HAVE_FUNCTION_TRACER	238	select HAVE_FUNCTION_TRACER if !XIP_KERNEL
239	select SWIOTLB if MMU	239	select SWIOTLB if MMU
240		240
241	endchoice	241	endchoice

arch/riscv/Makefile+9−0

@@ -38,6 +38,15 @@ else · 37 unmodified lines
38	KBUILD_LDFLAGS += -melf32lriscv	38	KBUILD_LDFLAGS += -melf32lriscv
39	endif	39	endif
40		40
		41	ifeq ($(CONFIG_LD_IS_LLD),y)
		42	KBUILD_CFLAGS += -mno-relax
		43	KBUILD_AFLAGS += -mno-relax
		44	ifneq ($(LLVM_IAS),1)
		45	KBUILD_CFLAGS += -Wa,-mno-relax
		46	KBUILD_AFLAGS += -Wa,-mno-relax
		47	endif
		48	endif
		49
41	# ISA string setting	50	# ISA string setting
42	riscv-march-$(CONFIG_ARCH_RV32I) := rv32ima	51	riscv-march-$(CONFIG_ARCH_RV32I) := rv32ima
43	riscv-march-$(CONFIG_ARCH_RV64I) := rv64ima	52	riscv-march-$(CONFIG_ARCH_RV64I) := rv64ima

arch/riscv/boot/dts/microchip/Makefile+1−0

@@ -1,2 +1,3 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2	dtb-$(CONFIG_SOC_MICROCHIP_POLARFIRE) += microchip-mpfs-icicle-kit.dtb	2	dtb-$(CONFIG_SOC_MICROCHIP_POLARFIRE) += microchip-mpfs-icicle-kit.dtb
		3	obj-$(CONFIG_BUILTIN_DTB) += $(addsuffix .o, $(dtb-y))

arch/riscv/boot/dts/sifive/Makefile+1−0

@@ -1,3 +1,4 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0
2	dtb-$(CONFIG_SOC_SIFIVE) += hifive-unleashed-a00.dtb \	2	dtb-$(CONFIG_SOC_SIFIVE) += hifive-unleashed-a00.dtb \
3	hifive-unmatched-a00.dtb	3	hifive-unmatched-a00.dtb
		4	obj-$(CONFIG_BUILTIN_DTB) += $(addsuffix .o, $(dtb-y))

arch/riscv/errata/sifive/Makefile+1−1

@@ -1,2 +1,2 @@
1	obj-y += errata_cip_453.o	1	obj-$(CONFIG_ERRATA_SIFIVE_CIP_453) += errata_cip_453.o
2	obj-y += errata.o	2	obj-y += errata.o

arch/riscv/include/asm/alternative-macros.h+2−2

@@ -51,7 +51,7 @@ · 50 unmodified lines
51	REG_ASM " " newlen "\n" \	51	REG_ASM " " newlen "\n" \
52	".word " errata_id "\n"	52	".word " errata_id "\n"
53		53
54	#define ALT_NEW_CONSTENT(vendor_id, errata_id, enable, new_c) \	54	#define ALT_NEW_CONTENT(vendor_id, errata_id, enable, new_c) \
55	".if " __stringify(enable) " == 1\n" \	55	".if " __stringify(enable) " == 1\n" \
56	".pushsection .alternative, \"a\"\n" \	56	".pushsection .alternative, \"a\"\n" \
57	ALT_ENTRY("886b", "888f", __stringify(vendor_id), __stringify(errata_id), "889f - 888f") \	57	ALT_ENTRY("886b", "888f", __stringify(vendor_id), __stringify(errata_id), "889f - 888f") \
@@ -69,7 +69,7 @@ · 11 unmodified lines
69	"886 :\n" \	69	"886 :\n" \
70	old_c "\n" \	70	old_c "\n" \
71	"887 :\n" \	71	"887 :\n" \
72	ALT_NEW_CONSTENT(vendor_id, errata_id, enable, new_c)	72	ALT_NEW_CONTENT(vendor_id, errata_id, enable, new_c)
73		73
74	#define _ALTERNATIVE_CFG(old_c, new_c, vendor_id, errata_id, CONFIG_k) \	74	#define _ALTERNATIVE_CFG(old_c, new_c, vendor_id, errata_id, CONFIG_k) \
75	__ALTERNATIVE_CFG(old_c, new_c, vendor_id, errata_id, IS_ENABLED(CONFIG_k))	75	__ALTERNATIVE_CFG(old_c, new_c, vendor_id, errata_id, IS_ENABLED(CONFIG_k))

arch/riscv/kernel/setup.c+2−2

@@ -231,13 +231,13 @@ static void __init init_resources(void) · 230 unmodified lines
231		231
232	/* Clean-up any unused pre-allocated resources */	232	/* Clean-up any unused pre-allocated resources */
233	mem_res_sz = (num_resources - res_idx + 1) * sizeof(*mem_res);	233	mem_res_sz = (num_resources - res_idx + 1) * sizeof(*mem_res);
234	memblock_free((phys_addr_t) mem_res, mem_res_sz);	234	memblock_free(__pa(mem_res), mem_res_sz);
235	return;	235	return;
236		236
237	error:	237	error:
238	/* Better an empty resource tree than an inconsistent one */	238	/* Better an empty resource tree than an inconsistent one */
239	release_child_resources(&iomem_resource);	239	release_child_resources(&iomem_resource);
240	memblock_free((phys_addr_t) mem_res, mem_res_sz);	240	memblock_free(__pa(mem_res), mem_res_sz);
241	}	241	}
242		242
243		243

arch/riscv/kernel/traps.c+9−4

 	}
 }
+#if defined (CONFIG_XIP_KERNEL) && defined (CONFIG_RISCV_ERRATA_ALTERNATIVE)
+#define __trap_section		__section(".xip.traps")
+#else
+#define __trap_section
+#endif
 #define DO_ERROR_INFO(name, signo, code, str)				\
-asmlinkage __visible void name(struct pt_regs *regs)			\
+asmlinkage __visible __trap_section void name(struct pt_regs *regs)	\
 {									\
 	do_trap_error(regs, signo, code, regs->epc, "Oops - " str);	\
 }
 int handle_misaligned_load(struct pt_regs *regs);
 int handle_misaligned_store(struct pt_regs *regs);
-asmlinkage void do_trap_load_misaligned(struct pt_regs *regs)
+asmlinkage void __trap_section do_trap_load_misaligned(struct pt_regs *regs)
 {
 	if (!handle_misaligned_load(regs))
 		return;
 		      "Oops - load address misaligned");
 }
-asmlinkage void do_trap_store_misaligned(struct pt_regs *regs)
+asmlinkage void __trap_section do_trap_store_misaligned(struct pt_regs *regs)
 {
 	if (!handle_misaligned_store(regs))
 		return;
 	return GET_INSN_LENGTH(insn);
 }
-asmlinkage __visible void do_trap_break(struct pt_regs *regs)
+asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs)
 {
 #ifdef CONFIG_KPROBES
 	if (kprobe_single_step_handler(regs))

arch/riscv/kernel/vmlinux-xip.lds.S+14−1

@@ -99,9 +99,22 @@ SECTIONS · 98 unmodified lines
99	}	99	}
100	PERCPU_SECTION(L1_CACHE_BYTES)	100	PERCPU_SECTION(L1_CACHE_BYTES)
101		101
102	. = ALIGN(PAGE_SIZE);	102	. = ALIGN(8);
		103	.alternative : {
		104	__alt_start = .;
		105	*(.alternative)
		106	__alt_end = .;
		107	}
103	__init_end = .;	108	__init_end = .;
104		109
		110	. = ALIGN(16);
		111	.xip.traps : {
		112	__xip_traps_start = .;
		113	*(.xip.traps)
		114	__xip_traps_end = .;
		115	}
		116
		117	. = ALIGN(PAGE_SIZE);
105	.sdata : {	118	.sdata : {
106	__global_pointer$ = . + 0x800;	119	__global_pointer$ = . + 0x800;
107	(.sdata)	120	(.sdata)

arch/riscv/mm/init.c+6−2

 	unsigned long init_data_start = (unsigned long)__init_data_begin;
 	unsigned long rodata_start = (unsigned long)__start_rodata;
 	unsigned long data_start = (unsigned long)_data;
-	unsigned long max_low = (unsigned long)(__va(PFN_PHYS(max_low_pfn)));
+#if defined(CONFIG_64BIT) && defined(CONFIG_MMU)
+	unsigned long end_va = kernel_virt_addr + load_sz;
+#else
+	unsigned long end_va = (unsigned long)(__va(PFN_PHYS(max_low_pfn)));
+#endif
 	set_memory_ro(text_start, (init_text_start - text_start) >> PAGE_SHIFT);
 	set_memory_ro(init_text_start, (init_data_start - init_text_start) >> PAGE_SHIFT);
 	set_memory_nx(init_data_start, (rodata_start - init_data_start) >> PAGE_SHIFT);
 	/* rodata section is marked readonly in mark_rodata_ro */
 	set_memory_nx(rodata_start, (data_start - rodata_start) >> PAGE_SHIFT);
-	set_memory_nx(data_start, (max_low - data_start) >> PAGE_SHIFT);
+	set_memory_nx(data_start, (end_va - data_start) >> PAGE_SHIFT);
 }
 void mark_rodata_ro(void)

arch/x86/Makefile+3−2

@@ -200,8 +200,9 @@ endif · 199 unmodified lines
200	KBUILD_LDFLAGS += -m elf_$(UTS_MACHINE)	200	KBUILD_LDFLAGS += -m elf_$(UTS_MACHINE)
201		201
202	ifdef CONFIG_LTO_CLANG	202	ifdef CONFIG_LTO_CLANG
203	KBUILD_LDFLAGS += -plugin-opt=-code-model=kernel \	203	ifeq ($(shell test $(CONFIG_LLD_VERSION) -lt 130000; echo $$?),0)
204	-plugin-opt=-stack-alignment=$(if $(CONFIG_X86_32),4,8)	204	KBUILD_LDFLAGS += -plugin-opt=-stack-alignment=$(if $(CONFIG_X86_32),4,8)
		205	endif
205	endif	206	endif
206		207
207	ifdef CONFIG_X86_NEED_RELOCS	208	ifdef CONFIG_X86_NEED_RELOCS

arch/x86/events/intel/uncore_snbep.c+6−3

 						die_id = i;
 					else
 						die_id = topology_phys_to_logical_pkg(i);
+					if (die_id < 0)
+						die_id = -ENODEV;
 					map->pbus_to_dieid[bus] = die_id;
 					break;
 				}
 			i = -1;
 			if (reverse) {
 				for (bus = 255; bus >= 0; bus--) {
-					if (map->pbus_to_dieid[bus] >= 0)
+					if (map->pbus_to_dieid[bus] != -1)
 						i = map->pbus_to_dieid[bus];
 					else
 						map->pbus_to_dieid[bus] = i;
 				}
 			} else {
 				for (bus = 0; bus <= 255; bus++) {
-					if (map->pbus_to_dieid[bus] >= 0)
+					if (map->pbus_to_dieid[bus] != -1)
 						i = map->pbus_to_dieid[bus];
 					else
 						map->pbus_to_dieid[bus] = i;
 	.perf_ctr	= SNR_M2M_PCI_PMON_CTR0,
 	.event_ctl	= SNR_M2M_PCI_PMON_CTL0,
 	.event_mask	= SNBEP_PMON_RAW_EVENT_MASK,
+	.event_mask_ext	= SNR_M2M_PCI_PMON_UMASK_EXT,
 	.box_ctl	= SNR_M2M_PCI_PMON_BOX_CTL,
 	.ops		= &snr_m2m_uncore_pci_ops,
-	.format_group	= &skx_uncore_format_group,
+	.format_group	= &snr_m2m_uncore_format_group,
 };
 static struct attribute *icx_upi_uncore_formats_attr[] = {

arch/x86/include/asm/apic.h+1−0

@@ -174,6 +174,7 @@ static inline int apic_is_clustered_box(void) · 173 unmodified lines
174	extern int setup_APIC_eilvt(u8 lvt_off, u8 vector, u8 msg_type, u8 mask);	174	extern int setup_APIC_eilvt(u8 lvt_off, u8 vector, u8 msg_type, u8 mask);
175	extern void lapic_assign_system_vectors(void);	175	extern void lapic_assign_system_vectors(void);
176	extern void lapic_assign_legacy_vector(unsigned int isairq, bool replace);	176	extern void lapic_assign_legacy_vector(unsigned int isairq, bool replace);
		177	extern void lapic_update_legacy_vectors(void);
177	extern void lapic_online(void);	178	extern void lapic_online(void);
178	extern void lapic_offline(void);	179	extern void lapic_offline(void);
179	extern bool apic_needs_pit(void);	180	extern bool apic_needs_pit(void);

arch/x86/include/asm/disabled-features.h+2−5

 # define DISABLE_PTI		(1 << (X86_FEATURE_PTI & 31))
 #endif
-#ifdef CONFIG_IOMMU_SUPPORT
+/* Force disable because it's broken beyond repair */
-# define DISABLE_ENQCMD	0
+#define DISABLE_ENQCMD		(1 << (X86_FEATURE_ENQCMD & 31))
-#else
-# define DISABLE_ENQCMD (1 << (X86_FEATURE_ENQCMD & 31))
-#endif
 #ifdef CONFIG_X86_SGX
 # define DISABLE_SGX	0

arch/x86/include/asm/fpu/api.h+1−5

@@ -106,10 +106,6 @@ extern int cpu_has_xfeatures(u64 xfeatures_mask, const char **feature_name); · 105 unmodified lines
106	*/	106	*/
107	#define PASID_DISABLED 0	107	#define PASID_DISABLED 0
108		108
109	#ifdef CONFIG_IOMMU_SUPPORT
110	/* Update current's PASID MSR/state by mm's PASID. */
111	void update_pasid(void);
112	#else
113	static inline void update_pasid(void) { }	109	static inline void update_pasid(void) { }
114	#endif	110
115	#endif /* _ASM_X86_FPU_API_H */	111	#endif /* _ASM_X86_FPU_API_H */

arch/x86/include/asm/fpu/internal.h+0−7

@@ -584,13 +584,6 @@ static inline void switch_fpu_finish(struct fpu *new_fpu) · 583 unmodified lines
584	pkru_val = pk->pkru;	584	pkru_val = pk->pkru;
585	}	585	}
586	__write_pkru(pkru_val);	586	__write_pkru(pkru_val);
587
588	/*
589	* Expensive PASID MSR write will be avoided in update_pasid() because
590	* TIF_NEED_FPU_LOAD was set. And the PASID state won't be updated
591	* unless it's different from mm->pasid to reduce overhead.
592	*/
593	update_pasid();
594	}	587	}
595		588
596	#endif /* _ASM_X86_FPU_INTERNAL_H */	589	#endif /* _ASM_X86_FPU_INTERNAL_H */

arch/x86/include/asm/thermal.h+3−1

 #define _ASM_X86_THERMAL_H
 #ifdef CONFIG_X86_THERMAL_VECTOR
+void therm_lvt_init(void);
 void intel_init_thermal(struct cpuinfo_x86 *c);
 bool x86_thermal_enabled(void);
 void intel_thermal_interrupt(void);
 #else
-static inline void intel_init_thermal(struct cpuinfo_x86 *c) { }
+static inline void therm_lvt_init(void)				{ }
+static inline void intel_init_thermal(struct cpuinfo_x86 *c)	{ }
 #endif
 #endif /* _ASM_X86_THERMAL_H */

arch/x86/kernel/alternative.c+46−18

@@ -182,42 +182,70 @@ done: · 181 unmodified lines
182	n_dspl, (unsigned long)orig_insn + n_dspl + repl_len);	182	n_dspl, (unsigned long)orig_insn + n_dspl + repl_len);
183	}	183	}
184		184
		185	/*
		186	* optimize_nops_range() - Optimize a sequence of single byte NOPs (0x90)
		187	*
		188	* @instr: instruction byte stream
		189	* @instrlen: length of the above
		190	* @off: offset within @instr where the first NOP has been detected
		191	*
		192	* Return: number of NOPs found (and replaced).
		193	*/
		194	static __always_inline int optimize_nops_range(u8 *instr, u8 instrlen, int off)
		195	{
		196	unsigned long flags;
		197	int i = off, nnops;
		198
		199	while (i < instrlen) {
		200	if (instr[i] != 0x90)
		201	break;
		202
		203	i++;
		204	}
		205
		206	nnops = i - off;
		207
		208	if (nnops <= 1)
		209	return nnops;
		210
		211	local_irq_save(flags);
		212	add_nops(instr + off, nnops);
		213	local_irq_restore(flags);
		214
		215	DUMP_BYTES(instr, instrlen, "%px: [%d:%d) optimized NOPs: ", instr, off, i);
		216
		217	return nnops;
		218	}
		219
185	/*	220	/*
186	* "noinline" to cause control flow change and thus invalidate I$ and	221	* "noinline" to cause control flow change and thus invalidate I$ and
187	* cause refetch after modification.	222	* cause refetch after modification.
188	*/	223	*/
189	static void __init_or_module noinline optimize_nops(struct alt_instr a, u8 instr)	224	static void __init_or_module noinline optimize_nops(struct alt_instr a, u8 instr)
190	{	225	{
191	unsigned long flags;
192	struct insn insn;	226	struct insn insn;
193	int nop, i = 0;	227	int i = 0;
194		228
195	/*	229	/*
196	* Jump over the non-NOP insns, the remaining bytes must be single-byte	230	* Jump over the non-NOP insns and optimize single-byte NOPs into bigger
197	* NOPs, optimize them.	231	* ones.
198	*/	232	*/
199	for (;;) {	233	for (;;) {
200	if (insn_decode_kernel(&insn, &instr[i]))	234	if (insn_decode_kernel(&insn, &instr[i]))
201	return;	235	return;
202		236
		237	/*
		238	* See if this and any potentially following NOPs can be
		239	* optimized.
		240	*/
203	if (insn.length == 1 && insn.opcode.bytes[0] == 0x90)	241	if (insn.length == 1 && insn.opcode.bytes[0] == 0x90)
204	break;	242	i += optimize_nops_range(instr, a->instrlen, i);
205		243	else
206	if ((i += insn.length) >= a->instrlen)	244	i += insn.length;
207	return;
208	}
209		245
210	for (nop = i; i < a->instrlen; i++) {	246	if (i >= a->instrlen)
211	if (WARN_ONCE(instr[i] != 0x90, "Not a NOP at 0x%px\n", &instr[i]))
212	return;	247	return;
213	}	248	}
214
215	local_irq_save(flags);
216	add_nops(instr + nop, i - nop);
217	local_irq_restore(flags);
218
219	DUMP_BYTES(instr, a->instrlen, "%px: [%d:%d) optimized NOPs: ",
220	instr, nop, a->instrlen);
221	}	249	}
222		250
223	/*	251	/*

arch/x86/kernel/apic/apic.c+1−0

@@ -2604,6 +2604,7 @@ static void __init apic_bsp_setup(bool upmode) · 2603 unmodified lines
2604	end_local_APIC_setup();	2604	end_local_APIC_setup();
2605	irq_remap_enable_fault_handling();	2605	irq_remap_enable_fault_handling();
2606	setup_IO_APIC();	2606	setup_IO_APIC();
		2607	lapic_update_legacy_vectors();
2607	}	2608	}
2608		2609
2609	#ifdef CONFIG_UP_LATE_INIT	2610	#ifdef CONFIG_UP_LATE_INIT

arch/x86/kernel/apic/vector.c+20−0

@@ -738,6 +738,26 @@ void lapic_assign_legacy_vector(unsigned int irq, bool replace) · 737 unmodified lines
738	irq_matrix_assign_system(vector_matrix, ISA_IRQ_VECTOR(irq), replace);	738	irq_matrix_assign_system(vector_matrix, ISA_IRQ_VECTOR(irq), replace);
739	}	739	}
740		740
		741	void __init lapic_update_legacy_vectors(void)
		742	{
		743	unsigned int i;
		744
		745	if (IS_ENABLED(CONFIG_X86_IO_APIC) && nr_ioapics > 0)
		746	return;
		747
		748	/*
		749	* If the IO/APIC is disabled via config, kernel command line or
		750	* lack of enumeration then all legacy interrupts are routed
		751	* through the PIC. Make sure that they are marked as legacy
		752	* vectors. PIC_CASCADE_IRQ has already been marked in
		753	* lapic_assign_system_vectors().
		754	*/
		755	for (i = 0; i < nr_legacy_irqs(); i++) {
		756	if (i != PIC_CASCADE_IR)
		757	lapic_assign_legacy_vector(i, true);
		758	}
		759	}
		760
741	void __init lapic_assign_system_vectors(void)	761	void __init lapic_assign_system_vectors(void)
742	{	762	{
743	unsigned int i, vector = 0;	763	unsigned int i, vector = 0;

arch/x86/kernel/cpu/perfctr-watchdog.c+2−2

@@ -63,7 +63,7 @@ static inline unsigned int nmi_perfctr_msr_to_bit(unsigned int msr) · 62 unmodified lines
63	case 15:	63	case 15:
64	return msr - MSR_P4_BPU_PERFCTR0;	64	return msr - MSR_P4_BPU_PERFCTR0;
65	}	65	}
66	fallthrough;	66	break;
67	case X86_VENDOR_ZHAOXIN:	67	case X86_VENDOR_ZHAOXIN:
68	case X86_VENDOR_CENTAUR:	68	case X86_VENDOR_CENTAUR:
69	return msr - MSR_ARCH_PERFMON_PERFCTR0;	69	return msr - MSR_ARCH_PERFMON_PERFCTR0;
@@ -96,7 +96,7 @@ static inline unsigned int nmi_evntsel_msr_to_bit(unsigned int msr) · 26 unmodified lines
96	case 15:	96	case 15:
97	return msr - MSR_P4_BSU_ESCR0;	97	return msr - MSR_P4_BSU_ESCR0;
98	}	98	}
99	fallthrough;	99	break;
100	case X86_VENDOR_ZHAOXIN:	100	case X86_VENDOR_ZHAOXIN:
101	case X86_VENDOR_CENTAUR:	101	case X86_VENDOR_CENTAUR:
102	return msr - MSR_ARCH_PERFMON_EVENTSEL0;	102	return msr - MSR_ARCH_PERFMON_EVENTSEL0;

arch/x86/kernel/fpu/xstate.c+0−57

@@ -1402,60 +1402,3 @@ int proc_pid_arch_status(struct seq_file m, struct pid_namespace ns, · 1401 unmodified lines
1402	return 0;	1402	return 0;
1403	}	1403	}
1404	#endif /* CONFIG_PROC_PID_ARCH_STATUS */	1404	#endif /* CONFIG_PROC_PID_ARCH_STATUS */
1405
1406	#ifdef CONFIG_IOMMU_SUPPORT
1407	void update_pasid(void)
1408	{
1409	u64 pasid_state;
1410	u32 pasid;
1411
1412	if (!cpu_feature_enabled(X86_FEATURE_ENQCMD))
1413	return;
1414
1415	if (!current->mm)
1416	return;
1417
1418	pasid = READ_ONCE(current->mm->pasid);
1419	/* Set the valid bit in the PASID MSR/state only for valid pasid. */
1420	pasid_state = pasid == PASID_DISABLED ?
1421	pasid : pasid \| MSR_IA32_PASID_VALID;
1422
1423	/*
1424	* No need to hold fregs_lock() since the task's fpstate won't
1425	* be changed by others (e.g. ptrace) while the task is being
1426	* switched to or is in IPI.
1427	*/
1428	if (!test_thread_flag(TIF_NEED_FPU_LOAD)) {
1429	/* The MSR is active and can be directly updated. */
1430	wrmsrl(MSR_IA32_PASID, pasid_state);
1431	} else {
1432	struct fpu *fpu = &current->thread.fpu;
1433	struct ia32_pasid_state *ppasid_state;
1434	struct xregs_state *xsave;
1435
1436	/*
1437	* The CPU's xstate registers are not currently active. Just
1438	* update the PASID state in the memory buffer here. The
1439	* PASID MSR will be loaded when returning to user mode.
1440	*/
1441	xsave = &fpu->state.xsave;
1442	xsave->header.xfeatures \|= XFEATURE_MASK_PASID;
1443	ppasid_state = get_xsave_addr(xsave, XFEATURE_PASID);
1444	/*
1445	* Since XFEATURE_MASK_PASID is set in xfeatures, ppasid_state
1446	* won't be NULL and no need to check its value.
1447	*
1448	* Only update the task's PASID state when it's different
1449	* from the mm's pasid.
1450	*/
1451	if (ppasid_state->pasid != pasid_state) {
1452	/*
1453	* Invalid fpregs so that state restoring will pick up
1454	* the PASID state.
1455	*/
1456	__fpu_invalidate_fpregs_state(fpu);
1457	ppasid_state->pasid = pasid_state;
1458	}
1459	}
1460	}
1461	#endif /* CONFIG_IOMMU_SUPPORT */

arch/x86/kernel/setup.c+30−14

 #include <asm/pci-direct.h>
 #include <asm/prom.h>
 #include <asm/proto.h>
+#include <asm/thermal.h>
 #include <asm/unwind.h>
 #include <asm/vsyscall.h>
 #include <linux/vmalloc.h>
 	 * them from accessing certain memory ranges, namely anything below
 	 * 1M and in the pages listed in bad_pages[] above.
 	 *
-	 * To avoid these pages being ever accessed by SNB gfx devices
+	 * To avoid these pages being ever accessed by SNB gfx devices reserve
-	 * reserve all memory below the 1 MB mark and bad_pages that have
+	 * bad_pages that have not already been reserved at boot time.
-	 * not already been reserved at boot time.
+	 * All memory below the 1 MB mark is anyway reserved later during
+	 * setup_arch(), so there is no need to reserve it here.
 	 */
-	memblock_reserve(0, 1<<20);
 	for (i = 0; i < ARRAY_SIZE(bad_pages); i++) {
 		if (memblock_reserve(bad_pages[i], PAGE_SIZE))
 	 * The first 4Kb of memory is a BIOS owned area, but generally it is
 	 * not listed as such in the E820 table.
 	 *
-	 * Reserve the first memory page and typically some additional
+	 * Reserve the first 64K of memory since some BIOSes are known to
-	 * memory (64KiB by default) since some BIOSes are known to corrupt
+	 * corrupt low memory. After the real mode trampoline is allocated the
-	 * low memory. See the Kconfig help text for X86_RESERVE_LOW.
+	 * rest of the memory below 640k is reserved.
 	 *
 	 * In addition, make sure page 0 is always reserved because on
 	 * systems with L1TF its contents can be leaked to user processes.
 	 */
-	memblock_reserve(0, ALIGN(reserve_low, PAGE_SIZE));
+	memblock_reserve(0, SZ_64K);
 	early_reserve_initrd();
 	reserve_ibft_region();
 	reserve_bios_regions();
+	trim_snb_memory();
 }
 /*
 			(max_pfn_mapped<<PAGE_SHIFT) - 1);
 #endif
-	reserve_real_mode();
 	/*
-	 * Reserving memory causing GPU hangs on Sandy Bridge integrated
+	 * Find free memory for the real mode trampoline and place it
-	 * graphics devices should be done after we allocated memory under
+	 * there.
-	 * 1M for the real mode trampoline.
+	 * If there is not enough free memory under 1M, on EFI-enabled
+	 * systems there will be additional attempt to reclaim the memory
+	 * for the real mode trampoline at efi_free_boot_services().
+	 *
+	 * Unconditionally reserve the entire first 1M of RAM because
+	 * BIOSes are know to corrupt low memory and several
+	 * hundred kilobytes are not worth complex detection what memory gets
+	 * clobbered. Moreover, on machines with SandyBridge graphics or in
+	 * setups that use crashkernel the entire 1M is reserved anyway.
 	 */
-	trim_snb_memory();
+	reserve_real_mode();
 	init_mem_mapping();
 	x86_init.timers.wallclock_init();
+	/*
+	 * This needs to run before setup_local_APIC() which soft-disables the
+	 * local APIC temporarily and that masks the thermal LVT interrupt,
+	 * leading to softlockups on machines which have configured SMI
+	 * interrupt delivery.
+	 */
+	therm_lvt_init();
 	mcheck_init();
 	register_refined_jiffies(CLOCK_TICK_RATE);

arch/x86/kvm/lapic.c+11−6

 static void cancel_hv_timer(struct kvm_lapic *apic);
+static void cancel_apic_timer(struct kvm_lapic *apic)
+{
+	hrtimer_cancel(&apic->lapic_timer.timer);
+	preempt_disable();
+	if (apic->lapic_timer.hv_timer_in_use)
+		cancel_hv_timer(apic);
+	preempt_enable();
+}
 static void apic_update_lvtt(struct kvm_lapic *apic)
 {
 	u32 timer_mode = kvm_lapic_get_reg(apic, APIC_LVTT) &
 	if (apic->lapic_timer.timer_mode != timer_mode) {
 		if (apic_lvtt_tscdeadline(apic) != (timer_mode ==
 				APIC_LVT_TIMER_TSCDEADLINE)) {
-			hrtimer_cancel(&apic->lapic_timer.timer);
+			cancel_apic_timer(apic);
-			preempt_disable();
-			if (apic->lapic_timer.hv_timer_in_use)
-				cancel_hv_timer(apic);
-			preempt_enable();
 			kvm_lapic_set_reg(apic, APIC_TMICT, 0);
 			apic->lapic_timer.period = 0;
 			apic->lapic_timer.tscdeadline = 0;
 		if (apic_lvtt_tscdeadline(apic))
 			break;
-		hrtimer_cancel(&apic->lapic_timer.timer);
+		cancel_apic_timer(apic);
 		kvm_lapic_set_reg(apic, APIC_TMICT, val);
 		start_apic_timer(apic);
 		break;

arch/x86/kvm/mmu/paging_tmpl.h+9−5

 	gpa_t pte_gpa[PT_MAX_FULL_LEVELS];
 	pt_element_t __user *ptep_user[PT_MAX_FULL_LEVELS];
 	bool pte_writable[PT_MAX_FULL_LEVELS];
-	unsigned pt_access;
+	unsigned int pt_access[PT_MAX_FULL_LEVELS];
-	unsigned pte_access;
+	unsigned int pte_access;
 	gfn_t gfn;
 	struct x86_exception fault;
 };
 		}
 		walker->ptes[walker->level - 1] = pte;
+		/* Convert to ACC_*_MASK flags for struct guest_walker.  */
+		walker->pt_access[walker->level - 1] = FNAME(gpte_access)(pt_access ^ walk_nx_mask);
 	} while (!is_last_gpte(mmu, walker->level, pte));
 	pte_pkey = FNAME(gpte_pkeys)(vcpu, pte);
 	accessed_dirty = have_ad ? pte_access & PT_GUEST_ACCESSED_MASK : 0;
 	/* Convert to ACC_*_MASK flags for struct guest_walker.  */
-	walker->pt_access = FNAME(gpte_access)(pt_access ^ walk_nx_mask);
 	walker->pte_access = FNAME(gpte_access)(pte_access ^ walk_nx_mask);
 	errcode = permission_fault(vcpu, mmu, walker->pte_access, pte_pkey, access);
 	if (unlikely(errcode))
 	}
 	pgprintk("%s: pte %llx pte_access %x pt_access %x\n",
-		 __func__, (u64)pte, walker->pte_access, walker->pt_access);
+		 __func__, (u64)pte, walker->pte_access,
+		 walker->pt_access[walker->level - 1]);
 	return 1;
 error:
 	bool huge_page_disallowed = exec && nx_huge_page_workaround_enabled;
 	struct kvm_mmu_page *sp = NULL;
 	struct kvm_shadow_walk_iterator it;
-	unsigned direct_access, access = gw->pt_access;
+	unsigned int direct_access, access;
 	int top_level, level, req_level, ret;
 	gfn_t base_gfn = gw->gfn;
 		sp = NULL;
 		if (!is_shadow_present_pte(*it.sptep)) {
 			table_gfn = gw->table_gfn[it.level - 2];
+			access = gw->pt_access[it.level - 2];
 			sp = kvm_mmu_get_page(vcpu, table_gfn, addr, it.level-1,
 					      false, access);
 		}

arch/x86/kvm/svm/sev.c+2−4

 	struct sev_data_send_start data;
 	int ret;
+	memset(&data, 0, sizeof(data));
 	data.handle = sev->handle;
 	ret = sev_issue_cmd(kvm, SEV_CMD_SEND_START, &data, &argp->error);
-	if (ret < 0)
-		return ret;
 	params->session_len = data.session_len;
 	if (copy_to_user((void __user *)(uintptr_t)argp->data, params,
 	struct sev_data_send_update_data data;
 	int ret;
+	memset(&data, 0, sizeof(data));
 	data.handle = sev->handle;
 	ret = sev_issue_cmd(kvm, SEV_CMD_SEND_UPDATE_DATA, &data, &argp->error);
-	if (ret < 0)
-		return ret;
 	params->hdr_len = data.hdr_len;
 	params->trans_len = data.trans_len;

arch/x86/kvm/trace.h+3−3

@@ -1550,16 +1550,16 @@ TRACE_EVENT(kvm_nested_vmenter_failed, · 1549 unmodified lines
1550	TP_ARGS(msg, err),	1550	TP_ARGS(msg, err),
1551		1551
1552	TP_STRUCT__entry(	1552	TP_STRUCT__entry(
1553	__field(const char *, msg)	1553	__string(msg, msg)
1554	__field(u32, err)	1554	__field(u32, err)
1555	),	1555	),
1556		1556
1557	TP_fast_assign(	1557	TP_fast_assign(
1558	__entry->msg = msg;	1558	__assign_str(msg, msg);
1559	__entry->err = err;	1559	__entry->err = err;
1560	),	1560	),
1561		1561
1562	TP_printk("%s%s", __entry->msg, !__entry->err ? "" :	1562	TP_printk("%s%s", __get_str(msg), !__entry->err ? "" :
1563	__print_symbolic(__entry->err, VMX_VMENTER_INSTRUCTION_ERRORS))	1563	__print_symbolic(__entry->err, VMX_VMENTER_INSTRUCTION_ERRORS))
1564	);	1564	);
1565		1565

arch/x86/kvm/x86.c+17−2

 static void kvm_vcpu_flush_tlb_guest(struct kvm_vcpu *vcpu)
 {
 	++vcpu->stat.tlb_flush;
+	if (!tdp_enabled) {
+               /*
+		 * A TLB flush on behalf of the guest is equivalent to
+		 * INVPCID(all), toggling CR4.PGE, etc., which requires
+		 * a forced sync of the shadow page tables.  Unload the
+		 * entire MMU here and the subsequent load will sync the
+		 * shadow page tables, and also flush the TLB.
+		 */
+		kvm_mmu_unload(vcpu);
+		return;
+	}
 	static_call(kvm_x86_tlb_flush_guest)(vcpu);
 }
 	 * expensive IPIs.
 	 */
 	if (guest_pv_has(vcpu, KVM_FEATURE_PV_TLB_FLUSH)) {
+		u8 st_preempted = xchg(&st->preempted, 0);
 		trace_kvm_pv_tlb_flush(vcpu->vcpu_id,
-				       st->preempted & KVM_VCPU_FLUSH_TLB);
+				       st_preempted & KVM_VCPU_FLUSH_TLB);
-		if (xchg(&st->preempted, 0) & KVM_VCPU_FLUSH_TLB)
+		if (st_preempted & KVM_VCPU_FLUSH_TLB)
 			kvm_vcpu_flush_tlb_guest(vcpu);
 	} else {
 		st->preempted = 0;

arch/x86/mm/fault.c+2−2

@@ -836,8 +836,8 @@ __bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code, · 835 unmodified lines
836		836
837	if (si_code == SEGV_PKUERR)	837	if (si_code == SEGV_PKUERR)
838	force_sig_pkuerr((void __user *)address, pkey);	838	force_sig_pkuerr((void __user *)address, pkey);
839		839	else
840	force_sig_fault(SIGSEGV, si_code, (void __user *)address);	840	force_sig_fault(SIGSEGV, si_code, (void __user *)address);
841		841
842	local_irq_disable();	842	local_irq_disable();
843	}	843	}

arch/x86/mm/mem_encrypt_identity.c+6−5

 #define AMD_SME_BIT	BIT(0)
 #define AMD_SEV_BIT	BIT(1)
-	/* Check the SEV MSR whether SEV or SME is enabled */
-	sev_status   = __rdmsr(MSR_AMD64_SEV);
-	feature_mask = (sev_status & MSR_AMD64_SEV_ENABLED) ? AMD_SEV_BIT : AMD_SME_BIT;
 	/*
 	 * Check for the SME/SEV feature:
 	 *   CPUID Fn8000_001F[EAX]
 	eax = 0x8000001f;
 	ecx = 0;
 	native_cpuid(&eax, &ebx, &ecx, &edx);
-	if (!(eax & feature_mask))
+	/* Check whether SEV or SME is supported */
+	if (!(eax & (AMD_SEV_BIT | AMD_SME_BIT)))
 		return;
 	me_mask = 1UL << (ebx & 0x3f);
+	/* Check the SEV MSR whether SEV or SME is enabled */
+	sev_status   = __rdmsr(MSR_AMD64_SEV);
+	feature_mask = (sev_status & MSR_AMD64_SEV_ENABLED) ? AMD_SEV_BIT : AMD_SME_BIT;
 	/* Check if memory encryption is enabled */
 	if (feature_mask == AMD_SME_BIT) {
 		/*

arch/x86/platform/efi/quirks.c+12−0

@@ -450,6 +450,18 @@ void __init efi_free_boot_services(void) · 449 unmodified lines
450	size -= rm_size;	450	size -= rm_size;
451	}	451	}
452		452
		453	/*
		454	* Don't free memory under 1M for two reasons:
		455	* - BIOS might clobber it
		456	* - Crash kernel needs it to be reserved
		457	*/
		458	if (start + size < SZ_1M)
		459	continue;
		460	if (start < SZ_1M) {
		461	size -= (SZ_1M - start);
		462	start = SZ_1M;
		463	}
		464
453	memblock_free_late(start, size);	465	memblock_free_late(start, size);
454	}	466	}
455		467

arch/x86/realmode/init.c+8−6

@@ -29,14 +29,16 @@ void __init reserve_real_mode(void) · 28 unmodified lines
29		29
30	/* Has to be under 1M so we can execute real-mode AP code. */	30	/* Has to be under 1M so we can execute real-mode AP code. */
31	mem = memblock_find_in_range(0, 1<<20, size, PAGE_SIZE);	31	mem = memblock_find_in_range(0, 1<<20, size, PAGE_SIZE);
32	if (!mem) {	32	if (!mem)
33	pr_info("No sub-1M memory is available for the trampoline\n");	33	pr_info("No sub-1M memory is available for the trampoline\n");
34	return;	34	else
35	}	35	set_real_mode_mem(mem);
36		36
37	memblock_reserve(mem, size);	37	/*
38	set_real_mode_mem(mem);	38	* Unconditionally reserve the entire fisrt 1M, see comment in
39	crash_reserve_low_1M();	39	* setup_arch().
		40	*/
		41	memblock_reserve(0, SZ_1M);
40	}	42	}
41		43
42	static void sme_sev_setup_real_mode(struct trampoline_header *th)	44	static void sme_sev_setup_real_mode(struct trampoline_header *th)

crypto/async_tx/async_xor.c+2−1

@@ -233,7 +233,8 @@ async_xor_offs(struct page *dest, unsigned int offset, · 232 unmodified lines
233	if (submit->flags & ASYNC_TX_XOR_DROP_DST) {	233	if (submit->flags & ASYNC_TX_XOR_DROP_DST) {
234	src_cnt--;	234	src_cnt--;
235	src_list++;	235	src_list++;
236	src_offs++;	236	if (src_offs)
		237	src_offs++;
237	}	238	}
238		239
239	/* wait for any prerequisite operations */	240	/* wait for any prerequisite operations */

drivers/acpi/acpica/utdelete.c+8−0

@@ -285,6 +285,14 @@ static void acpi_ut_delete_internal_obj(union acpi_operand_object *object) · 284 unmodified lines
285	}	285	}
286	break;	286	break;
287		287
		288	case ACPI_TYPE_LOCAL_ADDRESS_HANDLER:
		289
		290	ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
		291	"***** Address handler %p\n", object));
		292
		293	acpi_os_delete_mutex(object->address_space.context_mutex);
		294	break;
		295
288	default:	296	default:
289		297
290	break;	298	break;

drivers/acpi/bus.c+8−19

 	if (ACPI_FAILURE(acpi_run_osc(handle, &context)))
 		return;
-	capbuf_ret = context.ret.pointer;
+	kfree(context.ret.pointer);
-	if (context.ret.length <= OSC_SUPPORT_DWORD) {
-		kfree(context.ret.pointer);
-		return;
-	}
-	/*
+	/* Now run _OSC again with query flag clear */
-	 * Now run _OSC again with query flag clear and with the caps
-	 * supported by both the OS and the platform.
-	 */
 	capbuf[OSC_QUERY_DWORD] = 0;
-	capbuf[OSC_SUPPORT_DWORD] = capbuf_ret[OSC_SUPPORT_DWORD];
-	kfree(context.ret.pointer);
 	if (ACPI_FAILURE(acpi_run_osc(handle, &context)))
 		return;
 	capbuf_ret = context.ret.pointer;
-	if (context.ret.length > OSC_SUPPORT_DWORD) {
+	osc_sb_apei_support_acked =
-		osc_sb_apei_support_acked =
+		capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT;
-			capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT;
+	osc_pc_lpi_support_confirmed =
-		osc_pc_lpi_support_confirmed =
+		capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_PCLPI_SUPPORT;
-			capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_PCLPI_SUPPORT;
+	osc_sb_native_usb4_support_confirmed =
-		osc_sb_native_usb4_support_confirmed =
+		capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_NATIVE_USB4_SUPPORT;
-			capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_NATIVE_USB4_SUPPORT;
-	}
 	kfree(context.ret.pointer);
 }

drivers/acpi/sleep.c+1−3

 		return;
 	acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
-	if (facs) {
+	if (facs)
 		s4_hardware_signature = facs->hardware_signature;
-		acpi_put_table((struct acpi_table_header *)facs);
-	}
 }
 #else /* !CONFIG_HIBERNATION */
 static inline void acpi_sleep_hibernate_setup(void) {}

drivers/base/memory.c+3−3

 	struct zone *zone;
 	int ret;
-	zone = page_zone(pfn_to_page(start_pfn));
 	/*
 	 * Unaccount before offlining, such that unpopulated zone and kthreads
 	 * can properly be torn down in offline_pages().
 	 */
-	if (nr_vmemmap_pages)
+	if (nr_vmemmap_pages) {
+		zone = page_zone(pfn_to_page(start_pfn));
 		adjust_present_page_count(zone, -nr_vmemmap_pages);
+	}
 	ret = offline_pages(start_pfn + nr_vmemmap_pages,
 			    nr_pages - nr_vmemmap_pages);

drivers/block/loop.c+7−18

 static int lo_open(struct block_device *bdev, fmode_t mode)
 {
-	struct loop_device *lo;
+	struct loop_device *lo = bdev->bd_disk->private_data;
 	int err;
-	/*
-	 * take loop_ctl_mutex to protect lo pointer from race with
-	 * loop_control_ioctl(LOOP_CTL_REMOVE), however, to reduce contention
-	 * release it prior to updating lo->lo_refcnt.
-	 */
-	err = mutex_lock_killable(&loop_ctl_mutex);
-	if (err)
-		return err;
-	lo = bdev->bd_disk->private_data;
-	if (!lo) {
-		mutex_unlock(&loop_ctl_mutex);
-		return -ENXIO;
-	}
 	err = mutex_lock_killable(&lo->lo_mutex);
-	mutex_unlock(&loop_ctl_mutex);
 	if (err)
 		return err;
-	atomic_inc(&lo->lo_refcnt);
+	if (lo->lo_state == Lo_deleting)
+		err = -ENXIO;
+	else
+		atomic_inc(&lo->lo_refcnt);
 	mutex_unlock(&lo->lo_mutex);
-	return 0;
+	return err;
 }
 static void lo_release(struct gendisk *disk, fmode_t mode)
 			mutex_unlock(&lo->lo_mutex);
 			break;
 		}
-		lo->lo_disk->private_data = NULL;
+		lo->lo_state = Lo_deleting;
 		mutex_unlock(&lo->lo_mutex);
 		idr_remove(&loop_index_idr, lo->lo_number);
 		loop_remove(lo);

drivers/block/loop.h+1−0

@@ -22,6 +22,7 @@ enum { · 21 unmodified lines
22	Lo_unbound,	22	Lo_unbound,
23	Lo_bound,	23	Lo_bound,
24	Lo_rundown,	24	Lo_rundown,
		25	Lo_deleting,
25	};	26	};
26		27
27	struct loop_func_table;	28	struct loop_func_table;

drivers/bluetooth/btusb.c+23−2

 	/* Realtek 8822CE Bluetooth devices */
 	{ USB_DEVICE(0x0bda, 0xb00c), .driver_info = BTUSB_REALTEK |
 						     BTUSB_WIDEBAND_SPEECH },
+	{ USB_DEVICE(0x0bda, 0xc822), .driver_info = BTUSB_REALTEK |
+						     BTUSB_WIDEBAND_SPEECH },
 	/* Realtek 8852AE Bluetooth devices */
 	{ USB_DEVICE(0x0bda, 0xc852), .driver_info = BTUSB_REALTEK |
 	}
 	btusb_setup_intel_newgen_get_fw_name(ver, fwname, sizeof(fwname), "sfi");
-	err = request_firmware(&fw, fwname, &hdev->dev);
+	err = firmware_request_nowarn(&fw, fwname, &hdev->dev);
 	if (err < 0) {
+		if (!test_bit(BTUSB_BOOTLOADER, &data->flags)) {
+			/* Firmware has already been loaded */
+			set_bit(BTUSB_FIRMWARE_LOADED, &data->flags);
+			return 0;
+		}
 		bt_dev_err(hdev, "Failed to load Intel firmware file %s (%d)",
 			   fwname, err);
 		return err;
 	}
 	err = btusb_setup_intel_new_get_fw_name(ver, params, fwname,
 						sizeof(fwname), "sfi");
 	if (err < 0) {
+		if (!test_bit(BTUSB_BOOTLOADER, &data->flags)) {
+			/* Firmware has already been loaded */
+			set_bit(BTUSB_FIRMWARE_LOADED, &data->flags);
+			return 0;
+		}
 		bt_dev_err(hdev, "Unsupported Intel firmware naming");
 		return -EINVAL;
 	}
-	err = request_firmware(&fw, fwname, &hdev->dev);
+	err = firmware_request_nowarn(&fw, fwname, &hdev->dev);
 	if (err < 0) {
+		if (!test_bit(BTUSB_BOOTLOADER, &data->flags)) {
+			/* Firmware has already been loaded */
+			set_bit(BTUSB_FIRMWARE_LOADED, &data->flags);
+			return 0;
+		}
 		bt_dev_err(hdev, "Failed to load Intel firmware file %s (%d)",
 			   fwname, err);
 		return err;

drivers/bus/mhi/pci_generic.c+38−4

@@ -311,8 +311,8 @@ static const struct mhi_channel_config mhi_foxconn_sdx55_channels[] = { · 310 unmodified lines
311	MHI_CHANNEL_CONFIG_DL(5, "DIAG", 32, 1),	311	MHI_CHANNEL_CONFIG_DL(5, "DIAG", 32, 1),
312	MHI_CHANNEL_CONFIG_UL(12, "MBIM", 32, 0),	312	MHI_CHANNEL_CONFIG_UL(12, "MBIM", 32, 0),
313	MHI_CHANNEL_CONFIG_DL(13, "MBIM", 32, 0),	313	MHI_CHANNEL_CONFIG_DL(13, "MBIM", 32, 0),
314	MHI_CHANNEL_CONFIG_UL(32, "AT", 32, 0),	314	MHI_CHANNEL_CONFIG_UL(32, "DUN", 32, 0),
315	MHI_CHANNEL_CONFIG_DL(33, "AT", 32, 0),	315	MHI_CHANNEL_CONFIG_DL(33, "DUN", 32, 0),
316	MHI_CHANNEL_CONFIG_HW_UL(100, "IP_HW0_MBIM", 128, 2),	316	MHI_CHANNEL_CONFIG_HW_UL(100, "IP_HW0_MBIM", 128, 2),
317	MHI_CHANNEL_CONFIG_HW_DL(101, "IP_HW0_MBIM", 128, 3),	317	MHI_CHANNEL_CONFIG_HW_DL(101, "IP_HW0_MBIM", 128, 3),
318	};	318	};
@@ -708,7 +708,7 @@ static void mhi_pci_remove(struct pci_dev *pdev) · 389 unmodified lines
708	struct mhi_pci_device *mhi_pdev = pci_get_drvdata(pdev);	708	struct mhi_pci_device *mhi_pdev = pci_get_drvdata(pdev);
709	struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;	709	struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
710		710
711	del_timer(&mhi_pdev->health_check_timer);	711	del_timer_sync(&mhi_pdev->health_check_timer);
712	cancel_work_sync(&mhi_pdev->recovery_work);	712	cancel_work_sync(&mhi_pdev->recovery_work);
713		713
714	if (test_and_clear_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status)) {	714	if (test_and_clear_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status)) {
@@ -935,9 +935,43 @@ static int __maybe_unused mhi_pci_resume(struct device *dev) · 220 unmodified lines
935	return ret;	935	return ret;
936	}	936	}
937		937
		938	static int __maybe_unused mhi_pci_freeze(struct device *dev)
		939	{
		940	struct mhi_pci_device *mhi_pdev = dev_get_drvdata(dev);
		941	struct mhi_controller *mhi_cntrl = &mhi_pdev->mhi_cntrl;
		942
		943	/* We want to stop all operations, hibernation does not guarantee that
		944	* device will be in the same state as before freezing, especially if
		945	* the intermediate restore kernel reinitializes MHI device with new
		946	* context.
		947	*/
		948	if (test_and_clear_bit(MHI_PCI_DEV_STARTED, &mhi_pdev->status)) {
		949	mhi_power_down(mhi_cntrl, false);
		950	mhi_unprepare_after_power_down(mhi_cntrl);
		951	}
		952
		953	return 0;
		954	}
		955
		956	static int __maybe_unused mhi_pci_restore(struct device *dev)
		957	{
		958	struct mhi_pci_device *mhi_pdev = dev_get_drvdata(dev);
		959
		960	/* Reinitialize the device */
		961	queue_work(system_long_wq, &mhi_pdev->recovery_work);
		962
		963	return 0;
		964	}
		965
938	static const struct dev_pm_ops mhi_pci_pm_ops = {	966	static const struct dev_pm_ops mhi_pci_pm_ops = {
939	SET_RUNTIME_PM_OPS(mhi_pci_runtime_suspend, mhi_pci_runtime_resume, NULL)	967	SET_RUNTIME_PM_OPS(mhi_pci_runtime_suspend, mhi_pci_runtime_resume, NULL)
940	SET_SYSTEM_SLEEP_PM_OPS(mhi_pci_suspend, mhi_pci_resume)	968	#ifdef CONFIG_PM_SLEEP
		969	.suspend = mhi_pci_suspend,
		970	.resume = mhi_pci_resume,
		971	.freeze = mhi_pci_freeze,
		972	.thaw = mhi_pci_restore,
		973	.restore = mhi_pci_restore,
		974	#endif
941	};	975	};
942		976
943	static struct pci_driver mhi_pci_driver = {	977	static struct pci_driver mhi_pci_driver = {

drivers/bus/ti-sysc.c+54−6

 	return error;
 }
+static int sysc_reinit_module(struct sysc *ddata, bool leave_enabled)
+{
+	struct device *dev = ddata->dev;
+	int error;
+	/* Disable target module if it is enabled */
+	if (ddata->enabled) {
+		error = sysc_runtime_suspend(dev);
+		if (error)
+			dev_warn(dev, "reinit suspend failed: %i\n", error);
+	}
+	/* Enable target module */
+	error = sysc_runtime_resume(dev);
+	if (error)
+		dev_warn(dev, "reinit resume failed: %i\n", error);
+	if (leave_enabled)
+		return error;
+	/* Disable target module if no leave_enabled was set */
+	error = sysc_runtime_suspend(dev);
+	if (error)
+		dev_warn(dev, "reinit suspend failed: %i\n", error);
+	return error;
+}
 static int __maybe_unused sysc_noirq_suspend(struct device *dev)
 {
 	struct sysc *ddata;
 	    (SYSC_QUIRK_LEGACY_IDLE | SYSC_QUIRK_NO_IDLE))
 		return 0;
-	return pm_runtime_force_suspend(dev);
+	if (!ddata->enabled)
+		return 0;
+	ddata->needs_resume = 1;
+	return sysc_runtime_suspend(dev);
 }
 static int __maybe_unused sysc_noirq_resume(struct device *dev)
 {
 	struct sysc *ddata;
+	int error = 0;
 	ddata = dev_get_drvdata(dev);
 	    (SYSC_QUIRK_LEGACY_IDLE | SYSC_QUIRK_NO_IDLE))
 		return 0;
-	return pm_runtime_force_resume(dev);
+	if (ddata->cfg.quirks & SYSC_QUIRK_REINIT_ON_RESUME) {
+		error = sysc_reinit_module(ddata, ddata->needs_resume);
+		if (error)
+			dev_warn(dev, "noirq_resume failed: %i\n", error);
+	} else if (ddata->needs_resume) {
+		error = sysc_runtime_resume(dev);
+		if (error)
+			dev_warn(dev, "noirq_resume failed: %i\n", error);
+	}
+	ddata->needs_resume = 0;
+	return error;
 }
 static const struct dev_pm_ops sysc_pm_ops = {
 		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_LEGACY_IDLE),
 	/* Uarts on omap4 and later */
 	SYSC_QUIRK("uart", 0, 0x50, 0x54, 0x58, 0x50411e03, 0xffff00ff,
-		   SYSC_QUIRK_SWSUP_SIDLE_ACT | SYSC_QUIRK_LEGACY_IDLE),
+		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_LEGACY_IDLE),
 	SYSC_QUIRK("uart", 0, 0x50, 0x54, 0x58, 0x47422e03, 0xffffffff,
-		   SYSC_QUIRK_SWSUP_SIDLE_ACT | SYSC_QUIRK_LEGACY_IDLE),
+		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_LEGACY_IDLE),
 	/* Quirks that need to be set based on the module address */
 	SYSC_QUIRK("mcpdm", 0x40132000, 0, 0x10, -ENODEV, 0x50000800, 0xffffffff,
 		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_SWSUP_MSTANDBY),
 	SYSC_QUIRK("tptc", 0, 0, -ENODEV, -ENODEV, 0x40007c00, 0xffffffff,
 		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_SWSUP_MSTANDBY),
+	SYSC_QUIRK("sata", 0, 0xfc, 0x1100, -ENODEV, 0x5e412000, 0xffffffff,
+		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_SWSUP_MSTANDBY),
 	SYSC_QUIRK("usb_host_hs", 0, 0, 0x10, 0x14, 0x50700100, 0xffffffff,
 		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_SWSUP_MSTANDBY),
 	SYSC_QUIRK("usb_host_hs", 0, 0, 0x10, -ENODEV, 0x50700101, 0xffffffff,
 	SYSC_QUIRK("usb_otg_hs", 0, 0x400, 0x404, 0x408, 0x00000050,
 		   0xffffffff, SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_SWSUP_MSTANDBY),
 	SYSC_QUIRK("usb_otg_hs", 0, 0, 0x10, -ENODEV, 0x4ea2080d, 0xffffffff,
-		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_SWSUP_MSTANDBY),
+		   SYSC_QUIRK_SWSUP_SIDLE | SYSC_QUIRK_SWSUP_MSTANDBY |
+		   SYSC_QUIRK_REINIT_ON_RESUME),
 	SYSC_QUIRK("wdt", 0, 0, 0x10, 0x14, 0x502a0500, 0xfffff0f0,
 		   SYSC_MODULE_QUIRK_WDT),
 	/* PRUSS on am3, am4 and am5 */
 	SYSC_QUIRK("prcm", 0, 0, -ENODEV, -ENODEV, 0x40000400, 0xffffffff, 0),
 	SYSC_QUIRK("rfbi", 0x4832a800, 0, 0x10, 0x14, 0x00000010, 0xffffffff, 0),
 	SYSC_QUIRK("rfbi", 0x58002000, 0, 0x10, 0x14, 0x00000010, 0xffffffff, 0),
-	SYSC_QUIRK("sata", 0, 0xfc, 0x1100, -ENODEV, 0x5e412000, 0xffffffff, 0),
 	SYSC_QUIRK("scm", 0, 0, 0x10, -ENODEV, 0x40000900, 0xffffffff, 0),
 	SYSC_QUIRK("scm", 0, 0, -ENODEV, -ENODEV, 0x4e8b0100, 0xffffffff, 0),
 	SYSC_QUIRK("scm", 0, 0, -ENODEV, -ENODEV, 0x4f000100, 0xffffffff, 0),

drivers/dma/idxd/init.c+2−2

@@ -745,12 +745,12 @@ static int __init idxd_init_module(void) · 744 unmodified lines
745	* If the CPU does not support MOVDIR64B or ENQCMDS, there's no point in	745	* If the CPU does not support MOVDIR64B or ENQCMDS, there's no point in
746	* enumerating the device. We can not utilize it.	746	* enumerating the device. We can not utilize it.
747	*/	747	*/
748	if (!boot_cpu_has(X86_FEATURE_MOVDIR64B)) {	748	if (!cpu_feature_enabled(X86_FEATURE_MOVDIR64B)) {
749	pr_warn("idxd driver failed to load without MOVDIR64B.\n");	749	pr_warn("idxd driver failed to load without MOVDIR64B.\n");
750	return -ENODEV;	750	return -ENODEV;
751	}	751	}
752		752
753	if (!boot_cpu_has(X86_FEATURE_ENQCMD))	753	if (!cpu_feature_enabled(X86_FEATURE_ENQCMD))
754	pr_warn("Platform does not have ENQCMD(S) support.\n");	754	pr_warn("Platform does not have ENQCMD(S) support.\n");
755	else	755	else
756	support_enqcmd = true;	756	support_enqcmd = true;

drivers/firmware/efi/cper.c+1−3

 	if (!msg || !(mem->validation_bits & CPER_MEM_VALID_MODULE_HANDLE))
 		return 0;
-	n = 0;
+	len = CPER_REC_LEN;
-	len = CPER_REC_LEN - 1;
 	dmi_memdev_name(mem->mem_dev_handle, &bank, &device);
 	if (bank && device)
 		n = snprintf(msg, len, "DIMM location: %s %s ", bank, device);
 			     "DIMM location: not present. DMI handle: 0x%.4x ",
 			     mem->mem_dev_handle);
-	msg[n] = '\0';
 	return n;
 }

drivers/firmware/efi/fdtparams.c+3−0

@@ -98,6 +98,9 @@ u64 __init efi_get_fdt_params(struct efi_memory_map_data *mm) · 97 unmodified lines
98	BUILD_BUG_ON(ARRAY_SIZE(target) != ARRAY_SIZE(name));	98	BUILD_BUG_ON(ARRAY_SIZE(target) != ARRAY_SIZE(name));
99	BUILD_BUG_ON(ARRAY_SIZE(target) != ARRAY_SIZE(dt_params[0].params));	99	BUILD_BUG_ON(ARRAY_SIZE(target) != ARRAY_SIZE(dt_params[0].params));
100		100
		101	if (!fdt)
		102	return 0;
		103
101	for (i = 0; i < ARRAY_SIZE(dt_params); i++) {	104	for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
102	node = fdt_path_offset(fdt, dt_params[i].path);	105	node = fdt_path_offset(fdt, dt_params[i].path);
103	if (node < 0)	106	if (node < 0)

drivers/firmware/efi/libstub/file.c+1−1

@@ -103,7 +103,7 @@ static int find_file_option(const efi_char16_t *cmdline, int cmdline_len, · 102 unmodified lines
103	return 0;	103	return 0;
104		104
105	/* Skip any leading slashes */	105	/* Skip any leading slashes */
106	while (cmdline[i] == L'/' \|\| cmdline[i] == L'\\')	106	while (i < cmdline_len && (cmdline[i] == L'/' \|\| cmdline[i] == L'\\'))
107	i++;	107	i++;
108		108
109	while (--result_len > 0 && i < cmdline_len) {	109	while (--result_len > 0 && i < cmdline_len) {

drivers/firmware/efi/memattr.c+0−5

 		return false;
 	}
-	if (!(in->attribute & (EFI_MEMORY_RO | EFI_MEMORY_XP))) {
-		pr_warn("Entry attributes invalid: RO and XP bits both cleared\n");
-		return false;
-	}
 	if (PAGE_SIZE > EFI_PAGE_SIZE &&
 	    (!PAGE_ALIGNED(in->phys_addr) ||
 	     !PAGE_ALIGNED(in->num_pages << EFI_PAGE_SHIFT))) {

drivers/gpio/gpio-wcd934x.c+1−1

@@ -7,7 +7,7 @@ · 6 unmodified lines
7	#include <linux/slab.h>	7	#include <linux/slab.h>
8	#include <linux/of_device.h>	8	#include <linux/of_device.h>
9		9
10	#define WCD_PIN_MASK(p) BIT(p - 1)	10	#define WCD_PIN_MASK(p) BIT(p)
11	#define WCD_REG_DIR_CTL_OFFSET 0x42	11	#define WCD_REG_DIR_CTL_OFFSET 0x42
12	#define WCD_REG_VAL_CTL_OFFSET 0x43	12	#define WCD_REG_VAL_CTL_OFFSET 0x43
13	#define WCD934X_NPINS 5	13	#define WCD934X_NPINS 5

drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c+0−16

@@ -337,7 +337,6 @@ static int amdgpu_ctx_query2(struct amdgpu_device *adev, · 336 unmodified lines
337	{	337	{
338	struct amdgpu_ctx *ctx;	338	struct amdgpu_ctx *ctx;
339	struct amdgpu_ctx_mgr *mgr;	339	struct amdgpu_ctx_mgr *mgr;
340	unsigned long ras_counter;
341		340
342	if (!fpriv)	341	if (!fpriv)
343	return -EINVAL;	342	return -EINVAL;
@@ -362,21 +361,6 @@ static int amdgpu_ctx_query2(struct amdgpu_device *adev, · 18 unmodified lines
362	if (atomic_read(&ctx->guilty))	361	if (atomic_read(&ctx->guilty))
363	out->state.flags \|= AMDGPU_CTX_QUERY2_FLAGS_GUILTY;	362	out->state.flags \|= AMDGPU_CTX_QUERY2_FLAGS_GUILTY;
364		363
365	/query ue count/
366	ras_counter = amdgpu_ras_query_error_count(adev, false);
367	/ras counter is monotonic increasing/
368	if (ras_counter != ctx->ras_counter_ue) {
369	out->state.flags \|= AMDGPU_CTX_QUERY2_FLAGS_RAS_UE;
370	ctx->ras_counter_ue = ras_counter;
371	}
372
373	/query ce count/
374	ras_counter = amdgpu_ras_query_error_count(adev, true);
375	if (ras_counter != ctx->ras_counter_ce) {
376	out->state.flags \|= AMDGPU_CTX_QUERY2_FLAGS_RAS_CE;
377	ctx->ras_counter_ce = ras_counter;
378	}
379
380	mutex_unlock(&mgr->lock);	364	mutex_unlock(&mgr->lock);
381	return 0;	365	return 0;
382	}	366	}

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

  */
 bool amdgpu_device_has_dc_support(struct amdgpu_device *adev)
 {
-	if (amdgpu_sriov_vf(adev) || adev->enable_virtual_display)
+	if (amdgpu_sriov_vf(adev) ||
+	    adev->enable_virtual_display ||
+	    (adev->harvest_ip_mask & AMD_HARVEST_IP_DMU_MASK))
 		return false;
 	return amdgpu_device_asic_has_dc_support(adev->asic_type);

drivers/gpu/drm/amd/amdgpu/amdgpu_display.c+2−2

@@ -1057,7 +1057,7 @@ int amdgpu_display_gem_fb_init(struct drm_device *dev, · 1056 unmodified lines
1057		1057
1058	return 0;	1058	return 0;
1059	err:	1059	err:
1060	drm_err(dev, "Failed to init gem fb: %d\n", ret);	1060	drm_dbg_kms(dev, "Failed to init gem fb: %d\n", ret);
1061	rfb->base.obj[0] = NULL;	1061	rfb->base.obj[0] = NULL;
1062	return ret;	1062	return ret;
1063	}	1063	}
@@ -1094,7 +1094,7 @@ int amdgpu_display_gem_fb_verify_and_init( · 30 unmodified lines
1094		1094
1095	return 0;	1095	return 0;
1096	err:	1096	err:
1097	drm_err(dev, "Failed to verify and init gem fb: %d\n", ret);	1097	drm_dbg_kms(dev, "Failed to verify and init gem fb: %d\n", ret);
1098	rfb->base.obj[0] = NULL;	1098	rfb->base.obj[0] = NULL;
1099	return ret;	1099	return ret;
1100	}	1100	}

drivers/gpu/drm/amd/amdgpu/amdgpu_fru_eeprom.c+23−19

 int amdgpu_fru_get_product_info(struct amdgpu_device *adev)
 {
 	unsigned char buff[34];
-	int addrptr = 0, size = 0;
+	int addrptr, size;
+	int len;
 	if (!is_fru_eeprom_supported(adev))
 		return 0;
 	/* If algo exists, it means that the i2c_adapter's initialized */
 	if (!adev->pm.smu_i2c.algo) {
 		DRM_WARN("Cannot access FRU, EEPROM accessor not initialized");
-		return 0;
+		return -ENODEV;
 	}
 	/* There's a lot of repetition here. This is due to the FRU having
 	size = amdgpu_fru_read_eeprom(adev, addrptr, buff);
 	if (size < 1) {
 		DRM_ERROR("Failed to read FRU Manufacturer, ret:%d", size);
-		return size;
+		return -EINVAL;
 	}
 	/* Increment the addrptr by the size of the field, and 1 due to the
 	size = amdgpu_fru_read_eeprom(adev, addrptr, buff);
 	if (size < 1) {
 		DRM_ERROR("Failed to read FRU product name, ret:%d", size);
-		return size;
+		return -EINVAL;
 	}
+	len = size;
 	/* Product name should only be 32 characters. Any more,
 	 * and something could be wrong. Cap it at 32 to be safe
 	 */
-	if (size > 32) {
+	if (len >= sizeof(adev->product_name)) {
 		DRM_WARN("FRU Product Number is larger than 32 characters. This is likely a mistake");
-		size = 32;
+		len = sizeof(adev->product_name) - 1;
 	}
 	/* Start at 2 due to buff using fields 0 and 1 for the address */
-	memcpy(adev->product_name, &buff[2], size);
+	memcpy(adev->product_name, &buff[2], len);
-	adev->product_name[size] = '\0';
+	adev->product_name[len] = '\0';
 	addrptr += size + 1;
 	size = amdgpu_fru_read_eeprom(adev, addrptr, buff);
 	if (size < 1) {
 		DRM_ERROR("Failed to read FRU product number, ret:%d", size);
-		return size;
+		return -EINVAL;
 	}
+	len = size;
 	/* Product number should only be 16 characters. Any more,
 	 * and something could be wrong. Cap it at 16 to be safe
 	 */
-	if (size > 16) {
+	if (len >= sizeof(adev->product_number)) {
 		DRM_WARN("FRU Product Number is larger than 16 characters. This is likely a mistake");
-		size = 16;
+		len = sizeof(adev->product_number) - 1;
 	}
-	memcpy(adev->product_number, &buff[2], size);
+	memcpy(adev->product_number, &buff[2], len);
-	adev->product_number[size] = '\0';
+	adev->product_number[len] = '\0';
 	addrptr += size + 1;
 	size = amdgpu_fru_read_eeprom(adev, addrptr, buff);
 	if (size < 1) {
 		DRM_ERROR("Failed to read FRU product version, ret:%d", size);
-		return size;
+		return -EINVAL;
 	}
 	addrptr += size + 1;
 	if (size < 1) {
 		DRM_ERROR("Failed to read FRU serial number, ret:%d", size);
-		return size;
+		return -EINVAL;
 	}
+	len = size;
 	/* Serial number should only be 16 characters. Any more,
 	 * and something could be wrong. Cap it at 16 to be safe
 	 */
-	if (size > 16) {
+	if (len >= sizeof(adev->serial)) {
 		DRM_WARN("FRU Serial Number is larger than 16 characters. This is likely a mistake");
-		size = 16;
+		len = sizeof(adev->serial) - 1;
 	}
-	memcpy(adev->serial, &buff[2], size);
+	memcpy(adev->serial, &buff[2], len);
-	adev->serial[size] = '\0';
+	adev->serial[len] = '\0';
 	return 0;
 }

drivers/gpu/drm/amd/amdgpu/amdgpu_object.c+2−2

@@ -100,7 +100,7 @@ static void amdgpu_bo_destroy(struct ttm_buffer_object *tbo) · 99 unmodified lines
100	kfree(ubo->metadata);	100	kfree(ubo->metadata);
101	}	101	}
102		102
103	kfree(bo);	103	kvfree(bo);
104	}	104	}
105		105
106	/**	106	/**
@@ -552,7 +552,7 @@ static int amdgpu_bo_do_create(struct amdgpu_device *adev, · 445 unmodified lines
552	BUG_ON(bp->bo_ptr_size < sizeof(struct amdgpu_bo));	552	BUG_ON(bp->bo_ptr_size < sizeof(struct amdgpu_bo));
553		553
554	*bo_ptr = NULL;	554	*bo_ptr = NULL;
555	bo = kzalloc(bp->bo_ptr_size, GFP_KERNEL);	555	bo = kvzalloc(bp->bo_ptr_size, GFP_KERNEL);
556	if (bo == NULL)	556	if (bo == NULL)
557	return -ENOMEM;	557	return -ENOMEM;
558	drm_gem_private_object_init(adev_to_drm(adev), &bo->tbo.base, size);	558	drm_gem_private_object_init(adev_to_drm(adev), &bo->tbo.base, size);

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

@@ -76,6 +76,7 @@ struct psp_ring · 75 unmodified lines
76	uint64_t ring_mem_mc_addr;	76	uint64_t ring_mem_mc_addr;
77	void *ring_mem_handle;	77	void *ring_mem_handle;
78	uint32_t ring_size;	78	uint32_t ring_size;
		79	uint32_t ring_wptr;
79	};	80	};
80		81
81	/* More registers may will be supported */	82	/* More registers may will be supported */

drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c+21−5

@@ -173,6 +173,9 @@ · 172 unmodified lines
173	#define mmGC_THROTTLE_CTRL_Sienna_Cichlid 0x2030	173	#define mmGC_THROTTLE_CTRL_Sienna_Cichlid 0x2030
174	#define mmGC_THROTTLE_CTRL_Sienna_Cichlid_BASE_IDX 0	174	#define mmGC_THROTTLE_CTRL_Sienna_Cichlid_BASE_IDX 0
175		175
		176	#define mmRLC_SPARE_INT_0_Sienna_Cichlid 0x4ca5
		177	#define mmRLC_SPARE_INT_0_Sienna_Cichlid_BASE_IDX 1
		178
176	#define GFX_RLCG_GC_WRITE_OLD (0x8 << 28)	179	#define GFX_RLCG_GC_WRITE_OLD (0x8 << 28)
177	#define GFX_RLCG_GC_WRITE (0x0 << 28)	180	#define GFX_RLCG_GC_WRITE (0x0 << 28)
178	#define GFX_RLCG_GC_READ (0x1 << 28)	181	#define GFX_RLCG_GC_READ (0x1 << 28)
@@ -1480,8 +1483,15 @@ static u32 gfx_v10_rlcg_rw(struct amdgpu_device *adev, u32 offset, u32 v, uint32 · 1301 unmodified lines
1480	(adev->reg_offset[GC_HWIP][0][mmSCRATCH_REG0_BASE_IDX] + mmSCRATCH_REG2) * 4;	1483	(adev->reg_offset[GC_HWIP][0][mmSCRATCH_REG0_BASE_IDX] + mmSCRATCH_REG2) * 4;
1481	scratch_reg3 = adev->rmmio +	1484	scratch_reg3 = adev->rmmio +
1482	(adev->reg_offset[GC_HWIP][0][mmSCRATCH_REG1_BASE_IDX] + mmSCRATCH_REG3) * 4;	1485	(adev->reg_offset[GC_HWIP][0][mmSCRATCH_REG1_BASE_IDX] + mmSCRATCH_REG3) * 4;
1483	spare_int = adev->rmmio +	1486
1484	(adev->reg_offset[GC_HWIP][0][mmRLC_SPARE_INT_BASE_IDX] + mmRLC_SPARE_INT) * 4;	1487	if (adev->asic_type >= CHIP_SIENNA_CICHLID) {
		1488	spare_int = adev->rmmio +
		1489	(adev->reg_offset[GC_HWIP][0][mmRLC_SPARE_INT_0_Sienna_Cichlid_BASE_IDX]
		1490	+ mmRLC_SPARE_INT_0_Sienna_Cichlid) * 4;
		1491	} else {
		1492	spare_int = adev->rmmio +
		1493	(adev->reg_offset[GC_HWIP][0][mmRLC_SPARE_INT_BASE_IDX] + mmRLC_SPARE_INT) * 4;
		1494	}
1485		1495
1486	grbm_cntl = adev->reg_offset[GC_HWIP][0][mmGRBM_GFX_CNTL_BASE_IDX] + mmGRBM_GFX_CNTL;	1496	grbm_cntl = adev->reg_offset[GC_HWIP][0][mmGRBM_GFX_CNTL_BASE_IDX] + mmGRBM_GFX_CNTL;
1487	grbm_idx = adev->reg_offset[GC_HWIP][0][mmGRBM_GFX_INDEX_BASE_IDX] + mmGRBM_GFX_INDEX;	1497	grbm_idx = adev->reg_offset[GC_HWIP][0][mmGRBM_GFX_INDEX_BASE_IDX] + mmGRBM_GFX_INDEX;
@@ -7349,9 +7359,15 @@ static int gfx_v10_0_hw_fini(void *handle) · 5861 unmodified lines
7349	if (amdgpu_sriov_vf(adev)) {	7359	if (amdgpu_sriov_vf(adev)) {
7350	gfx_v10_0_cp_gfx_enable(adev, false);	7360	gfx_v10_0_cp_gfx_enable(adev, false);
7351	/* Program KIQ position of RLC_CP_SCHEDULERS during destroy */	7361	/* Program KIQ position of RLC_CP_SCHEDULERS during destroy */
7352	tmp = RREG32_SOC15(GC, 0, mmRLC_CP_SCHEDULERS);	7362	if (adev->asic_type >= CHIP_SIENNA_CICHLID) {
7353	tmp &= 0xffffff00;	7363	tmp = RREG32_SOC15(GC, 0, mmRLC_CP_SCHEDULERS_Sienna_Cichlid);
7354	WREG32_SOC15(GC, 0, mmRLC_CP_SCHEDULERS, tmp);	7364	tmp &= 0xffffff00;
		7365	WREG32_SOC15(GC, 0, mmRLC_CP_SCHEDULERS_Sienna_Cichlid, tmp);
		7366	} else {
		7367	tmp = RREG32_SOC15(GC, 0, mmRLC_CP_SCHEDULERS);
		7368	tmp &= 0xffffff00;
		7369	WREG32_SOC15(GC, 0, mmRLC_CP_SCHEDULERS, tmp);
		7370	}
7355		7371
7356	return 0;	7372	return 0;
7357	}	7373	}

drivers/gpu/drm/amd/amdgpu/psp_v11_0.c+2−1

 	struct amdgpu_device *adev = psp->adev;
 	if (amdgpu_sriov_vf(adev))
-		data = RREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_102);
+		data = psp->km_ring.ring_wptr;
 	else
 		data = RREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_67);
 	if (amdgpu_sriov_vf(adev)) {
 		WREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_102, value);
 		WREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_101, GFX_CTRL_CMD_ID_CONSUME_CMD);
+		psp->km_ring.ring_wptr = value;
 	} else
 		WREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_67, value);
 }

drivers/gpu/drm/amd/amdgpu/psp_v3_1.c+2−1

 	struct amdgpu_device *adev = psp->adev;
 	if (amdgpu_sriov_vf(adev))
-		data = RREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_102);
+		data = psp->km_ring.ring_wptr;
 	else
 		data = RREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_67);
 	return data;
 		/* send interrupt to PSP for SRIOV ring write pointer update */
 		WREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_101,
 			GFX_CTRL_CMD_ID_CONSUME_CMD);
+		psp->km_ring.ring_wptr = value;
 	} else
 		WREG32_SOC15(MP0, 0, mmMP0_SMN_C2PMSG_67, value);
 }

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

@@ -357,6 +357,7 @@ static int uvd_v6_0_enc_ring_test_ib(struct amdgpu_ring *ring, long timeout) · 356 unmodified lines
357		357
358	error:	358	error:
359	dma_fence_put(fence);	359	dma_fence_put(fence);
		360	amdgpu_bo_unpin(bo);
360	amdgpu_bo_unreserve(bo);	361	amdgpu_bo_unreserve(bo);
361	amdgpu_bo_unref(&bo);	362	amdgpu_bo_unref(&bo);
362	return r;	363	return r;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+19−11

 		abm->dmcu_is_running = dmcu->funcs->is_dmcu_initialized(dmcu);
 	}
-	adev->dm.dc->ctx->dmub_srv = dc_dmub_srv_create(adev->dm.dc, dmub_srv);
+	if (!adev->dm.dc->ctx->dmub_srv)
+		adev->dm.dc->ctx->dmub_srv = dc_dmub_srv_create(adev->dm.dc, dmub_srv);
 	if (!adev->dm.dc->ctx->dmub_srv) {
 		DRM_ERROR("Couldn't allocate DC DMUB server!\n");
 		return -ENOMEM;
 	amdgpu_dm_irq_suspend(adev);
 	dc_set_power_state(dm->dc, DC_ACPI_CM_POWER_STATE_D3);
 	return 0;
 	struct drm_display_mode saved_mode;
 	struct drm_display_mode *freesync_mode = NULL;
 	bool native_mode_found = false;
-	bool recalculate_timing = dm_state ? (dm_state->scaling != RMX_OFF) : false;
+	bool recalculate_timing = false;
+	bool scale = dm_state ? (dm_state->scaling != RMX_OFF) : false;
 	int mode_refresh;
 	int preferred_refresh = 0;
 #if defined(CONFIG_DRM_AMD_DC_DCN)
 		 */
 		DRM_DEBUG_DRIVER("No preferred mode found\n");
 	} else {
-		recalculate_timing |= amdgpu_freesync_vid_mode &&
+		recalculate_timing = amdgpu_freesync_vid_mode &&
 				 is_freesync_video_mode(&mode, aconnector);
 		if (recalculate_timing) {
 			freesync_mode = get_highest_refresh_rate_mode(aconnector, false);
 			mode = *freesync_mode;
 		} else {
 			decide_crtc_timing_for_drm_display_mode(
-				&mode, preferred_mode,
+				&mode, preferred_mode, scale);
-				dm_state ? (dm_state->scaling != RMX_OFF) : false);
-		}
-		preferred_refresh = drm_mode_vrefresh(preferred_mode);
+			preferred_refresh = drm_mode_vrefresh(preferred_mode);
+		}
 	}
 	if (recalculate_timing)
 	* If scaling is enabled and refresh rate didn't change
 	* we copy the vic and polarities of the old timings
 	*/
-	if (!recalculate_timing || mode_refresh != preferred_refresh)
+	if (!scale || mode_refresh != preferred_refresh)
 		fill_stream_properties_from_drm_display_mode(
 			stream, &mode, &aconnector->base, con_state, NULL,
 			requested_bpc);
 	if (cursor_scale_w != primary_scale_w ||
 	    cursor_scale_h != primary_scale_h) {
-		DRM_DEBUG_ATOMIC("Cursor plane scaling doesn't match primary plane\n");
+		drm_dbg_atomic(crtc->dev, "Cursor plane scaling doesn't match primary plane\n");
 		return -EINVAL;
 	}
 	int i;
 	struct drm_plane *plane;
 	struct drm_plane_state *old_plane_state, *new_plane_state;
-	struct drm_plane_state *primary_state, *overlay_state = NULL;
+	struct drm_plane_state *primary_state, *cursor_state, *overlay_state = NULL;
 	/* Check if primary plane is contained inside overlay */
 	for_each_oldnew_plane_in_state_reverse(state, plane, old_plane_state, new_plane_state, i) {
 	if (!primary_state->crtc)
 		return 0;
+	/* check if cursor plane is enabled */
+	cursor_state = drm_atomic_get_plane_state(state, overlay_state->crtc->cursor);
+	if (IS_ERR(cursor_state))
+		return PTR_ERR(cursor_state);
+	if (drm_atomic_plane_disabling(plane->state, cursor_state))
+		return 0;
 	/* Perform the bounds check to ensure the overlay plane covers the primary */
 	if (primary_state->crtc_x < overlay_state->crtc_x ||
 	    primary_state->crtc_y < overlay_state->crtc_y ||

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c+1−1

@@ -3236,7 +3236,7 @@ static noinline bool dcn20_validate_bandwidth_fp(struct dc *dc, · 3235 unmodified lines
3236	voltage_supported = dcn20_validate_bandwidth_internal(dc, context, false);	3236	voltage_supported = dcn20_validate_bandwidth_internal(dc, context, false);
3237	dummy_pstate_supported = context->bw_ctx.bw.dcn.clk.p_state_change_support;	3237	dummy_pstate_supported = context->bw_ctx.bw.dcn.clk.p_state_change_support;
3238		3238
3239	if (voltage_supported && dummy_pstate_supported) {	3239	if (voltage_supported && (dummy_pstate_supported \|\| !(context->stream_count))) {
3240	context->bw_ctx.bw.dcn.clk.p_state_change_support = false;	3240	context->bw_ctx.bw.dcn.clk.p_state_change_support = false;
3241	goto restore_dml_state;	3241	goto restore_dml_state;
3242	}	3242	}

drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu10_hwmgr.c+1−0

@@ -810,6 +810,7 @@ static int smu10_dpm_force_dpm_level(struct pp_hwmgr *hwmgr, · 809 unmodified lines
810	break;	810	break;
811	case AMD_DPM_FORCED_LEVEL_MANUAL:	811	case AMD_DPM_FORCED_LEVEL_MANUAL:
812	data->fine_grain_enabled = 1;	812	data->fine_grain_enabled = 1;
		813	break;
813	case AMD_DPM_FORCED_LEVEL_PROFILE_EXIT:	814	case AMD_DPM_FORCED_LEVEL_PROFILE_EXIT:
814	default:	815	default:
815	break;	816	break;

drivers/gpu/drm/drm_auth.c+2−1

 void drm_master_release(struct drm_file *file_priv)
 {
 	struct drm_device *dev = file_priv->minor->dev;
-	struct drm_master *master = file_priv->master;
+	struct drm_master *master;
 	mutex_lock(&dev->master_mutex);
+	master = file_priv->master;
 	if (file_priv->magic)
 		idr_remove(&file_priv->master->magic_map, file_priv->magic);

drivers/gpu/drm/drm_ioctl.c+5−4

 		  struct drm_file *file_priv)
 {
 	struct drm_unique *u = data;
-	struct drm_master *master = file_priv->master;
+	struct drm_master *master;
-	mutex_lock(&master->dev->master_mutex);
+	mutex_lock(&dev->master_mutex);
+	master = file_priv->master;
 	if (u->unique_len >= master->unique_len) {
 		if (copy_to_user(u->unique, master->unique, master->unique_len)) {
-			mutex_unlock(&master->dev->master_mutex);
+			mutex_unlock(&dev->master_mutex);
 			return -EFAULT;
 		}
 	}
 	u->unique_len = master->unique_len;
-	mutex_unlock(&master->dev->master_mutex);
+	mutex_unlock(&dev->master_mutex);
 	return 0;
 }

drivers/gpu/drm/i915/Kconfig+0−1

@@ -20,7 +20,6 @@ config DRM_I915 · 19 unmodified lines
20	select INPUT if ACPI	20	select INPUT if ACPI
21	select ACPI_VIDEO if ACPI	21	select ACPI_VIDEO if ACPI
22	select ACPI_BUTTON if ACPI	22	select ACPI_BUTTON if ACPI
23	select IO_MAPPING
24	select SYNC_FILE	23	select SYNC_FILE
25	select IOSF_MBI	24	select IOSF_MBI
26	select CRC32	25	select CRC32

drivers/gpu/drm/i915/gem/i915_gem_mman.c+5−4

@@ -367,10 +367,11 @@ retry: · 366 unmodified lines
367	goto err_unpin;	367	goto err_unpin;
368		368
369	/* Finally, remap it using the new GTT offset */	369	/* Finally, remap it using the new GTT offset */
370	ret = io_mapping_map_user(&ggtt->iomap, area, area->vm_start +	370	ret = remap_io_mapping(area,
371	(vma->ggtt_view.partial.offset << PAGE_SHIFT),	371	area->vm_start + (vma->ggtt_view.partial.offset << PAGE_SHIFT),
372	(ggtt->gmadr.start + vma->node.start) >> PAGE_SHIFT,	372	(ggtt->gmadr.start + vma->node.start) >> PAGE_SHIFT,
373	min_t(u64, vma->size, area->vm_end - area->vm_start));	373	min_t(u64, vma->size, area->vm_end - area->vm_start),
		374	&ggtt->iomap);
374	if (ret)	375	if (ret)
375	goto err_fence;	376	goto err_fence;
376		377

drivers/gpu/drm/i915/i915_drv.h+3−0

 			struct drm_file *file);
 /* i915_mm.c */
+int remap_io_mapping(struct vm_area_struct *vma,
+		     unsigned long addr, unsigned long pfn, unsigned long size,
+		     struct io_mapping *iomap);
 int remap_io_sg(struct vm_area_struct *vma,
 		unsigned long addr, unsigned long size,
 		struct scatterlist *sgl, resource_size_t iobase);

drivers/gpu/drm/i915/i915_mm.c+44−0

@@ -37,6 +37,17 @@ struct remap_pfn { · 36 unmodified lines
37	resource_size_t iobase;	37	resource_size_t iobase;
38	};	38	};
39		39
		40	static int remap_pfn(pte_t pte, unsigned long addr, void data)
		41	{
		42	struct remap_pfn *r = data;
		43
		44	/* Special PTE are not associated with any struct page */
		45	set_pte_at(r->mm, addr, pte, pte_mkspecial(pfn_pte(r->pfn, r->prot)));
		46	r->pfn++;
		47
		48	return 0;
		49	}
		50
40	#define use_dma(io) ((io) != -1)	51	#define use_dma(io) ((io) != -1)
41		52
42	static inline unsigned long sgt_pfn(const struct remap_pfn *r)	53	static inline unsigned long sgt_pfn(const struct remap_pfn *r)
@@ -66,7 +77,40 @@ static int remap_sg(pte_t pte, unsigned long addr, void data) · 23 unmodified lines
66	return 0;	77	return 0;
67	}	78	}
68		79
		80	/**
		81	* remap_io_mapping - remap an IO mapping to userspace
		82	* @vma: user vma to map to
		83	* @addr: target user address to start at
		84	* @pfn: physical address of kernel memory
		85	* @size: size of map area
		86	* @iomap: the source io_mapping
		87	*
		88	* Note: this is only safe if the mm semaphore is held when called.
		89	*/
		90	int remap_io_mapping(struct vm_area_struct *vma,
		91	unsigned long addr, unsigned long pfn, unsigned long size,
		92	struct io_mapping *iomap)
		93	{
		94	struct remap_pfn r;
		95	int err;
		96
69	#define EXPECTED_FLAGS (VM_PFNMAP \| VM_DONTEXPAND \| VM_DONTDUMP)	97	#define EXPECTED_FLAGS (VM_PFNMAP \| VM_DONTEXPAND \| VM_DONTDUMP)
		98	GEM_BUG_ON((vma->vm_flags & EXPECTED_FLAGS) != EXPECTED_FLAGS);
		99
		100	/* We rely on prevalidation of the io-mapping to skip track_pfn(). */
		101	r.mm = vma->vm_mm;
		102	r.pfn = pfn;
		103	r.prot = __pgprot((pgprot_val(iomap->prot) & _PAGE_CACHE_MASK) \|
		104	(pgprot_val(vma->vm_page_prot) & ~_PAGE_CACHE_MASK));
		105
		106	err = apply_to_page_range(r.mm, addr, size, remap_pfn, &r);
		107	if (unlikely(err)) {
		108	zap_vma_ptes(vma, addr, (r.pfn - pfn) << PAGE_SHIFT);
		109	return err;
		110	}
		111
		112	return 0;
		113	}
70		114
71	/**	115	/**
72	* remap_io_sg - remap an IO mapping to userspace	116	* remap_io_sg - remap an IO mapping to userspace

drivers/gpu/drm/i915/selftests/i915_request.c+2−2

@@ -1592,8 +1592,8 @@ static int live_breadcrumbs_smoketest(void *arg) · 1591 unmodified lines
1592		1592
1593	for (n = 0; n < smoke[0].ncontexts; n++) {	1593	for (n = 0; n < smoke[0].ncontexts; n++) {
1594	smoke[0].contexts[n] = live_context(i915, file);	1594	smoke[0].contexts[n] = live_context(i915, file);
1595	if (!smoke[0].contexts[n]) {	1595	if (IS_ERR(smoke[0].contexts[n])) {
1596	ret = -ENOMEM;	1596	ret = PTR_ERR(smoke[0].contexts[n]);
1597	goto out_contexts;	1597	goto out_contexts;
1598	}	1598	}
1599	}	1599	}

drivers/gpu/drm/mcde/mcde_dsi.c+1−1

@@ -577,7 +577,7 @@ static void mcde_dsi_setup_video_mode(struct mcde_dsi *d, · 576 unmodified lines
577	* porches and sync.	577	* porches and sync.
578	*/	578	*/
579	/* (ps/s) / (pixels/s) = ps/pixels */	579	/* (ps/s) / (pixels/s) = ps/pixels */
580	pclk = DIV_ROUND_UP_ULL(1000000000000, mode->clock);	580	pclk = DIV_ROUND_UP_ULL(1000000000000, (mode->clock * 1000));
581	dev_dbg(d->dev, "picoseconds between two pixels: %llu\n",	581	dev_dbg(d->dev, "picoseconds between two pixels: %llu\n",
582	pclk);	582	pclk);
583		583

drivers/gpu/drm/msm/adreno/a6xx_gpu.c+114−41

@@ -157,7 +157,7 @@ static void a6xx_submit(struct msm_gpu gpu, struct msm_gem_submit submit) · 156 unmodified lines
157	* GPU registers so we need to add 0x1a800 to the register value on A630	157	* GPU registers so we need to add 0x1a800 to the register value on A630
158	* to get the right value from PM4.	158	* to get the right value from PM4.
159	*/	159	*/
160	get_stats_counter(ring, REG_A6XX_GMU_ALWAYS_ON_COUNTER_L + 0x1a800,	160	get_stats_counter(ring, REG_A6XX_CP_ALWAYS_ON_COUNTER_LO,
161	rbmemptr_stats(ring, index, alwayson_start));	161	rbmemptr_stats(ring, index, alwayson_start));
162		162
163	/* Invalidate CCU depth and color */	163	/* Invalidate CCU depth and color */
@@ -187,7 +187,7 @@ static void a6xx_submit(struct msm_gpu gpu, struct msm_gem_submit submit) · 23 unmodified lines
187		187
188	get_stats_counter(ring, REG_A6XX_RBBM_PERFCTR_CP_0_LO,	188	get_stats_counter(ring, REG_A6XX_RBBM_PERFCTR_CP_0_LO,
189	rbmemptr_stats(ring, index, cpcycles_end));	189	rbmemptr_stats(ring, index, cpcycles_end));
190	get_stats_counter(ring, REG_A6XX_GMU_ALWAYS_ON_COUNTER_L + 0x1a800,	190	get_stats_counter(ring, REG_A6XX_CP_ALWAYS_ON_COUNTER_LO,
191	rbmemptr_stats(ring, index, alwayson_end));	191	rbmemptr_stats(ring, index, alwayson_end));
192		192
193	/* Write the fence to the scratch register */	193	/* Write the fence to the scratch register */
@@ -206,8 +206,8 @@ static void a6xx_submit(struct msm_gpu gpu, struct msm_gem_submit submit) · 12 unmodified lines
206	OUT_RING(ring, submit->seqno);	206	OUT_RING(ring, submit->seqno);
207		207
208	trace_msm_gpu_submit_flush(submit,	208	trace_msm_gpu_submit_flush(submit,
209	gmu_read64(&a6xx_gpu->gmu, REG_A6XX_GMU_ALWAYS_ON_COUNTER_L,	209	gpu_read64(gpu, REG_A6XX_CP_ALWAYS_ON_COUNTER_LO,
210	REG_A6XX_GMU_ALWAYS_ON_COUNTER_H));	210	REG_A6XX_CP_ALWAYS_ON_COUNTER_HI));
211		211
212	a6xx_flush(gpu, ring);	212	a6xx_flush(gpu, ring);
213	}	213	}
@@ -462,6 +462,113 @@ static void a6xx_set_hwcg(struct msm_gpu *gpu, bool state) · 248 unmodified lines
462	gpu_write(gpu, REG_A6XX_RBBM_CLOCK_CNTL, state ? clock_cntl_on : 0);	462	gpu_write(gpu, REG_A6XX_RBBM_CLOCK_CNTL, state ? clock_cntl_on : 0);
463	}	463	}
464		464
		465	/* For a615, a616, a618, A619, a630, a640 and a680 */
		466	static const u32 a6xx_protect[] = {
		467	A6XX_PROTECT_RDONLY(0x00000, 0x04ff),
		468	A6XX_PROTECT_RDONLY(0x00501, 0x0005),
		469	A6XX_PROTECT_RDONLY(0x0050b, 0x02f4),
		470	A6XX_PROTECT_NORDWR(0x0050e, 0x0000),
		471	A6XX_PROTECT_NORDWR(0x00510, 0x0000),
		472	A6XX_PROTECT_NORDWR(0x00534, 0x0000),
		473	A6XX_PROTECT_NORDWR(0x00800, 0x0082),
		474	A6XX_PROTECT_NORDWR(0x008a0, 0x0008),
		475	A6XX_PROTECT_NORDWR(0x008ab, 0x0024),
		476	A6XX_PROTECT_RDONLY(0x008de, 0x00ae),
		477	A6XX_PROTECT_NORDWR(0x00900, 0x004d),
		478	A6XX_PROTECT_NORDWR(0x0098d, 0x0272),
		479	A6XX_PROTECT_NORDWR(0x00e00, 0x0001),
		480	A6XX_PROTECT_NORDWR(0x00e03, 0x000c),
		481	A6XX_PROTECT_NORDWR(0x03c00, 0x00c3),
		482	A6XX_PROTECT_RDONLY(0x03cc4, 0x1fff),
		483	A6XX_PROTECT_NORDWR(0x08630, 0x01cf),
		484	A6XX_PROTECT_NORDWR(0x08e00, 0x0000),
		485	A6XX_PROTECT_NORDWR(0x08e08, 0x0000),
		486	A6XX_PROTECT_NORDWR(0x08e50, 0x001f),
		487	A6XX_PROTECT_NORDWR(0x09624, 0x01db),
		488	A6XX_PROTECT_NORDWR(0x09e70, 0x0001),
		489	A6XX_PROTECT_NORDWR(0x09e78, 0x0187),
		490	A6XX_PROTECT_NORDWR(0x0a630, 0x01cf),
		491	A6XX_PROTECT_NORDWR(0x0ae02, 0x0000),
		492	A6XX_PROTECT_NORDWR(0x0ae50, 0x032f),
		493	A6XX_PROTECT_NORDWR(0x0b604, 0x0000),
		494	A6XX_PROTECT_NORDWR(0x0be02, 0x0001),
		495	A6XX_PROTECT_NORDWR(0x0be20, 0x17df),
		496	A6XX_PROTECT_NORDWR(0x0f000, 0x0bff),
		497	A6XX_PROTECT_RDONLY(0x0fc00, 0x1fff),
		498	A6XX_PROTECT_NORDWR(0x11c00, 0x0000), /* note: infinite range */
		499	};
		500
		501	/* These are for a620 and a650 */
		502	static const u32 a650_protect[] = {
		503	A6XX_PROTECT_RDONLY(0x00000, 0x04ff),
		504	A6XX_PROTECT_RDONLY(0x00501, 0x0005),
		505	A6XX_PROTECT_RDONLY(0x0050b, 0x02f4),
		506	A6XX_PROTECT_NORDWR(0x0050e, 0x0000),
		507	A6XX_PROTECT_NORDWR(0x00510, 0x0000),
		508	A6XX_PROTECT_NORDWR(0x00534, 0x0000),
		509	A6XX_PROTECT_NORDWR(0x00800, 0x0082),
		510	A6XX_PROTECT_NORDWR(0x008a0, 0x0008),
		511	A6XX_PROTECT_NORDWR(0x008ab, 0x0024),
		512	A6XX_PROTECT_RDONLY(0x008de, 0x00ae),
		513	A6XX_PROTECT_NORDWR(0x00900, 0x004d),
		514	A6XX_PROTECT_NORDWR(0x0098d, 0x0272),
		515	A6XX_PROTECT_NORDWR(0x00e00, 0x0001),
		516	A6XX_PROTECT_NORDWR(0x00e03, 0x000c),
		517	A6XX_PROTECT_NORDWR(0x03c00, 0x00c3),
		518	A6XX_PROTECT_RDONLY(0x03cc4, 0x1fff),
		519	A6XX_PROTECT_NORDWR(0x08630, 0x01cf),
		520	A6XX_PROTECT_NORDWR(0x08e00, 0x0000),
		521	A6XX_PROTECT_NORDWR(0x08e08, 0x0000),
		522	A6XX_PROTECT_NORDWR(0x08e50, 0x001f),
		523	A6XX_PROTECT_NORDWR(0x08e80, 0x027f),
		524	A6XX_PROTECT_NORDWR(0x09624, 0x01db),
		525	A6XX_PROTECT_NORDWR(0x09e60, 0x0011),
		526	A6XX_PROTECT_NORDWR(0x09e78, 0x0187),
		527	A6XX_PROTECT_NORDWR(0x0a630, 0x01cf),
		528	A6XX_PROTECT_NORDWR(0x0ae02, 0x0000),
		529	A6XX_PROTECT_NORDWR(0x0ae50, 0x032f),
		530	A6XX_PROTECT_NORDWR(0x0b604, 0x0000),
		531	A6XX_PROTECT_NORDWR(0x0b608, 0x0007),
		532	A6XX_PROTECT_NORDWR(0x0be02, 0x0001),
		533	A6XX_PROTECT_NORDWR(0x0be20, 0x17df),
		534	A6XX_PROTECT_NORDWR(0x0f000, 0x0bff),
		535	A6XX_PROTECT_RDONLY(0x0fc00, 0x1fff),
		536	A6XX_PROTECT_NORDWR(0x18400, 0x1fff),
		537	A6XX_PROTECT_NORDWR(0x1a800, 0x1fff),
		538	A6XX_PROTECT_NORDWR(0x1f400, 0x0443),
		539	A6XX_PROTECT_RDONLY(0x1f844, 0x007b),
		540	A6XX_PROTECT_NORDWR(0x1f887, 0x001b),
		541	A6XX_PROTECT_NORDWR(0x1f8c0, 0x0000), /* note: infinite range */
		542	};
		543
		544	static void a6xx_set_cp_protect(struct msm_gpu *gpu)
		545	{
		546	struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
		547	const u32 *regs = a6xx_protect;
		548	unsigned i, count = ARRAY_SIZE(a6xx_protect), count_max = 32;
		549
		550	BUILD_BUG_ON(ARRAY_SIZE(a6xx_protect) > 32);
		551	BUILD_BUG_ON(ARRAY_SIZE(a650_protect) > 48);
		552
		553	if (adreno_is_a650(adreno_gpu)) {
		554	regs = a650_protect;
		555	count = ARRAY_SIZE(a650_protect);
		556	count_max = 48;
		557	}
		558
		559	/*
		560	* Enable access protection to privileged registers, fault on an access
		561	* protect violation and select the last span to protect from the start
		562	* address all the way to the end of the register address space
		563	*/
		564	gpu_write(gpu, REG_A6XX_CP_PROTECT_CNTL, BIT(0) \| BIT(1) \| BIT(3));
		565
		566	for (i = 0; i < count - 1; i++)
		567	gpu_write(gpu, REG_A6XX_CP_PROTECT(i), regs[i]);
		568	/* last CP_PROTECT to have "infinite" length on the last entry */
		569	gpu_write(gpu, REG_A6XX_CP_PROTECT(count_max - 1), regs[i]);
		570	}
		571
465	static void a6xx_set_ubwc_config(struct msm_gpu *gpu)	572	static void a6xx_set_ubwc_config(struct msm_gpu *gpu)
466	{	573	{
467	struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);	574	struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
@@ -489,7 +596,7 @@ static void a6xx_set_ubwc_config(struct msm_gpu *gpu) · 21 unmodified lines
489	rgb565_predicator << 11 \| amsbc << 4 \| lower_bit << 1);	596	rgb565_predicator << 11 \| amsbc << 4 \| lower_bit << 1);
490	gpu_write(gpu, REG_A6XX_TPL1_NC_MODE_CNTL, lower_bit << 1);	597	gpu_write(gpu, REG_A6XX_TPL1_NC_MODE_CNTL, lower_bit << 1);
491	gpu_write(gpu, REG_A6XX_SP_NC_MODE_CNTL,	598	gpu_write(gpu, REG_A6XX_SP_NC_MODE_CNTL,
492	uavflagprd_inv >> 4 \| lower_bit << 1);	599	uavflagprd_inv << 4 \| lower_bit << 1);
493	gpu_write(gpu, REG_A6XX_UCHE_MODE_CNTL, lower_bit << 21);	600	gpu_write(gpu, REG_A6XX_UCHE_MODE_CNTL, lower_bit << 21);
494	}	601	}
495		602
@@ -776,41 +883,7 @@ static int a6xx_hw_init(struct msm_gpu *gpu) · 280 unmodified lines
776	}	883	}
777		884
778	/* Protect registers from the CP */	885	/* Protect registers from the CP */
779	gpu_write(gpu, REG_A6XX_CP_PROTECT_CNTL, 0x00000003);	886	a6xx_set_cp_protect(gpu);
780
781	gpu_write(gpu, REG_A6XX_CP_PROTECT(0),
782	A6XX_PROTECT_RDONLY(0x600, 0x51));
783	gpu_write(gpu, REG_A6XX_CP_PROTECT(1), A6XX_PROTECT_RW(0xae50, 0x2));
784	gpu_write(gpu, REG_A6XX_CP_PROTECT(2), A6XX_PROTECT_RW(0x9624, 0x13));
785	gpu_write(gpu, REG_A6XX_CP_PROTECT(3), A6XX_PROTECT_RW(0x8630, 0x8));
786	gpu_write(gpu, REG_A6XX_CP_PROTECT(4), A6XX_PROTECT_RW(0x9e70, 0x1));
787	gpu_write(gpu, REG_A6XX_CP_PROTECT(5), A6XX_PROTECT_RW(0x9e78, 0x187));
788	gpu_write(gpu, REG_A6XX_CP_PROTECT(6), A6XX_PROTECT_RW(0xf000, 0x810));
789	gpu_write(gpu, REG_A6XX_CP_PROTECT(7),
790	A6XX_PROTECT_RDONLY(0xfc00, 0x3));
791	gpu_write(gpu, REG_A6XX_CP_PROTECT(8), A6XX_PROTECT_RW(0x50e, 0x0));
792	gpu_write(gpu, REG_A6XX_CP_PROTECT(9), A6XX_PROTECT_RDONLY(0x50f, 0x0));
793	gpu_write(gpu, REG_A6XX_CP_PROTECT(10), A6XX_PROTECT_RW(0x510, 0x0));
794	gpu_write(gpu, REG_A6XX_CP_PROTECT(11),
795	A6XX_PROTECT_RDONLY(0x0, 0x4f9));
796	gpu_write(gpu, REG_A6XX_CP_PROTECT(12),
797	A6XX_PROTECT_RDONLY(0x501, 0xa));
798	gpu_write(gpu, REG_A6XX_CP_PROTECT(13),
799	A6XX_PROTECT_RDONLY(0x511, 0x44));
800	gpu_write(gpu, REG_A6XX_CP_PROTECT(14), A6XX_PROTECT_RW(0xe00, 0xe));
801	gpu_write(gpu, REG_A6XX_CP_PROTECT(15), A6XX_PROTECT_RW(0x8e00, 0x0));
802	gpu_write(gpu, REG_A6XX_CP_PROTECT(16), A6XX_PROTECT_RW(0x8e50, 0xf));
803	gpu_write(gpu, REG_A6XX_CP_PROTECT(17), A6XX_PROTECT_RW(0xbe02, 0x0));
804	gpu_write(gpu, REG_A6XX_CP_PROTECT(18),
805	A6XX_PROTECT_RW(0xbe20, 0x11f3));
806	gpu_write(gpu, REG_A6XX_CP_PROTECT(19), A6XX_PROTECT_RW(0x800, 0x82));
807	gpu_write(gpu, REG_A6XX_CP_PROTECT(20), A6XX_PROTECT_RW(0x8a0, 0x8));
808	gpu_write(gpu, REG_A6XX_CP_PROTECT(21), A6XX_PROTECT_RW(0x8ab, 0x19));
809	gpu_write(gpu, REG_A6XX_CP_PROTECT(22), A6XX_PROTECT_RW(0x900, 0x4d));
810	gpu_write(gpu, REG_A6XX_CP_PROTECT(23), A6XX_PROTECT_RW(0x98d, 0x76));
811	gpu_write(gpu, REG_A6XX_CP_PROTECT(24),
812	A6XX_PROTECT_RDONLY(0x980, 0x4));
813	gpu_write(gpu, REG_A6XX_CP_PROTECT(25), A6XX_PROTECT_RW(0xa630, 0x0));
814		887
815	/* Enable expanded apriv for targets that support it */	888	/* Enable expanded apriv for targets that support it */
816	if (gpu->hw_apriv) {	889	if (gpu->hw_apriv) {
@@ -1211,7 +1284,7 @@ static int a6xx_pm_suspend(struct msm_gpu *gpu) · 394 unmodified lines
1211	if (ret)	1284	if (ret)
1212	return ret;	1285	return ret;
1213		1286
1214	if (adreno_gpu->base.hw_apriv \|\| a6xx_gpu->has_whereami)	1287	if (a6xx_gpu->shadow_bo)
1215	for (i = 0; i < gpu->nr_rings; i++)	1288	for (i = 0; i < gpu->nr_rings; i++)
1216	a6xx_gpu->shadow[i] = 0;	1289	a6xx_gpu->shadow[i] = 0;
1217		1290

drivers/gpu/drm/msm/adreno/a6xx_gpu.h+1−1

@@ -44,7 +44,7 @@ struct a6xx_gpu { · 43 unmodified lines
44	* REG_CP_PROTECT_REG(n) - this will block both reads and writes for _len	44	* REG_CP_PROTECT_REG(n) - this will block both reads and writes for _len
45	* registers starting at _reg.	45	* registers starting at _reg.
46	*/	46	*/
47	#define A6XX_PROTECT_RW(_reg, _len) \	47	#define A6XX_PROTECT_NORDWR(_reg, _len) \
48	((1 << 31) \| \	48	((1 << 31) \| \
49	(((_len) & 0x3FFF) << 18) \| ((_reg) & 0x3FFFF))	49	(((_len) & 0x3FFF) << 18) \| ((_reg) & 0x3FFFF))
50		50

drivers/gpu/drm/msm/dsi/phy/dsi_phy_10nm.c+1−0

@@ -432,6 +432,7 @@ static unsigned long dsi_pll_10nm_vco_recalc_rate(struct clk_hw *hw, · 431 unmodified lines
432	pll_freq += div_u64(tmp64, multiplier);	432	pll_freq += div_u64(tmp64, multiplier);
433		433
434	vco_rate = pll_freq;	434	vco_rate = pll_freq;
		435	pll_10nm->vco_current_rate = vco_rate;
435		436
436	DBG("DSI PLL%d returning vco rate = %lu, dec = %x, frac = %x",	437	DBG("DSI PLL%d returning vco rate = %lu, dec = %x, frac = %x",
437	pll_10nm->phy->id, (unsigned long)vco_rate, dec, frac);	438	pll_10nm->phy->id, (unsigned long)vco_rate, dec, frac);

drivers/gpu/drm/msm/dsi/phy/dsi_phy_7nm.c+1−0

@@ -460,6 +460,7 @@ static unsigned long dsi_pll_7nm_vco_recalc_rate(struct clk_hw *hw, · 459 unmodified lines
460	pll_freq += div_u64(tmp64, multiplier);	460	pll_freq += div_u64(tmp64, multiplier);
461		461
462	vco_rate = pll_freq;	462	vco_rate = pll_freq;
		463	pll_7nm->vco_current_rate = vco_rate;
463		464
464	DBG("DSI PLL%d returning vco rate = %lu, dec = %x, frac = %x",	465	DBG("DSI PLL%d returning vco rate = %lu, dec = %x, frac = %x",
465	pll_7nm->phy->id, (unsigned long)vco_rate, dec, frac);	466	pll_7nm->phy->id, (unsigned long)vco_rate, dec, frac);

drivers/gpu/drm/msm/msm_gem.c+7−0

@@ -1241,6 +1241,13 @@ static struct drm_gem_object _msm_gem_new(struct drm_device dev, · 1240 unmodified lines
1241		1241
1242	to_msm_bo(obj)->vram_node = &vma->node;	1242	to_msm_bo(obj)->vram_node = &vma->node;
1243		1243
		1244	/* Call chain get_pages() -> update_inactive() tries to
		1245	* access msm_obj->mm_list, but it is not initialized yet.
		1246	* To avoid NULL pointer dereference error, initialize
		1247	* mm_list to be empty.
		1248	*/
		1249	INIT_LIST_HEAD(&msm_obj->mm_list);
		1250
1244	msm_gem_lock(obj);	1251	msm_gem_lock(obj);
1245	pages = get_pages(obj);	1252	pages = get_pages(obj);
1246	msm_gem_unlock(obj);	1253	msm_gem_unlock(obj);

drivers/gpu/drm/radeon/radeon_uvd.c+2−2

@@ -286,7 +286,7 @@ int radeon_uvd_resume(struct radeon_device *rdev) · 285 unmodified lines
286	if (rdev->uvd.vcpu_bo == NULL)	286	if (rdev->uvd.vcpu_bo == NULL)
287	return -EINVAL;	287	return -EINVAL;
288		288
289	memcpy(rdev->uvd.cpu_addr, rdev->uvd_fw->data, rdev->uvd_fw->size);	289	memcpy_toio((void __iomem *)rdev->uvd.cpu_addr, rdev->uvd_fw->data, rdev->uvd_fw->size);
290		290
291	size = radeon_bo_size(rdev->uvd.vcpu_bo);	291	size = radeon_bo_size(rdev->uvd.vcpu_bo);
292	size -= rdev->uvd_fw->size;	292	size -= rdev->uvd_fw->size;
@@ -294,7 +294,7 @@ int radeon_uvd_resume(struct radeon_device *rdev) · 1 unmodified line
294	ptr = rdev->uvd.cpu_addr;	294	ptr = rdev->uvd.cpu_addr;
295	ptr += rdev->uvd_fw->size;	295	ptr += rdev->uvd_fw->size;
296		296
297	memset(ptr, 0, size);	297	memset_io((void __iomem *)ptr, 0, size);
298		298
299	return 0;	299	return 0;
300	}	300	}

drivers/gpu/drm/sun4i/sun8i_dw_hdmi.c+27−4

@@ -209,7 +209,7 @@ static int sun8i_dw_hdmi_bind(struct device dev, struct device master, · 208 unmodified lines
209	goto err_disable_clk_tmds;	209	goto err_disable_clk_tmds;
210	}	210	}
211		211
212	ret = sun8i_hdmi_phy_probe(hdmi, phy_node);	212	ret = sun8i_hdmi_phy_get(hdmi, phy_node);
213	of_node_put(phy_node);	213	of_node_put(phy_node);
214	if (ret) {	214	if (ret) {
215	dev_err(dev, "Couldn't get the HDMI PHY\n");	215	dev_err(dev, "Couldn't get the HDMI PHY\n");
@@ -242,7 +242,6 @@ static int sun8i_dw_hdmi_bind(struct device dev, struct device master, · 26 unmodified lines
242		242
243	cleanup_encoder:	243	cleanup_encoder:
244	drm_encoder_cleanup(encoder);	244	drm_encoder_cleanup(encoder);
245	sun8i_hdmi_phy_remove(hdmi);
246	err_disable_clk_tmds:	245	err_disable_clk_tmds:
247	clk_disable_unprepare(hdmi->clk_tmds);	246	clk_disable_unprepare(hdmi->clk_tmds);
248	err_assert_ctrl_reset:	247	err_assert_ctrl_reset:
@@ -263,7 +262,6 @@ static void sun8i_dw_hdmi_unbind(struct device dev, struct device master, · 14 unmodified lines
263	struct sun8i_dw_hdmi *hdmi = dev_get_drvdata(dev);	262	struct sun8i_dw_hdmi *hdmi = dev_get_drvdata(dev);
264		263
265	dw_hdmi_unbind(hdmi->hdmi);	264	dw_hdmi_unbind(hdmi->hdmi);
266	sun8i_hdmi_phy_remove(hdmi);
267	clk_disable_unprepare(hdmi->clk_tmds);	265	clk_disable_unprepare(hdmi->clk_tmds);
268	reset_control_assert(hdmi->rst_ctrl);	266	reset_control_assert(hdmi->rst_ctrl);
269	gpiod_set_value(hdmi->ddc_en, 0);	267	gpiod_set_value(hdmi->ddc_en, 0);
@@ -320,7 +318,32 @@ static struct platform_driver sun8i_dw_hdmi_pltfm_driver = { · 50 unmodified lines
320	.of_match_table = sun8i_dw_hdmi_dt_ids,	318	.of_match_table = sun8i_dw_hdmi_dt_ids,
321	},	319	},
322	};	320	};
323	module_platform_driver(sun8i_dw_hdmi_pltfm_driver);	321
		322	static int __init sun8i_dw_hdmi_init(void)
		323	{
		324	int ret;
		325
		326	ret = platform_driver_register(&sun8i_dw_hdmi_pltfm_driver);
		327	if (ret)
		328	return ret;
		329
		330	ret = platform_driver_register(&sun8i_hdmi_phy_driver);
		331	if (ret) {
		332	platform_driver_unregister(&sun8i_dw_hdmi_pltfm_driver);
		333	return ret;
		334	}
		335
		336	return ret;
		337	}
		338
		339	static void __exit sun8i_dw_hdmi_exit(void)
		340	{
		341	platform_driver_unregister(&sun8i_dw_hdmi_pltfm_driver);
		342	platform_driver_unregister(&sun8i_hdmi_phy_driver);
		343	}
		344
		345	module_init(sun8i_dw_hdmi_init);
		346	module_exit(sun8i_dw_hdmi_exit);
324		347
325	MODULE_AUTHOR("Jernej Skrabec <jernej.skrabec@siol.net>");	348	MODULE_AUTHOR("Jernej Skrabec <jernej.skrabec@siol.net>");
326	MODULE_DESCRIPTION("Allwinner DW HDMI bridge");	349	MODULE_DESCRIPTION("Allwinner DW HDMI bridge");

drivers/gpu/drm/sun4i/sun8i_dw_hdmi.h+3−2

 	struct gpio_desc		*ddc_en;
 };
+extern struct platform_driver sun8i_hdmi_phy_driver;
 static inline struct sun8i_dw_hdmi *
 encoder_to_sun8i_dw_hdmi(struct drm_encoder *encoder)
 {
 	return container_of(encoder, struct sun8i_dw_hdmi, encoder);
 }
-int sun8i_hdmi_phy_probe(struct sun8i_dw_hdmi *hdmi, struct device_node *node);
+int sun8i_hdmi_phy_get(struct sun8i_dw_hdmi *hdmi, struct device_node *node);
-void sun8i_hdmi_phy_remove(struct sun8i_dw_hdmi *hdmi);
 void sun8i_hdmi_phy_init(struct sun8i_hdmi_phy *phy);
 void sun8i_hdmi_phy_set_ops(struct sun8i_hdmi_phy *phy,

drivers/gpu/drm/sun4i/sun8i_hdmi_phy.c+36−5

 #include <linux/delay.h>
 #include <linux/of_address.h>
+#include <linux/of_platform.h>
 #include "sun8i_dw_hdmi.h"
 	{ /* sentinel */ }
 };
-int sun8i_hdmi_phy_probe(struct sun8i_dw_hdmi *hdmi, struct device_node *node)
+int sun8i_hdmi_phy_get(struct sun8i_dw_hdmi *hdmi, struct device_node *node)
+{
+	struct platform_device *pdev = of_find_device_by_node(node);
+	struct sun8i_hdmi_phy *phy;
+	if (!pdev)
+		return -EPROBE_DEFER;
+	phy = platform_get_drvdata(pdev);
+	if (!phy)
+		return -EPROBE_DEFER;
+	hdmi->phy = phy;
+	put_device(&pdev->dev);
+	return 0;
+}
+static int sun8i_hdmi_phy_probe(struct platform_device *pdev)
 {
 	const struct of_device_id *match;
-	struct device *dev = hdmi->dev;
+	struct device *dev = &pdev->dev;
+	struct device_node *node = dev->of_node;
 	struct sun8i_hdmi_phy *phy;
 	struct resource res;
 	void __iomem *regs;
 		clk_prepare_enable(phy->clk_phy);
 	}
-	hdmi->phy = phy;
+	platform_set_drvdata(pdev, phy);
 	return 0;
 	return ret;
 }
-void sun8i_hdmi_phy_remove(struct sun8i_dw_hdmi *hdmi)
+static int sun8i_hdmi_phy_remove(struct platform_device *pdev)
 {
-	struct sun8i_hdmi_phy *phy = hdmi->phy;
+	struct sun8i_hdmi_phy *phy = platform_get_drvdata(pdev);
 	clk_disable_unprepare(phy->clk_mod);
 	clk_disable_unprepare(phy->clk_bus);
 	clk_put(phy->clk_pll1);
 	clk_put(phy->clk_mod);
 	clk_put(phy->clk_bus);
+	return 0;
 }
+struct platform_driver sun8i_hdmi_phy_driver = {
+	.probe  = sun8i_hdmi_phy_probe,
+	.remove = sun8i_hdmi_phy_remove,
+	.driver = {
+		.name = "sun8i-hdmi-phy",
+		.of_match_table = sun8i_hdmi_phy_of_table,
+	},
+};

drivers/gpu/drm/tegra/drm.h+1−1

@@ -25,7 +25,7 @@ · 24 unmodified lines
25	#include "trace.h"	25	#include "trace.h"
26		26
27	/* XXX move to include/uapi/drm/drm_fourcc.h? */	27	/* XXX move to include/uapi/drm/drm_fourcc.h? */
28	#define DRM_FORMAT_MOD_NVIDIA_SECTOR_LAYOUT BIT(22)	28	#define DRM_FORMAT_MOD_NVIDIA_SECTOR_LAYOUT BIT_ULL(22)
29		29
30	struct reset_control;	30	struct reset_control;
31		31

drivers/gpu/drm/tegra/hub.c+1−1

@@ -510,7 +510,7 @@ static void tegra_shared_plane_atomic_update(struct drm_plane *plane, · 509 unmodified lines
510	* dGPU sector layout.	510	* dGPU sector layout.
511	*/	511	*/
512	if (tegra_plane_state->tiling.sector_layout == TEGRA_BO_SECTOR_LAYOUT_GPU)	512	if (tegra_plane_state->tiling.sector_layout == TEGRA_BO_SECTOR_LAYOUT_GPU)
513	base \|= BIT(39);	513	base \|= BIT_ULL(39);
514	#endif	514	#endif
515		515
516	tegra_plane_writel(p, tegra_plane_state->format, DC_WIN_COLOR_DEPTH);	516	tegra_plane_writel(p, tegra_plane_state->format, DC_WIN_COLOR_DEPTH);

drivers/gpu/drm/tegra/sor.c+42−28

 		if (err < 0) {
 			dev_err(sor->dev, "failed to acquire SOR reset: %d\n",
 				err);
-			return err;
+			goto rpm_put;
 		}
 		err = reset_control_assert(sor->rst);
 		if (err < 0) {
 			dev_err(sor->dev, "failed to assert SOR reset: %d\n",
 				err);
-			return err;
+			goto rpm_put;
 		}
 	}
 	err = clk_prepare_enable(sor->clk);
 	if (err < 0) {
 		dev_err(sor->dev, "failed to enable clock: %d\n", err);
-		return err;
+		goto rpm_put;
 	}
 	usleep_range(1000, 3000);
 			dev_err(sor->dev, "failed to deassert SOR reset: %d\n",
 				err);
 			clk_disable_unprepare(sor->clk);
-			return err;
+			goto rpm_put;
 		}
 		reset_control_release(sor->rst);
 	}
 	return 0;
+rpm_put:
+	if (sor->rst)
+		pm_runtime_put(sor->dev);
+	return err;
 }
 static int tegra_sor_exit(struct host1x_client *client)
 		if (!sor->aux)
 			return -EPROBE_DEFER;
-		if (get_device(&sor->aux->ddc.dev)) {
+		if (get_device(sor->aux->dev))
-			if (try_module_get(sor->aux->ddc.owner))
+			sor->output.ddc = &sor->aux->ddc;
-				sor->output.ddc = &sor->aux->ddc;
-			else
-				put_device(&sor->aux->ddc.dev);
-		}
 	}
 	if (!sor->aux) {
 	err = tegra_sor_parse_dt(sor);
 	if (err < 0)
-		return err;
+		goto put_aux;
 	err = tegra_output_probe(&sor->output);
-	if (err < 0)
+	if (err < 0) {
-		return dev_err_probe(&pdev->dev, err,
+		dev_err_probe(&pdev->dev, err, "failed to probe output\n");
-				     "failed to probe output\n");
+		goto put_aux;
+	}
 	if (sor->ops && sor->ops->probe) {
 		err = sor->ops->probe(sor);
 	platform_set_drvdata(pdev, sor);
 	pm_runtime_enable(&pdev->dev);
-	INIT_LIST_HEAD(&sor->client.list);
+	host1x_client_init(&sor->client);
 	sor->client.ops = &sor_client_ops;
 	sor->client.dev = &pdev->dev;
-	err = host1x_client_register(&sor->client);
-	if (err < 0) {
-		dev_err(&pdev->dev, "failed to register host1x client: %d\n",
-			err);
-		goto rpm_disable;
-	}
 	/*
 	 * On Tegra210 and earlier, provide our own implementation for the
 	 * pad output clock.
 				      sor->index);
 		if (!name) {
 			err = -ENOMEM;
-			goto unregister;
+			goto uninit;
 		}
 		err = host1x_client_resume(&sor->client);
 		if (err < 0) {
 			dev_err(sor->dev, "failed to resume: %d\n", err);
-			goto unregister;
+			goto uninit;
 		}
 		sor->clk_pad = tegra_clk_sor_pad_register(sor, name);
 		err = PTR_ERR(sor->clk_pad);
 		dev_err(sor->dev, "failed to register SOR pad clock: %d\n",
 			err);
-		goto unregister;
+		goto uninit;
+	}
+	err = __host1x_client_register(&sor->client);
+	if (err < 0) {
+		dev_err(&pdev->dev, "failed to register host1x client: %d\n",
+			err);
+		goto uninit;
 	}
 	return 0;
-unregister:
+uninit:
-	host1x_client_unregister(&sor->client);
+	host1x_client_exit(&sor->client);
-rpm_disable:
 	pm_runtime_disable(&pdev->dev);
 remove:
+	if (sor->aux)
+		sor->output.ddc = NULL;
 	tegra_output_remove(&sor->output);
+put_aux:
+	if (sor->aux)
+		put_device(sor->aux->dev);
 	return err;
 }
 	pm_runtime_disable(&pdev->dev);
+	if (sor->aux) {
+		put_device(sor->aux->dev);
+		sor->output.ddc = NULL;
+	}
 	tegra_output_remove(&sor->output);
 	return 0;

drivers/gpu/drm/ttm/ttm_bo.c+4−1

 	if (!ttm_bo_evict_swapout_allowable(bo, ctx, &locked, NULL))
 		return -EBUSY;
-	if (!ttm_bo_get_unless_zero(bo)) {
+	if (!bo->ttm || !ttm_tt_is_populated(bo->ttm) ||
+	    bo->ttm->page_flags & TTM_PAGE_FLAG_SG ||
+	    bo->ttm->page_flags & TTM_PAGE_FLAG_SWAPPED ||
+	    !ttm_bo_get_unless_zero(bo)) {
 		if (locked)
 			dma_resv_unlock(bo->base.resv);
 		return -EBUSY;

drivers/gpu/drm/ttm/ttm_device.c+1−7

 		for (j = 0; j < TTM_MAX_BO_PRIORITY; ++j) {
 			list_for_each_entry(bo, &man->lru[j], lru) {
-				uint32_t num_pages;
+				uint32_t num_pages = PFN_UP(bo->base.size);
-				if (!bo->ttm || !ttm_tt_is_populated(bo->ttm) ||
-				    bo->ttm->page_flags & TTM_PAGE_FLAG_SG ||
-				    bo->ttm->page_flags & TTM_PAGE_FLAG_SWAPPED)
-					continue;
-				num_pages = bo->ttm->num_pages;
 				ret = ttm_bo_swapout(bo, ctx, gfp_flags);
 				/* ttm_bo_swapout has dropped the lru_lock */
 				if (!ret)

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

@@ -372,7 +372,7 @@ static void vc4_atomic_commit_tail(struct drm_atomic_state *state) · 371 unmodified lines
372	if (!old_hvs_state->fifo_state[channel].in_use)	372	if (!old_hvs_state->fifo_state[channel].in_use)
373	continue;	373	continue;
374		374
375	ret = drm_crtc_commit_wait(old_hvs_state->fifo_state[i].pending_commit);	375	ret = drm_crtc_commit_wait(old_hvs_state->fifo_state[channel].pending_commit);
376	if (ret)	376	if (ret)
377	drm_err(dev, "Timed out waiting for commit\n");	377	drm_err(dev, "Timed out waiting for commit\n");
378	}	378	}

drivers/gpu/host1x/bus.c+24−6

@@ -735,6 +735,29 @@ void host1x_driver_unregister(struct host1x_driver *driver) · 734 unmodified lines
735	}	735	}
736	EXPORT_SYMBOL(host1x_driver_unregister);	736	EXPORT_SYMBOL(host1x_driver_unregister);
737		737
		738	/**
		739	* __host1x_client_init() - initialize a host1x client
		740	* @client: host1x client
		741	* @key: lock class key for the client-specific mutex
		742	*/
		743	void __host1x_client_init(struct host1x_client client, struct lock_class_key key)
		744	{
		745	INIT_LIST_HEAD(&client->list);
		746	__mutex_init(&client->lock, "host1x client lock", key);
		747	client->usecount = 0;
		748	}
		749	EXPORT_SYMBOL(__host1x_client_init);
		750
		751	/**
		752	* host1x_client_exit() - uninitialize a host1x client
		753	* @client: host1x client
		754	*/
		755	void host1x_client_exit(struct host1x_client *client)
		756	{
		757	mutex_destroy(&client->lock);
		758	}
		759	EXPORT_SYMBOL(host1x_client_exit);
		760
738	/**	761	/**
739	* __host1x_client_register() - register a host1x client	762	* __host1x_client_register() - register a host1x client
740	* @client: host1x client	763	* @client: host1x client
@@ -747,16 +770,11 @@ EXPORT_SYMBOL(host1x_driver_unregister); · 6 unmodified lines
747	* device and call host1x_device_init(), which will in turn call each client's	770	* device and call host1x_device_init(), which will in turn call each client's
748	* &host1x_client_ops.init implementation.	771	* &host1x_client_ops.init implementation.
749	*/	772	*/
750	int __host1x_client_register(struct host1x_client *client,	773	int __host1x_client_register(struct host1x_client *client)
751	struct lock_class_key *key)
752	{	774	{
753	struct host1x *host1x;	775	struct host1x *host1x;
754	int err;	776	int err;
755		777
756	INIT_LIST_HEAD(&client->list);
757	__mutex_init(&client->lock, "host1x client lock", key);
758	client->usecount = 0;
759
760	mutex_lock(&devices_lock);	778	mutex_lock(&devices_lock);
761		779
762	list_for_each_entry(host1x, &devices, list) {	780	list_for_each_entry(host1x, &devices, list) {

drivers/hid/Kconfig+17−2

 	depends on HID
 config HID_A4TECH
-	tristate "A4 tech mice"
+	tristate "A4TECH mice"
 	depends on HID
 	default !EXPERT
 	help
-	Support for A4 tech X5 and WOP-35 / Trust 450L mice.
+	Support for some A4TECH mice with two scroll wheels.
 config HID_ACCUTOUCH
 	tristate "Accutouch touch device"
 	help
 	Support for Samsung InfraRed remote control or keyboards.
+config HID_SEMITEK
+	tristate "Semitek USB keyboards"
+	depends on HID
+	help
+	Support for Semitek USB keyboards that are not fully compliant
+	with the HID standard.
+	There are many variants, including:
+	- GK61, GK64, GK68, GK84, GK96, etc.
+	- SK61, SK64, SK68, SK84, SK96, etc.
+	- Dierya DK61/DK66
+	- Tronsmart TK09R
+	- Woo-dy
+	- X-Bows Nature/Knight
 config HID_SONY
 	tristate "Sony PS2/3/4 accessories"
 	depends on USB_HID

drivers/hid/Makefile+1−0

@@ -106,6 +106,7 @@ obj-$(CONFIG_HID_ROCCAT) += hid-roccat.o hid-roccat-common.o \ · 105 unmodified lines
106	obj-$(CONFIG_HID_RMI) += hid-rmi.o	106	obj-$(CONFIG_HID_RMI) += hid-rmi.o
107	obj-$(CONFIG_HID_SAITEK) += hid-saitek.o	107	obj-$(CONFIG_HID_SAITEK) += hid-saitek.o
108	obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o	108	obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o
		109	obj-$(CONFIG_HID_SEMITEK) += hid-semitek.o
109	obj-$(CONFIG_HID_SMARTJOYPLUS) += hid-sjoy.o	110	obj-$(CONFIG_HID_SMARTJOYPLUS) += hid-sjoy.o
110	obj-$(CONFIG_HID_SONY) += hid-sony.o	111	obj-$(CONFIG_HID_SONY) += hid-sony.o
111	obj-$(CONFIG_HID_SPEEDLINK) += hid-speedlink.o	112	obj-$(CONFIG_HID_SPEEDLINK) += hid-speedlink.o

drivers/hid/amd-sfh-hid/amd_sfh_client.c+10−9

 	sensor_index = req_node->sensor_idx;
 	report_id = req_node->report_id;
 	node_type = req_node->report_type;
+	kfree(req_node);
 	if (node_type == HID_FEATURE_REPORT) {
 		report_size = get_feature_report(sensor_index, report_id,
 	int rc, i;
 	dev = &privdata->pdev->dev;
-	cl_data = kzalloc(sizeof(*cl_data), GFP_KERNEL);
+	cl_data = devm_kzalloc(dev, sizeof(*cl_data), GFP_KERNEL);
 	if (!cl_data)
 		return -ENOMEM;
 			rc = -EINVAL;
 			goto cleanup;
 		}
-		cl_data->feature_report[i] = kzalloc(feature_report_size, GFP_KERNEL);
+		cl_data->feature_report[i] = devm_kzalloc(dev, feature_report_size, GFP_KERNEL);
 		if (!cl_data->feature_report[i]) {
 			rc = -ENOMEM;
 			goto cleanup;
 		}
-		cl_data->input_report[i] = kzalloc(input_report_size, GFP_KERNEL);
+		cl_data->input_report[i] = devm_kzalloc(dev, input_report_size, GFP_KERNEL);
 		if (!cl_data->input_report[i]) {
 			rc = -ENOMEM;
 			goto cleanup;
 		info.sensor_idx = cl_idx;
 		info.dma_address = cl_data->sensor_dma_addr[i];
-		cl_data->report_descr[i] = kzalloc(cl_data->report_descr_sz[i], GFP_KERNEL);
+		cl_data->report_descr[i] =
+			devm_kzalloc(dev, cl_data->report_descr_sz[i], GFP_KERNEL);
 		if (!cl_data->report_descr[i]) {
 			rc = -ENOMEM;
 			goto cleanup;
 					  cl_data->sensor_virt_addr[i],
 					  cl_data->sensor_dma_addr[i]);
 		}
-		kfree(cl_data->feature_report[i]);
+		devm_kfree(dev, cl_data->feature_report[i]);
-		kfree(cl_data->input_report[i]);
+		devm_kfree(dev, cl_data->input_report[i]);
-		kfree(cl_data->report_descr[i]);
+		devm_kfree(dev, cl_data->report_descr[i]);
 	}
-	kfree(cl_data);
+	devm_kfree(dev, cl_data);
 	return rc;
 }
 					  cl_data->sensor_dma_addr[i]);
 		}
 	}
-	kfree(cl_data);
 	return 0;
 }

drivers/hid/amd-sfh-hid/amd_sfh_hid.c+0−3

 	int i;
 	for (i = 0; i < cli_data->num_hid_devices; ++i) {
-		kfree(cli_data->feature_report[i]);
-		kfree(cli_data->input_report[i]);
-		kfree(cli_data->report_descr[i]);
 		if (cli_data->hid_sensor_hubs[i]) {
 			kfree(cli_data->hid_sensor_hubs[i]->driver_data);
 			hid_destroy_device(cli_data->hid_sensor_hubs[i]);

drivers/hid/hid-a4tech.c+2−0

 		.driver_data = A4_2WHEEL_MOUSE_HACK_B8 },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649),
 		.driver_data = A4_2WHEEL_MOUSE_HACK_B8 },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_NB_95),
+		.driver_data = A4_2WHEEL_MOUSE_HACK_B8 },
 	{ }
 };
 MODULE_DEVICE_TABLE(hid, a4_devices);

drivers/hid/hid-asus.c+20−12

 #define QUIRK_T100_KEYBOARD		BIT(6)
 #define QUIRK_T100CHI			BIT(7)
 #define QUIRK_G752_KEYBOARD		BIT(8)
-#define QUIRK_T101HA_DOCK		BIT(9)
+#define QUIRK_T90CHI			BIT(9)
-#define QUIRK_T90CHI			BIT(10)
+#define QUIRK_MEDION_E1239T		BIT(10)
-#define QUIRK_MEDION_E1239T		BIT(11)
+#define QUIRK_ROG_NKEY_KEYBOARD		BIT(11)
-#define QUIRK_ROG_NKEY_KEYBOARD		BIT(12)
 #define I2C_KEYBOARD_QUIRKS			(QUIRK_FIX_NOTEBOOK_REPORT | \
 						 QUIRK_NO_INIT_REPORTS | \
 	if (drvdata->quirks & QUIRK_MEDION_E1239T)
 		return asus_e1239t_event(drvdata, data, size);
-	if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD) {
+	if (drvdata->quirks & QUIRK_USE_KBD_BACKLIGHT) {
 		/*
 		 * Skip these report ID, the device emits a continuous stream associated
 		 * with the AURA mode it is in which looks like an 'echo'.
 				return -1;
 			}
 		}
+		if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD) {
+			/*
+			 * G713 and G733 send these codes on some keypresses, depending on
+			 * the key pressed it can trigger a shutdown event if not caught.
+			*/
+			if(data[0] == 0x02 && data[1] == 0x30) {
+				return -1;
+			}
+		}
 	}
 	return 0;
 		return ret;
 	}
-	/* use hid-multitouch for T101HA touchpad */
-	if (id->driver_data & QUIRK_T101HA_DOCK &&
-	    hdev->collection->usage == HID_GD_MOUSE)
-		return -ENODEV;
 	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 	if (ret) {
 		hid_err(hdev, "Asus hw start failed: %d\n", ret);
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK,
 		USB_DEVICE_ID_ASUSTEK_T100TAF_KEYBOARD),
 	  QUIRK_T100_KEYBOARD | QUIRK_NO_CONSUMER_USAGES },
-	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK,
-		USB_DEVICE_ID_ASUSTEK_T101HA_KEYBOARD), QUIRK_T101HA_DOCK },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_ASUS_AK1D) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_ASUS_MD_5110) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_JESS, USB_DEVICE_ID_ASUS_MD_5112) },
 		USB_DEVICE_ID_ASUSTEK_T100CHI_KEYBOARD), QUIRK_T100CHI },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ITE, USB_DEVICE_ID_ITE_MEDION_E1239T),
 		QUIRK_MEDION_E1239T },
+	/*
+	 * Note bind to the HID_GROUP_GENERIC group, so that we only bind to the keyboard
+	 * part, while letting hid-multitouch.c handle the touchpad.
+	 */
+	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
+		USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_T101HA_KEYBOARD) },
 	{ }
 };
 MODULE_DEVICE_TABLE(hid, asus_devices);

drivers/hid/hid-core.c+3−1

 	case BUS_I2C:
 		bus = "I2C";
 		break;
+	case BUS_VIRTUAL:
+		bus = "VIRTUAL";
+		break;
 	default:
 		bus = "<UNKNOWN>";
 	}
 	return 0;
 }
 EXPORT_SYMBOL_GPL(hid_check_keys_pressed);
 static int __init hid_init(void)

drivers/hid/hid-debug.c+3−0

 	[KEY_APPSELECT] = "AppSelect",
 	[KEY_SCREENSAVER] = "ScreenSaver",
 	[KEY_VOICECOMMAND] = "VoiceCommand",
+	[KEY_ASSISTANT] = "Assistant",
+	[KEY_KBD_LAYOUT_NEXT] = "KbdLayoutNext",
+	[KEY_EMOJI_PICKER] = "EmojiPicker",
 	[KEY_BRIGHTNESS_MIN] = "BrightnessMin",
 	[KEY_BRIGHTNESS_MAX] = "BrightnessMax",
 	[KEY_BRIGHTNESS_AUTO] = "BrightnessAuto",

drivers/hid/hid-ft260.c+16−13

 	u8 address;		/* 7-bit I2C address */
 	u8 flag;		/* I2C transaction condition */
 	u8 length;		/* data payload length */
-	u8 data[60];		/* data payload */
+	u8 data[FT260_WR_DATA_MAX]; /* data payload */
 } __packed;
 struct ft260_i2c_read_request_report {
 	ret = hid_hw_raw_request(hdev, report_id, buf, len, HID_FEATURE_REPORT,
 				 HID_REQ_GET_REPORT);
-	memcpy(data, buf, len);
+	if (likely(ret == len))
+		memcpy(data, buf, len);
+	else if (ret >= 0)
+		ret = -EIO;
 	kfree(buf);
 	return ret;
 }
 	ret = ft260_hid_feature_report_get(hdev, FT260_I2C_STATUS,
 					   (u8 *)&report, sizeof(report));
-	if (ret < 0) {
+	if (unlikely(ret < 0)) {
 		hid_err(hdev, "failed to retrieve status: %d\n", ret);
 		return ret;
 	}
 	struct ft260_i2c_write_request_report *rep =
 		(struct ft260_i2c_write_request_report *)dev->write_buf;
+	if (data_len >= sizeof(rep->data))
+		return -EINVAL;
 	rep->address = addr;
 	rep->data[0] = cmd;
 	rep->length = data_len + 1;
 	ret = ft260_hid_feature_report_get(hdev, FT260_SYSTEM_SETTINGS,
 					   (u8 *)cfg, len);
-	if (ret != len) {
+	if (ret < 0) {
 		hid_err(hdev, "failed to retrieve system status\n");
-		if (ret >= 0)
+		return ret;
-			return -EIO;
 	}
 	return 0;
 }
 	int ret;
 	ret = ft260_hid_feature_report_get(hdev, id, cfg, len);
-	if (ret != len && ret >= 0)
+	if (ret < 0)
-		return -EIO;
+		return ret;
 	return scnprintf(buf, PAGE_SIZE, "%hi\n", *field);
 }
 	int ret;
 	ret = ft260_hid_feature_report_get(hdev, id, cfg, len);
-	if (ret != len && ret >= 0)
+	if (ret < 0)
-		return -EIO;
+		return ret;
 	return scnprintf(buf, PAGE_SIZE, "%hi\n", le16_to_cpu(*field));
 }
 	ret = ft260_hid_feature_report_get(hdev, FT260_CHIP_VERSION,
 					   (u8 *)&version, sizeof(version));
-	if (ret != sizeof(version)) {
+	if (ret < 0) {
 		hid_err(hdev, "failed to retrieve chip version\n");
-		if (ret >= 0)
-			ret = -EIO;
 		goto err_hid_close;
 	}

drivers/hid/hid-gt683r.c+1−0

@@ -54,6 +54,7 @@ static const struct hid_device_id gt683r_led_id[] = { · 53 unmodified lines
54	{ HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) },	54	{ HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) },
55	{ }	55	{ }
56	};	56	};
		57	MODULE_DEVICE_TABLE(hid, gt683r_led_id);
57		58
58	static void gt683r_brightness_set(struct led_classdev *led_cdev,	59	static void gt683r_brightness_set(struct led_classdev *led_cdev,
59	enum led_brightness brightness)	60	enum led_brightness brightness)

drivers/hid/hid-ids.h+7−2

 #define USB_DEVICE_ID_A4TECH_WCP32PU	0x0006
 #define USB_DEVICE_ID_A4TECH_X5_005D	0x000a
 #define USB_DEVICE_ID_A4TECH_RP_649	0x001a
+#define USB_DEVICE_ID_A4TECH_NB_95	0x022b
 #define USB_VENDOR_ID_AASHIMA		0x06d6
 #define USB_DEVICE_ID_AASHIMA_GAMEPAD	0x0025
 #define USB_VENDOR_ID_CORSAIR		0x1b1c
 #define USB_DEVICE_ID_CORSAIR_K90	0x1b02
-#define USB_VENDOR_ID_CORSAIR           0x1b1c
 #define USB_DEVICE_ID_CORSAIR_K70R      0x1b09
 #define USB_DEVICE_ID_CORSAIR_K95RGB    0x1b11
 #define USB_DEVICE_ID_CORSAIR_M65RGB    0x1b12
 #define USB_DEVICE_ID_LENOVO_X1_COVER	0x6085
 #define USB_DEVICE_ID_LENOVO_X1_TAB	0x60a3
 #define USB_DEVICE_ID_LENOVO_X1_TAB3	0x60b5
+#define USB_DEVICE_ID_LENOVO_OPTICAL_USB_MOUSE_600E	0x600e
 #define USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_608D	0x608d
 #define USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_6019	0x6019
 #define USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_602E	0x602e
 #define USB_DEVICE_ID_SAITEK_X52	0x075c
 #define USB_DEVICE_ID_SAITEK_X52_2	0x0255
 #define USB_DEVICE_ID_SAITEK_X52_PRO	0x0762
+#define USB_DEVICE_ID_SAITEK_X65	0x0b6a
 #define USB_VENDOR_ID_SAMSUNG		0x0419
 #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE	0x0001
 #define USB_DEVICE_ID_SEMICO_USB_KEYKOARD	0x0023
 #define USB_DEVICE_ID_SEMICO_USB_KEYKOARD2	0x0027
+#define USB_VENDOR_ID_SEMITEK	0x1ea7
+#define USB_DEVICE_ID_SEMITEK_KEYBOARD	0x0907
 #define USB_VENDOR_ID_SENNHEISER	0x1395
 #define USB_DEVICE_ID_SENNHEISER_BTD500USB	0x002c
 #define USB_DEVICE_ID_SYNAPTICS_DELL_K12A	0x2819
 #define USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5_012	0x2968
 #define USB_DEVICE_ID_SYNAPTICS_TP_V103	0x5710
+#define USB_DEVICE_ID_SYNAPTICS_DELL_K15A	0x6e21
 #define USB_DEVICE_ID_SYNAPTICS_ACER_ONE_S1002	0x73f4
 #define USB_DEVICE_ID_SYNAPTICS_ACER_ONE_S1003	0x73f5
 #define USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5	0x81a7

drivers/hid/hid-input.c+3−0

@@ -964,6 +964,9 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel · 963 unmodified lines
964		964
965	case 0x0cd: map_key_clear(KEY_PLAYPAUSE); break;	965	case 0x0cd: map_key_clear(KEY_PLAYPAUSE); break;
966	case 0x0cf: map_key_clear(KEY_VOICECOMMAND); break;	966	case 0x0cf: map_key_clear(KEY_VOICECOMMAND); break;
		967
		968	case 0x0d9: map_key_clear(KEY_EMOJI_PICKER); break;
		969
967	case 0x0e0: map_abs_clear(ABS_VOLUME); break;	970	case 0x0e0: map_abs_clear(ABS_VOLUME); break;
968	case 0x0e2: map_key_clear(KEY_MUTE); break;	971	case 0x0e2: map_key_clear(KEY_MUTE); break;
969	case 0x0e5: map_key_clear(KEY_BASSBOOST); break;	972	case 0x0e5: map_key_clear(KEY_BASSBOOST); break;

drivers/hid/hid-logitech-hidpp.c+1−0

@@ -1263,6 +1263,7 @@ static int hidpp20_battery_map_status_voltage(u8 data[3], int *voltage, · 1262 unmodified lines
1263	int status;	1263	int status;
1264		1264
1265	long flags = (long) data[2];	1265	long flags = (long) data[2];
		1266	*level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
1266		1267
1267	if (flags & 0x80)	1268	if (flags & 0x80)
1268	switch (flags & 0x07) {	1269	switch (flags & 0x07) {

drivers/hid/hid-magicmouse.c+5−2

@@ -693,7 +693,7 @@ static int magicmouse_probe(struct hid_device *hdev, · 692 unmodified lines
693	if (id->vendor == USB_VENDOR_ID_APPLE &&	693	if (id->vendor == USB_VENDOR_ID_APPLE &&
694	id->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2 &&	694	id->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2 &&
695	hdev->type != HID_TYPE_USBMOUSE)	695	hdev->type != HID_TYPE_USBMOUSE)
696	return 0;	696	return -ENODEV;
697		697
698	msc = devm_kzalloc(&hdev->dev, sizeof(*msc), GFP_KERNEL);	698	msc = devm_kzalloc(&hdev->dev, sizeof(*msc), GFP_KERNEL);
699	if (msc == NULL) {	699	if (msc == NULL) {
@@ -779,7 +779,10 @@ err_stop_hw: · 79 unmodified lines
779	static void magicmouse_remove(struct hid_device *hdev)	779	static void magicmouse_remove(struct hid_device *hdev)
780	{	780	{
781	struct magicmouse_sc *msc = hid_get_drvdata(hdev);	781	struct magicmouse_sc *msc = hid_get_drvdata(hdev);
782	cancel_delayed_work_sync(&msc->work);	782
		783	if (msc)
		784	cancel_delayed_work_sync(&msc->work);
		785
783	hid_hw_stop(hdev);	786	hid_hw_stop(hdev);
784	}	787	}
785		788

drivers/hid/hid-multitouch.c+37−9

 #define MT_QUIRK_WIN8_PTP_BUTTONS	BIT(18)
 #define MT_QUIRK_SEPARATE_APP_REPORT	BIT(19)
 #define MT_QUIRK_FORCE_MULTI_INPUT	BIT(20)
+#define MT_QUIRK_DISABLE_WAKEUP		BIT(21)
 #define MT_INPUTMODE_TOUCHSCREEN	0x02
 #define MT_INPUTMODE_TOUCHPAD		0x03
 #define MT_CLS_EXPORT_ALL_INPUTS		0x0013
 /* reserved					0x0014 */
 #define MT_CLS_WIN_8_FORCE_MULTI_INPUT		0x0015
+#define MT_CLS_WIN_8_DISABLE_WAKEUP		0x0016
 /* vendor specific classes */
 #define MT_CLS_3M				0x0101
 			MT_QUIRK_WIN8_PTP_BUTTONS |
 			MT_QUIRK_FORCE_MULTI_INPUT,
 		.export_all_inputs = true },
+	{ .name = MT_CLS_WIN_8_DISABLE_WAKEUP,
+		.quirks = MT_QUIRK_ALWAYS_VALID |
+			MT_QUIRK_IGNORE_DUPLICATES |
+			MT_QUIRK_HOVERING |
+			MT_QUIRK_CONTACT_CNT_ACCURATE |
+			MT_QUIRK_STICKY_FINGERS |
+			MT_QUIRK_WIN8_PTP_BUTTONS |
+			MT_QUIRK_DISABLE_WAKEUP,
+		.export_all_inputs = true },
 	/*
 	 * vendor specific classes
 		if (!(HID_MAIN_ITEM_VARIABLE & field->flags))
 			continue;
-		for (n = 0; n < field->report_count; n++) {
+		if (field->logical == HID_DG_FINGER || td->hdev->group != HID_GROUP_MULTITOUCH_WIN_8) {
-			if (field->usage[n].hid == HID_DG_CONTACTID)
+			for (n = 0; n < field->report_count; n++) {
-				rdata->is_mt_collection = true;
+				if (field->usage[n].hid == HID_DG_CONTACTID) {
+					rdata->is_mt_collection = true;
+					break;
+				}
+			}
 		}
 	}
 			return 1;
 		case HID_DG_CONFIDENCE:
 			if ((cls->name == MT_CLS_WIN_8 ||
-			     cls->name == MT_CLS_WIN_8_FORCE_MULTI_INPUT) &&
+			     cls->name == MT_CLS_WIN_8_FORCE_MULTI_INPUT ||
+			     cls->name == MT_CLS_WIN_8_DISABLE_WAKEUP) &&
 				(field->application == HID_DG_TOUCHPAD ||
 				 field->application == HID_DG_TOUCHSCREEN))
 				app->quirks |= MT_QUIRK_CONFIDENCE;
 		/* we do not set suffix = "Touchscreen" */
 		hi->input->name = hdev->name;
 		break;
-	case HID_DG_STYLUS:
-		/* force BTN_STYLUS to allow tablet matching in udev */
-		__set_bit(BTN_STYLUS, hi->input->keybit);
-		break;
 	case HID_VD_ASUS_CUSTOM_MEDIA_KEYS:
 		suffix = "Custom Media Keys";
 		break;
+	case HID_DG_STYLUS:
+		/* force BTN_STYLUS to allow tablet matching in udev */
+		__set_bit(BTN_STYLUS, hi->input->keybit);
+		fallthrough;
 	case HID_DG_PEN:
 		suffix = "Stylus";
 		break;
 #ifdef CONFIG_PM
 static int mt_suspend(struct hid_device *hdev, pm_message_t state)
 {
+	struct mt_device *td = hid_get_drvdata(hdev);
 	/* High latency is desirable for power savings during S3/S0ix */
-	mt_set_modes(hdev, HID_LATENCY_HIGH, true, true);
+	if (td->mtclass.quirks & MT_QUIRK_DISABLE_WAKEUP)
+		mt_set_modes(hdev, HID_LATENCY_HIGH, false, false);
+	else
+		mt_set_modes(hdev, HID_LATENCY_HIGH, true, true);
 	return 0;
 }
 		MT_USB_DEVICE(USB_VENDOR_ID_ANTON,
 			USB_DEVICE_ID_ANTON_TOUCH_PAD) },
+	/* Asus T101HA */
+	{ .driver_data = MT_CLS_WIN_8_DISABLE_WAKEUP,
+		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,
+			   USB_VENDOR_ID_ASUSTEK,
+			   USB_DEVICE_ID_ASUSTEK_T101HA_KEYBOARD) },
 	/* Asus T304UA */
 	{ .driver_data = MT_CLS_ASUS,
 		HID_DEVICE(BUS_USB, HID_GROUP_MULTITOUCH_WIN_8,

drivers/hid/hid-quirks.c+4−0

 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_PENSKETCH_M912), HID_QUIRK_MULTI_INPUT },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M406XE), HID_QUIRK_MULTI_INPUT },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE_ID2), HID_QUIRK_ALWAYS_POLL },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_OPTICAL_USB_MOUSE_600E), HID_QUIRK_ALWAYS_POLL },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_608D), HID_QUIRK_ALWAYS_POLL },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_6019), HID_QUIRK_ALWAYS_POLL },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_PIXART_USB_MOUSE_602E), HID_QUIRK_ALWAYS_POLL },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X52), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X52_2), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X52_PRO), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X65), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SEMICO, USB_DEVICE_ID_SEMICO_USB_KEYKOARD2), HID_QUIRK_NO_INIT_REPORTS },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SEMICO, USB_DEVICE_ID_SEMICO_USB_KEYKOARD), HID_QUIRK_NO_INIT_REPORTS },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SENNHEISER, USB_DEVICE_ID_SENNHEISER_BTD500USB), HID_QUIRK_NOGET },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_QUAD_HD), HID_QUIRK_NO_INIT_REPORTS },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP_V103), HID_QUIRK_NO_INIT_REPORTS },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DELL_K12A), HID_QUIRK_NO_INIT_REPORTS },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DELL_K15A), HID_QUIRK_NO_INIT_REPORTS },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD), HID_QUIRK_BADPAD },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TOUCHPACK, USB_DEVICE_ID_TOUCHPACK_RTS), HID_QUIRK_MULTI_INPUT },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TPV, USB_DEVICE_ID_TPV_OPTICAL_TOUCHSCREEN_8882), HID_QUIRK_NOGET },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_NB_95) },
 #endif
 #if IS_ENABLED(CONFIG_HID_ACCUTOUCH)
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_ACCUTOUCH_2216) },

drivers/hid/hid-semitek.c+40−0

@@ -0,0 +1,40 @@
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* HID driver for Semitek keyboards
	4	*
	5	* Copyright (c) 2021 Benjamin Moody
	6	*/
	7
	8	#include <linux/device.h>
	9	#include <linux/hid.h>
	10	#include <linux/module.h>
	11
	12	#include "hid-ids.h"
	13
	14	static __u8 semitek_report_fixup(struct hid_device hdev, __u8 *rdesc,
	15	unsigned int *rsize)
	16	{
	17	/* In the report descriptor for interface 2, fix the incorrect
	18	description of report ID 0x04 (the report contains a
	19	bitmask, not an array of keycodes.) */
	20	if (*rsize == 0xcb && rdesc[0x83] == 0x81 && rdesc[0x84] == 0x00) {
	21	hid_info(hdev, "fixing up Semitek report descriptor\n");
	22	rdesc[0x84] = 0x02;
	23	}
	24	return rdesc;
	25	}
	26
	27	static const struct hid_device_id semitek_devices[] = {
	28	{ HID_USB_DEVICE(USB_VENDOR_ID_SEMITEK, USB_DEVICE_ID_SEMITEK_KEYBOARD) },
	29	{ }
	30	};
	31	MODULE_DEVICE_TABLE(hid, semitek_devices);
	32
	33	static struct hid_driver semitek_driver = {
	34	.name = "semitek",
	35	.id_table = semitek_devices,
	36	.report_fixup = semitek_report_fixup,
	37	};
	38	module_hid_driver(semitek_driver);
	39
	40	MODULE_LICENSE("GPL");

drivers/hid/hid-sensor-custom.c+5−3

 	struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev);
 	int index, field_index, usage;
 	char name[HID_CUSTOM_NAME_LENGTH];
-	int value;
+	int value, ret;
 	if (sscanf(attr->attr.name, "feature-%x-%x-%s", &index, &usage,
 		   name) == 3) {
 		report_id = sensor_inst->fields[field_index].attribute.
 								report_id;
-		sensor_hub_set_feature(sensor_inst->hsdev, report_id,
+		ret = sensor_hub_set_feature(sensor_inst->hsdev, report_id,
-				       index, sizeof(value), &value);
+					     index, sizeof(value), &value);
+		if (ret)
+			return ret;
 	} else
 		return -EINVAL;

drivers/hid/hid-sensor-hub.c+9−4

 	buffer_size = buffer_size / sizeof(__s32);
 	if (buffer_size) {
 		for (i = 0; i < buffer_size; ++i) {
-			hid_set_field(report->field[field_index], i,
+			ret = hid_set_field(report->field[field_index], i,
-				      (__force __s32)cpu_to_le32(*buf32));
+					    (__force __s32)cpu_to_le32(*buf32));
+			if (ret)
+				goto done_proc;
 			++buf32;
 		}
 	}
 	if (remaining_bytes) {
 		value = 0;
 		memcpy(&value, (u8 *)buf32, remaining_bytes);
-		hid_set_field(report->field[field_index], i,
+		ret = hid_set_field(report->field[field_index], i,
-			      (__force __s32)cpu_to_le32(value));
+				    (__force __s32)cpu_to_le32(value));
+		if (ret)
+			goto done_proc;
 	}
 	hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT);
 	hid_hw_wait(hsdev->hdev);

drivers/hid/hid-thrustmaster.c+1−1

@@ -312,7 +312,7 @@ static int thrustmaster_probe(struct hid_device *hdev, const struct hid_device_i · 311 unmodified lines
312	}	312	}
313		313
314	tm_wheel->change_request = kzalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);	314	tm_wheel->change_request = kzalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
315	if (!tm_wheel->model_request) {	315	if (!tm_wheel->change_request) {
316	ret = -ENOMEM;	316	ret = -ENOMEM;
317	goto error5;	317	goto error5;
318	}	318	}

drivers/hid/i2c-hid/i2c-hid-core.c+10−3

 #define I2C_HID_QUIRK_BOGUS_IRQ			BIT(4)
 #define I2C_HID_QUIRK_RESET_ON_RESUME		BIT(5)
 #define I2C_HID_QUIRK_BAD_INPUT_SIZE		BIT(6)
+#define I2C_HID_QUIRK_NO_WAKEUP_AFTER_RESET	BIT(7)
 /* flags */
 		 I2C_HID_QUIRK_RESET_ON_RESUME },
 	{ USB_VENDOR_ID_ITE, I2C_DEVICE_ID_ITE_LENOVO_LEGION_Y720,
 		I2C_HID_QUIRK_BAD_INPUT_SIZE },
+	/*
+	 * Sending the wakeup after reset actually break ELAN touchscreen controller
+	 */
+	{ USB_VENDOR_ID_ELAN, HID_ANY_ID,
+		 I2C_HID_QUIRK_NO_WAKEUP_AFTER_RESET },
 	{ 0, 0 }
 };
 	}
 	/* At least some SIS devices need this after reset */
-	ret = i2c_hid_set_power(client, I2C_HID_PWR_ON);
+	if (!(ihid->quirks & I2C_HID_QUIRK_NO_WAKEUP_AFTER_RESET))
+		ret = i2c_hid_set_power(client, I2C_HID_PWR_ON);
 out_unlock:
 	mutex_unlock(&ihid->reset_lock);
 	hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID);
 	hid->product = le16_to_cpu(ihid->hdesc.wProductID);
-	snprintf(hid->name, sizeof(hid->name), "%s %04hX:%04hX",
+	snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X",
-		 client->name, hid->vendor, hid->product);
+		 client->name, (u16)hid->vendor, (u16)hid->product);
 	strlcpy(hid->phys, dev_name(&client->dev), sizeof(hid->phys));
 	ihid->quirks = i2c_hid_lookup_quirk(hid->vendor, hid->product);

drivers/hid/intel-ish-hid/ipc/hw-ish.h+2−0

@@ -28,6 +28,8 @@ · 27 unmodified lines
28	#define EHL_Ax_DEVICE_ID 0x4BB3	28	#define EHL_Ax_DEVICE_ID 0x4BB3
29	#define TGL_LP_DEVICE_ID 0xA0FC	29	#define TGL_LP_DEVICE_ID 0xA0FC
30	#define TGL_H_DEVICE_ID 0x43FC	30	#define TGL_H_DEVICE_ID 0x43FC
		31	#define ADL_S_DEVICE_ID 0x7AF8
		32	#define ADL_P_DEVICE_ID 0x51FC
31		33
32	#define REVISION_ID_CHT_A0 0x6	34	#define REVISION_ID_CHT_A0 0x6
33	#define REVISION_ID_CHT_Ax_SI 0x0	35	#define REVISION_ID_CHT_Ax_SI 0x0

drivers/hid/intel-ish-hid/ipc/pci-ish.c+2−0

 	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, EHL_Ax_DEVICE_ID)},
 	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, TGL_LP_DEVICE_ID)},
 	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, TGL_H_DEVICE_ID)},
+	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, ADL_S_DEVICE_ID)},
+	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, ADL_P_DEVICE_ID)},
 	{0, }
 };
 MODULE_DEVICE_TABLE(pci, ish_pci_tbl);

drivers/hid/surface-hid/surface_hid_core.c+3−3

@@ -168,9 +168,9 @@ int surface_hid_device_add(struct surface_hid_device *shid) · 167 unmodified lines
168		168
169	shid->hid->dev.parent = shid->dev;	169	shid->hid->dev.parent = shid->dev;
170	shid->hid->bus = BUS_HOST;	170	shid->hid->bus = BUS_HOST;
171	shid->hid->vendor = cpu_to_le16(shid->attrs.vendor);	171	shid->hid->vendor = get_unaligned_le16(&shid->attrs.vendor);
172	shid->hid->product = cpu_to_le16(shid->attrs.product);	172	shid->hid->product = get_unaligned_le16(&shid->attrs.product);
173	shid->hid->version = cpu_to_le16(shid->hid_desc.hid_version);	173	shid->hid->version = get_unaligned_le16(&shid->hid_desc.hid_version);
174	shid->hid->country = shid->hid_desc.country_code;	174	shid->hid->country = shid->hid_desc.country_code;
175		175
176	snprintf(shid->hid->name, sizeof(shid->hid->name), "Microsoft Surface %04X:%04X",	176	snprintf(shid->hid->name, sizeof(shid->hid->name), "Microsoft Surface %04X:%04X",

drivers/hid/usbhid/hid-core.c+1−1

@@ -374,7 +374,7 @@ static int hid_submit_ctrl(struct hid_device *hid) · 373 unmodified lines
374	raw_report = usbhid->ctrl[usbhid->ctrltail].raw_report;	374	raw_report = usbhid->ctrl[usbhid->ctrltail].raw_report;
375	dir = usbhid->ctrl[usbhid->ctrltail].dir;	375	dir = usbhid->ctrl[usbhid->ctrltail].dir;
376		376
377	len = ((report->size - 1) >> 3) + 1 + (report->id > 0);	377	len = hid_report_len(report);
378	if (dir == USB_DIR_OUT) {	378	if (dir == USB_DIR_OUT) {
379	usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);	379	usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);
380	usbhid->urbctrl->transfer_buffer_length = len;	380	usbhid->urbctrl->transfer_buffer_length = len;

drivers/hid/usbhid/hid-pidff.c+1−0

@@ -1292,6 +1292,7 @@ int hid_pidff_init(struct hid_device *hid) · 1291 unmodified lines
1292		1292
1293	if (pidff->pool[PID_DEVICE_MANAGED_POOL].value &&	1293	if (pidff->pool[PID_DEVICE_MANAGED_POOL].value &&
1294	pidff->pool[PID_DEVICE_MANAGED_POOL].value[0] == 0) {	1294	pidff->pool[PID_DEVICE_MANAGED_POOL].value[0] == 0) {
		1295	error = -EPERM;
1295	hid_notice(hid,	1296	hid_notice(hid,
1296	"device does not support device managed pool\n");	1297	"device does not support device managed pool\n");
1297	goto fail;	1298	goto fail;

drivers/hwmon/corsair-psu.c+14−0

@@ -771,6 +771,16 @@ static int corsairpsu_raw_event(struct hid_device hdev, struct hid_report repo · 770 unmodified lines
771	return 0;	771	return 0;
772	}	772	}
773		773
		774	#ifdef CONFIG_PM
		775	static int corsairpsu_resume(struct hid_device *hdev)
		776	{
		777	struct corsairpsu_data *priv = hid_get_drvdata(hdev);
		778
		779	/* some PSUs turn off the microcontroller during standby, so a reinit is required */
		780	return corsairpsu_init(priv);
		781	}
		782	#endif
		783
774	static const struct hid_device_id corsairpsu_idtable[] = {	784	static const struct hid_device_id corsairpsu_idtable[] = {
775	{ HID_USB_DEVICE(0x1b1c, 0x1c03) }, /* Corsair HX550i */	785	{ HID_USB_DEVICE(0x1b1c, 0x1c03) }, /* Corsair HX550i */
776	{ HID_USB_DEVICE(0x1b1c, 0x1c04) }, /* Corsair HX650i */	786	{ HID_USB_DEVICE(0x1b1c, 0x1c04) }, /* Corsair HX650i */
@@ -793,6 +803,10 @@ static struct hid_driver corsairpsu_driver = { · 16 unmodified lines
793	.probe = corsairpsu_probe,	803	.probe = corsairpsu_probe,
794	.remove = corsairpsu_remove,	804	.remove = corsairpsu_remove,
795	.raw_event = corsairpsu_raw_event,	805	.raw_event = corsairpsu_raw_event,
		806	#ifdef CONFIG_PM
		807	.resume = corsairpsu_resume,
		808	.reset_resume = corsairpsu_resume,
		809	#endif
796	};	810	};
797	module_hid_driver(corsairpsu_driver);	811	module_hid_driver(corsairpsu_driver);
798		812

drivers/hwmon/dell-smm-hwmon.c+2−2

@@ -838,10 +838,10 @@ static struct attribute *i8k_attrs[] = { · 837 unmodified lines
838	static umode_t i8k_is_visible(struct kobject kobj, struct attribute attr,	838	static umode_t i8k_is_visible(struct kobject kobj, struct attribute attr,
839	int index)	839	int index)
840	{	840	{
841	if (disallow_fan_support && index >= 8)	841	if (disallow_fan_support && index >= 20)
842	return 0;	842	return 0;
843	if (disallow_fan_type_call &&	843	if (disallow_fan_type_call &&
844	(index == 9 \|\| index == 12 \|\| index == 15))	844	(index == 21 \|\| index == 25 \|\| index == 28))
845	return 0;	845	return 0;
846	if (index >= 0 && index <= 1 &&	846	if (index >= 0 && index <= 1 &&
847	!(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1))	847	!(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1))

drivers/hwmon/pmbus/fsp-3y.c+25−7

 	struct pmbus_driver_info info;
 	int chip;
 	int page;
+	bool vout_linear_11;
 };
 #define to_fsp3y_data(x) container_of(x, struct fsp3y_data, info)
 	int rv;
 	/*
-	 * YH5151-E outputs vout in linear11. The conversion is done when
+	 * Inject an exponent for non-compliant YH5151-E.
-	 * reading. Here, we have to inject pmbus_core with the correct
-	 * exponent (it is -6).
 	 */
-	if (data->chip == yh5151e && reg == PMBUS_VOUT_MODE)
+	if (data->vout_linear_11 && reg == PMBUS_VOUT_MODE)
 		return 0x1A;
 	rv = set_page(client, page);
 		return rv;
 	/*
-	 * YH-5151E is non-compliant and outputs output voltages in linear11
+	 * Handle YH-5151E non-compliant linear11 vout voltage.
-	 * instead of linear16.
 	 */
-	if (data->chip == yh5151e && reg == PMBUS_READ_VOUT)
+	if (data->vout_linear_11 && reg == PMBUS_READ_VOUT)
 		rv = sign_extend32(rv, 10) & 0xffff;
 	return rv;
 	data->info = fsp3y_info[data->chip];
+	/*
+	 * YH-5151E sometimes reports vout in linear11 and sometimes in
+	 * linear16. This depends on the exact individual piece of hardware. One
+	 * YH-5151E can use linear16 and another might use linear11 instead.
+	 *
+	 * The format can be recognized by reading VOUT_MODE - if it doesn't
+	 * report a valid exponent, then vout uses linear11. Otherwise, the
+	 * device is compliant and uses linear16.
+	 */
+	data->vout_linear_11 = false;
+	if (data->chip == yh5151e) {
+		rv = i2c_smbus_read_byte_data(client, PMBUS_VOUT_MODE);
+		if (rv < 0)
+			return rv;
+		if (rv == 0xFF)
+			data->vout_linear_11 = true;
+	}
 	return pmbus_do_probe(client, &data->info);
 }

drivers/hwmon/pmbus/isl68137.c+2−2

@@ -244,8 +244,8 @@ static int isl68137_probe(struct i2c_client *client) · 243 unmodified lines
244	info->read_word_data = raa_dmpvr2_read_word_data;	244	info->read_word_data = raa_dmpvr2_read_word_data;
245	break;	245	break;
246	case raa_dmpvr2_2rail_nontc:	246	case raa_dmpvr2_2rail_nontc:
247	info->func[0] &= ~PMBUS_HAVE_TEMP;	247	info->func[0] &= ~PMBUS_HAVE_TEMP3;
248	info->func[1] &= ~PMBUS_HAVE_TEMP;	248	info->func[1] &= ~PMBUS_HAVE_TEMP3;
249	fallthrough;	249	fallthrough;
250	case raa_dmpvr2_2rail:	250	case raa_dmpvr2_2rail:
251	info->pages = 2;	251	info->pages = 2;

drivers/hwmon/pmbus/q54sj108a2.c+1−1

@@ -299,7 +299,7 @@ static int q54sj108a2_probe(struct i2c_client *client) · 298 unmodified lines
299	dev_err(&client->dev, "Failed to read Manufacturer ID\n");	299	dev_err(&client->dev, "Failed to read Manufacturer ID\n");
300	return ret;	300	return ret;
301	}	301	}
302	if (ret != 5 \|\| strncmp(buf, "DELTA", 5)) {	302	if (ret != 6 \|\| strncmp(buf, "DELTA", 5)) {
303	buf[ret] = '\0';	303	buf[ret] = '\0';
304	dev_err(dev, "Unsupported Manufacturer ID '%s'\n", buf);	304	dev_err(dev, "Unsupported Manufacturer ID '%s'\n", buf);
305	return -ENODEV;	305	return -ENODEV;

drivers/hwmon/scpi-hwmon.c+9−0

@@ -99,6 +99,15 @@ scpi_show_sensor(struct device dev, struct device_attribute attr, char *buf) · 98 unmodified lines
99		99
100	scpi_scale_reading(&value, sensor);	100	scpi_scale_reading(&value, sensor);
101		101
		102	/*
		103	* Temperature sensor values are treated as signed values based on
		104	* observation even though that is not explicitly specified, and
		105	* because an unsigned u64 temperature does not really make practical
		106	* sense especially when the temperature is below zero degrees Celsius.
		107	*/
		108	if (sensor->info.class == TEMPERATURE)
		109	return sprintf(buf, "%lld\n", (s64)value);
		110
102	return sprintf(buf, "%llu\n", value);	111	return sprintf(buf, "%llu\n", value);
103	}	112	}
104		113

drivers/hwmon/tps23861.c+15−2

 #define POWER_ENABLE			0x19
 #define TPS23861_NUM_PORTS		4
+#define TPS23861_GENERAL_MASK_1		0x17
+#define TPS23861_CURRENT_SHUNT_MASK	BIT(0)
 #define TEMPERATURE_LSB			652 /* 0.652 degrees Celsius */
 #define VOLTAGE_LSB			3662 /* 3.662 mV */
 #define SHUNT_RESISTOR_DEFAULT		255000 /* 255 mOhm */
-#define CURRENT_LSB_255			62260 /* 62.260 uA */
+#define CURRENT_LSB_250			62260 /* 62.260 uA */
-#define CURRENT_LSB_250			61039 /* 61.039 uA */
+#define CURRENT_LSB_255			61039 /* 61.039 uA */
 #define RESISTANCE_LSB			110966 /* 11.0966 Ohm*/
 #define RESISTANCE_LSB_LOW		157216 /* 15.7216 Ohm*/
 static struct regmap_config tps23861_regmap_config = {
 	.reg_bits = 8,
 	.val_bits = 8,
+	.max_register = 0x6f,
 };
 static int tps23861_read_temp(struct tps23861_data *data, long *val)
 	else
 		data->shunt_resistor = SHUNT_RESISTOR_DEFAULT;
+	if (data->shunt_resistor == SHUNT_RESISTOR_DEFAULT)
+		regmap_clear_bits(data->regmap,
+				  TPS23861_GENERAL_MASK_1,
+				  TPS23861_CURRENT_SHUNT_MASK);
+	else
+		regmap_set_bits(data->regmap,
+				TPS23861_GENERAL_MASK_1,
+				TPS23861_CURRENT_SHUNT_MASK);
 	hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
 							 data, &tps23861_chip_info,
 							 NULL);

drivers/i2c/busses/i2c-altera.c+4−5

 #define ALTR_I2C_XFER_TIMEOUT	(msecs_to_jiffies(250))
 /**
- * altr_i2c_dev - I2C device context
+ * struct altr_i2c_dev - I2C device context
  * @base: pointer to register struct
  * @msg: pointer to current message
  * @msg_len: number of bytes transferred in msg
 	altr_i2c_int_enable(idev, ALTR_I2C_ALL_IRQ, false);
 }
-/**
+/*
  * altr_i2c_transfer - On the last byte to be transmitted, send
  * a Stop bit on the last byte.
  */
 		writel(data, idev->base + ALTR_I2C_TFR_CMD);
 }
-/**
+/*
  * altr_i2c_empty_rx_fifo - Fetch data from RX FIFO until end of
  * transfer. Send a Stop bit on the last byte.
  */
 	}
 }
-/**
+/*
  * altr_i2c_fill_tx_fifo - Fill TX FIFO from current message buffer.
- * @return: Number of bytes left to transfer.
  */
 static int altr_i2c_fill_tx_fifo(struct altr_i2c_dev *idev)
 {

drivers/i2c/busses/i2c-qcom-geni.c+20−1

 	return 0;
 }
+static void geni_i2c_shutdown(struct platform_device *pdev)
+{
+	struct geni_i2c_dev *gi2c = platform_get_drvdata(pdev);
+	/* Make client i2c transfers start failing */
+	i2c_mark_adapter_suspended(&gi2c->adap);
+}
 static int __maybe_unused geni_i2c_runtime_suspend(struct device *dev)
 {
 	int ret;
 {
 	struct geni_i2c_dev *gi2c = dev_get_drvdata(dev);
+	i2c_mark_adapter_suspended(&gi2c->adap);
 	if (!gi2c->suspended) {
 		geni_i2c_runtime_suspend(dev);
 		pm_runtime_disable(dev);
 	return 0;
 }
+static int __maybe_unused geni_i2c_resume_noirq(struct device *dev)
+{
+	struct geni_i2c_dev *gi2c = dev_get_drvdata(dev);
+	i2c_mark_adapter_resumed(&gi2c->adap);
+	return 0;
+}
 static const struct dev_pm_ops geni_i2c_pm_ops = {
-	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(geni_i2c_suspend_noirq, NULL)
+	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(geni_i2c_suspend_noirq, geni_i2c_resume_noirq)
 	SET_RUNTIME_PM_OPS(geni_i2c_runtime_suspend, geni_i2c_runtime_resume,
 									NULL)
 };
 static struct platform_driver geni_i2c_driver = {
 	.probe  = geni_i2c_probe,
 	.remove = geni_i2c_remove,
+	.shutdown = geni_i2c_shutdown,
 	.driver = {
 		.name = "geni_i2c",
 		.pm = &geni_i2c_pm_ops,

drivers/i2c/busses/i2c-tegra-bpmp.c+2−2

@@ -65,7 +65,7 @@ static void tegra_bpmp_xlate_flags(u16 flags, u16 *out) · 64 unmodified lines
65	*out \|= SERIALI2C_RECV_LEN;	65	*out \|= SERIALI2C_RECV_LEN;
66	}	66	}
67		67
68	/**	68	/*
69	* The serialized I2C format is simply the following:	69	* The serialized I2C format is simply the following:
70	* [addr little-endian][flags little-endian][len little-endian][data if write]	70	* [addr little-endian][flags little-endian][len little-endian][data if write]
71	* [addr little-endian][flags little-endian][len little-endian][data if write]	71	* [addr little-endian][flags little-endian][len little-endian][data if write]
@@ -109,7 +109,7 @@ static void tegra_bpmp_serialize_i2c_msg(struct tegra_bpmp_i2c *i2c, · 37 unmodified lines
109	request->xfer.data_size = pos;	109	request->xfer.data_size = pos;
110	}	110	}
111		111
112	/**	112	/*
113	* The data in the BPMP -> CPU direction is composed of sequential blocks for	113	* The data in the BPMP -> CPU direction is composed of sequential blocks for
114	* those messages that have I2C_M_RD. So, for example, if you have:	114	* those messages that have I2C_M_RD. So, for example, if you have:
115	*	115	*

drivers/infiniband/core/uverbs_cmd.c+5−0

 		goto err_free_attr;
 	}
+	if (!rdma_is_port_valid(uobj->context->device, cmd.flow_attr.port)) {
+		err = -EINVAL;
+		goto err_uobj;
+	}
 	qp = uobj_get_obj_read(qp, UVERBS_OBJECT_QP, cmd.qp_handle, attrs);
 	if (!qp) {
 		err = -EINVAL;

drivers/infiniband/hw/mlx4/main.c+1−7

 	props->cq_caps.max_cq_moderation_count = MLX4_MAX_CQ_COUNT;
 	props->cq_caps.max_cq_moderation_period = MLX4_MAX_CQ_PERIOD;
-	if (!mlx4_is_slave(dev->dev))
-		err = mlx4_get_internal_clock_params(dev->dev, &clock_params);
 	if (uhw->outlen >= resp.response_length + sizeof(resp.hca_core_clock_offset)) {
 		resp.response_length += sizeof(resp.hca_core_clock_offset);
-		if (!err && !mlx4_is_slave(dev->dev)) {
+		if (!mlx4_get_internal_clock_params(dev->dev, &clock_params)) {
 			resp.comp_mask |= MLX4_IB_QUERY_DEV_RESP_MASK_CORE_CLOCK_OFFSET;
 			resp.hca_core_clock_offset = clock_params.offset % PAGE_SIZE;
 		}
 	struct mlx4_dev *dev = (to_mdev(qp->device))->dev;
 	int is_bonded = mlx4_is_bonded(dev);
-	if (!rdma_is_port_valid(qp->device, flow_attr->port))
-		return ERR_PTR(-EINVAL);
 	if (flow_attr->flags & ~IB_FLOW_ATTR_FLAGS_DONT_TRAP)
 		return ERR_PTR(-EOPNOTSUPP);

drivers/infiniband/hw/mlx5/cq.c+4−5

 	ib_umem_release(cq->buf.umem);
 }
-static void init_cq_frag_buf(struct mlx5_ib_cq *cq,
+static void init_cq_frag_buf(struct mlx5_ib_cq_buf *buf)
-			     struct mlx5_ib_cq_buf *buf)
 {
 	int i;
 	void *cqe;
 	struct mlx5_cqe64 *cqe64;
 	for (i = 0; i < buf->nent; i++) {
-		cqe = get_cqe(cq, i);
+		cqe = mlx5_frag_buf_get_wqe(&buf->fbc, i);
 		cqe64 = buf->cqe_size == 64 ? cqe : cqe + 64;
 		cqe64->op_own = MLX5_CQE_INVALID << 4;
 	}
 	if (err)
 		goto err_db;
-	init_cq_frag_buf(cq, &cq->buf);
+	init_cq_frag_buf(&cq->buf);
 	*inlen = MLX5_ST_SZ_BYTES(create_cq_in) +
 		 MLX5_FLD_SZ_BYTES(create_cq_in, pas[0]) *
 	if (err)
 		goto ex;
-	init_cq_frag_buf(cq, cq->resize_buf);
+	init_cq_frag_buf(cq->resize_buf);
 	return 0;

drivers/infiniband/hw/mlx5/doorbell.c+6−1

 	struct ib_umem	       *umem;
 	unsigned long		user_virt;
 	int			refcnt;
+	struct mm_struct	*mm;
 };
 int mlx5_ib_db_map_user(struct mlx5_ib_ucontext *context,
 	mutex_lock(&context->db_page_mutex);
 	list_for_each_entry(page, &context->db_page_list, list)
-		if (page->user_virt == (virt & PAGE_MASK))
+		if ((current->mm == page->mm) &&
+		    (page->user_virt == (virt & PAGE_MASK)))
 			goto found;
 	page = kmalloc(sizeof(*page), GFP_KERNEL);
 		kfree(page);
 		goto out;
 	}
+	mmgrab(current->mm);
+	page->mm = current->mm;
 	list_add(&page->list, &context->db_page_list);
 	if (!--db->u.user_page->refcnt) {
 		list_del(&db->u.user_page->list);
+		mmdrop(db->u.user_page->mm);
 		ib_umem_release(db->u.user_page->umem);
 		kfree(db->u.user_page);
 	}

drivers/infiniband/hw/mlx5/fs.c+8−3

 		goto free_ucmd;
 	}
-	if (flow_attr->port > dev->num_ports ||
+	if (flow_attr->flags &
-	    (flow_attr->flags &
+	    ~(IB_FLOW_ATTR_FLAGS_DONT_TRAP | IB_FLOW_ATTR_FLAGS_EGRESS)) {
-	     ~(IB_FLOW_ATTR_FLAGS_DONT_TRAP | IB_FLOW_ATTR_FLAGS_EGRESS))) {
 		err = -EINVAL;
 		goto free_ucmd;
 	}
 	if (err)
 		goto end;
+	if (obj->ns_type == MLX5_FLOW_NAMESPACE_FDB &&
+	    mlx5_eswitch_mode(dev->mdev) != MLX5_ESWITCH_OFFLOADS) {
+		err = -EINVAL;
+		goto end;
+	}
 	uobj->object = obj;
 	obj->mdev = dev->mdev;
 	atomic_set(&obj->usecnt, 0);

drivers/infiniband/hw/mlx5/mr.c+2−2

@@ -1940,8 +1940,8 @@ int mlx5_ib_dereg_mr(struct ib_mr ibmr, struct ib_udata udata) · 1939 unmodified lines
1940	mlx5r_deref_wait_odp_mkey(&mr->mmkey);	1940	mlx5r_deref_wait_odp_mkey(&mr->mmkey);
1941		1941
1942	if (ibmr->type == IB_MR_TYPE_INTEGRITY) {	1942	if (ibmr->type == IB_MR_TYPE_INTEGRITY) {
1943	xa_cmpxchg(&dev->sig_mrs, mlx5_base_mkey(mr->mmkey.key), ibmr,	1943	xa_cmpxchg(&dev->sig_mrs, mlx5_base_mkey(mr->mmkey.key),
1944	NULL, GFP_KERNEL);	1944	mr->sig, NULL, GFP_KERNEL);
1945		1945
1946	if (mr->mtt_mr) {	1946	if (mr->mtt_mr) {
1947	rc = mlx5_ib_dereg_mr(&mr->mtt_mr->ibmr, NULL);	1947	rc = mlx5_ib_dereg_mr(&mr->mtt_mr->ibmr, NULL);

drivers/infiniband/ulp/ipoib/ipoib_netlink.c+1−0

@@ -163,6 +163,7 @@ static size_t ipoib_get_size(const struct net_device *dev) · 162 unmodified lines
163		163
164	static struct rtnl_link_ops ipoib_link_ops __read_mostly = {	164	static struct rtnl_link_ops ipoib_link_ops __read_mostly = {
165	.kind = "ipoib",	165	.kind = "ipoib",
		166	.netns_refund = true,
166	.maxtype = IFLA_IPOIB_MAX,	167	.maxtype = IFLA_IPOIB_MAX,
167	.policy = ipoib_policy,	168	.policy = ipoib_policy,
168	.priv_size = sizeof(struct ipoib_dev_priv),	169	.priv_size = sizeof(struct ipoib_dev_priv),

drivers/md/bcache/bcache.h+0−1

@@ -364,7 +364,6 @@ struct cached_dev { · 363 unmodified lines
364		364
365	/* The rest of this all shows up in sysfs */	365	/* The rest of this all shows up in sysfs */
366	unsigned int sequential_cutoff;	366	unsigned int sequential_cutoff;
367	unsigned int readahead;
368		367
369	unsigned int io_disable:1;	368	unsigned int io_disable:1;
370	unsigned int verify:1;	369	unsigned int verify:1;

drivers/md/bcache/request.c+7−13

 				 struct bio *bio, unsigned int sectors)
 {
 	int ret = MAP_CONTINUE;
-	unsigned int reada = 0;
 	struct cached_dev *dc = container_of(s->d, struct cached_dev, disk);
 	struct bio *miss, *cache_bio;
+	unsigned int size_limit;
 	s->cache_missed = 1;
 		goto out_submit;
 	}
-	if (!(bio->bi_opf & REQ_RAHEAD) &&
+	/* Limitation for valid replace key size and cache_bio bvecs number */
-	    !(bio->bi_opf & (REQ_META|REQ_PRIO)) &&
+	size_limit = min_t(unsigned int, BIO_MAX_VECS * PAGE_SECTORS,
-	    s->iop.c->gc_stats.in_use < CUTOFF_CACHE_READA)
+			   (1 << KEY_SIZE_BITS) - 1);
-		reada = min_t(sector_t, dc->readahead >> 9,
+	s->insert_bio_sectors = min3(size_limit, sectors, bio_sectors(bio));
-			      get_capacity(bio->bi_bdev->bd_disk) -
-			      bio_end_sector(bio));
-	s->insert_bio_sectors = min(sectors, bio_sectors(bio) + reada);
 	s->iop.replace_key = KEY(s->iop.inode,
 				 bio->bi_iter.bi_sector + s->insert_bio_sectors,
 	s->iop.replace = true;
-	miss = bio_next_split(bio, sectors, GFP_NOIO, &s->d->bio_split);
+	miss = bio_next_split(bio, s->insert_bio_sectors, GFP_NOIO,
+			      &s->d->bio_split);
 	/* btree_search_recurse()'s btree iterator is no good anymore */
 	ret = miss == bio ? MAP_DONE : -EINTR;
 	if (bch_bio_alloc_pages(cache_bio, __GFP_NOWARN|GFP_NOIO))
 		goto out_put;
-	if (reada)
-		bch_mark_cache_readahead(s->iop.c, s->d);
 	s->cache_miss	= miss;
 	s->iop.bio	= cache_bio;
 	bio_get(cache_bio);

drivers/md/bcache/stats.c+0−14

 read_attribute(cache_bypass_hits);
 read_attribute(cache_bypass_misses);
 read_attribute(cache_hit_ratio);
-read_attribute(cache_readaheads);
 read_attribute(cache_miss_collisions);
 read_attribute(bypassed);
 		    DIV_SAFE(var(cache_hits) * 100,
 			     var(cache_hits) + var(cache_misses)));
-	var_print(cache_readaheads);
 	var_print(cache_miss_collisions);
 	sysfs_hprint(bypassed,	var(sectors_bypassed) << 9);
 #undef var
 	&sysfs_cache_bypass_hits,
 	&sysfs_cache_bypass_misses,
 	&sysfs_cache_hit_ratio,
-	&sysfs_cache_readaheads,
 	&sysfs_cache_miss_collisions,
 	&sysfs_bypassed,
 	NULL
 	acc->total.cache_misses = 0;
 	acc->total.cache_bypass_hits = 0;
 	acc->total.cache_bypass_misses = 0;
-	acc->total.cache_readaheads = 0;
 	acc->total.cache_miss_collisions = 0;
 	acc->total.sectors_bypassed = 0;
 }
 		scale_stat(&stats->cache_misses);
 		scale_stat(&stats->cache_bypass_hits);
 		scale_stat(&stats->cache_bypass_misses);
-		scale_stat(&stats->cache_readaheads);
 		scale_stat(&stats->cache_miss_collisions);
 		scale_stat(&stats->sectors_bypassed);
 	}
 	move_stat(cache_misses);
 	move_stat(cache_bypass_hits);
 	move_stat(cache_bypass_misses);
-	move_stat(cache_readaheads);
 	move_stat(cache_miss_collisions);
 	move_stat(sectors_bypassed);
 	mark_cache_stats(&c->accounting.collector, hit, bypass);
 }
-void bch_mark_cache_readahead(struct cache_set *c, struct bcache_device *d)
-{
-	struct cached_dev *dc = container_of(d, struct cached_dev, disk);
-	atomic_inc(&dc->accounting.collector.cache_readaheads);
-	atomic_inc(&c->accounting.collector.cache_readaheads);
-}
 void bch_mark_cache_miss_collision(struct cache_set *c, struct bcache_device *d)
 {
 	struct cached_dev *dc = container_of(d, struct cached_dev, disk);

drivers/md/bcache/stats.h+0−1

@@ -7,7 +7,6 @@ struct cache_stat_collector { · 6 unmodified lines
7	atomic_t cache_misses;	7	atomic_t cache_misses;
8	atomic_t cache_bypass_hits;	8	atomic_t cache_bypass_hits;
9	atomic_t cache_bypass_misses;	9	atomic_t cache_bypass_misses;
10	atomic_t cache_readaheads;
11	atomic_t cache_miss_collisions;	10	atomic_t cache_miss_collisions;
12	atomic_t sectors_bypassed;	11	atomic_t sectors_bypassed;
13	};	12	};

drivers/md/bcache/sysfs.c+0−4

 rw_attribute(discard);
 rw_attribute(running);
 rw_attribute(label);
-rw_attribute(readahead);
 rw_attribute(errors);
 rw_attribute(io_error_limit);
 rw_attribute(io_error_halflife);
 	var_printf(partial_stripes_expensive,	"%u");
 	var_hprint(sequential_cutoff);
-	var_hprint(readahead);
 	sysfs_print(running,		atomic_read(&dc->running));
 	sysfs_print(state,		states[BDEV_STATE(&dc->sb)]);
 	sysfs_strtoul_clamp(sequential_cutoff,
 			    dc->sequential_cutoff,
 			    0, UINT_MAX);
-	d_strtoi_h(readahead);
 	if (attr == &sysfs_clear_stats)
 		bch_cache_accounting_clear(&dc->accounting);
 	&sysfs_running,
 	&sysfs_state,
 	&sysfs_label,
-	&sysfs_readahead,
 #ifdef CONFIG_BCACHE_DEBUG
 	&sysfs_verify,
 	&sysfs_bypass_torture_test,

drivers/misc/cardreader/rtl8411.c+1−0

@@ -468,6 +468,7 @@ static void rtl8411_init_common_params(struct rtsx_pcr *pcr) · 467 unmodified lines
468	pcr->sd30_drive_sel_1v8 = DRIVER_TYPE_B;	468	pcr->sd30_drive_sel_1v8 = DRIVER_TYPE_B;
469	pcr->sd30_drive_sel_3v3 = DRIVER_TYPE_D;	469	pcr->sd30_drive_sel_3v3 = DRIVER_TYPE_D;
470	pcr->aspm_en = ASPM_L1_EN;	470	pcr->aspm_en = ASPM_L1_EN;
		471	pcr->aspm_mode = ASPM_MODE_CFG;
471	pcr->tx_initial_phase = SET_CLOCK_PHASE(23, 7, 14);	472	pcr->tx_initial_phase = SET_CLOCK_PHASE(23, 7, 14);
472	pcr->rx_initial_phase = SET_CLOCK_PHASE(4, 3, 10);	473	pcr->rx_initial_phase = SET_CLOCK_PHASE(4, 3, 10);
473	pcr->ic_version = rtl8411_get_ic_version(pcr);	474	pcr->ic_version = rtl8411_get_ic_version(pcr);

drivers/misc/cardreader/rts5209.c+1−0

@@ -255,6 +255,7 @@ void rts5209_init_params(struct rtsx_pcr *pcr) · 254 unmodified lines
255	pcr->sd30_drive_sel_1v8 = DRIVER_TYPE_B;	255	pcr->sd30_drive_sel_1v8 = DRIVER_TYPE_B;
256	pcr->sd30_drive_sel_3v3 = DRIVER_TYPE_D;	256	pcr->sd30_drive_sel_3v3 = DRIVER_TYPE_D;
257	pcr->aspm_en = ASPM_L1_EN;	257	pcr->aspm_en = ASPM_L1_EN;
		258	pcr->aspm_mode = ASPM_MODE_CFG;
258	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 27, 16);	259	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 27, 16);
259	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);	260	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);
260		261

drivers/misc/cardreader/rts5227.c+2−0

 	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;
 	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;
 	pcr->aspm_en = ASPM_L1_EN;
+	pcr->aspm_mode = ASPM_MODE_CFG;
 	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 27, 15);
 	pcr->rx_initial_phase = SET_CLOCK_PHASE(30, 7, 7);
 	rts5227_init_params(pcr);
 	pcr->ops = &rts522a_pcr_ops;
+	pcr->aspm_mode = ASPM_MODE_REG;
 	pcr->tx_initial_phase = SET_CLOCK_PHASE(20, 20, 11);
 	pcr->reg_pm_ctrl3 = RTS522A_PM_CTRL3;

drivers/misc/cardreader/rts5228.c+1−0

@@ -718,6 +718,7 @@ void rts5228_init_params(struct rtsx_pcr *pcr) · 717 unmodified lines
718	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;	718	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;
719	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;	719	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;
720	pcr->aspm_en = ASPM_L1_EN;	720	pcr->aspm_en = ASPM_L1_EN;
		721	pcr->aspm_mode = ASPM_MODE_REG;
721	pcr->tx_initial_phase = SET_CLOCK_PHASE(28, 27, 11);	722	pcr->tx_initial_phase = SET_CLOCK_PHASE(28, 27, 11);
722	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);	723	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);
723		724

drivers/misc/cardreader/rts5229.c+1−0

@@ -246,6 +246,7 @@ void rts5229_init_params(struct rtsx_pcr *pcr) · 245 unmodified lines
246	pcr->sd30_drive_sel_1v8 = DRIVER_TYPE_B;	246	pcr->sd30_drive_sel_1v8 = DRIVER_TYPE_B;
247	pcr->sd30_drive_sel_3v3 = DRIVER_TYPE_D;	247	pcr->sd30_drive_sel_3v3 = DRIVER_TYPE_D;
248	pcr->aspm_en = ASPM_L1_EN;	248	pcr->aspm_en = ASPM_L1_EN;
		249	pcr->aspm_mode = ASPM_MODE_CFG;
249	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 27, 15);	250	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 27, 15);
250	pcr->rx_initial_phase = SET_CLOCK_PHASE(30, 6, 6);	251	pcr->rx_initial_phase = SET_CLOCK_PHASE(30, 6, 6);
251		252

drivers/misc/cardreader/rts5249.c+3−0

 	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;
 	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;
 	pcr->aspm_en = ASPM_L1_EN;
+	pcr->aspm_mode = ASPM_MODE_CFG;
 	pcr->tx_initial_phase = SET_CLOCK_PHASE(1, 29, 16);
 	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);
 void rts524a_init_params(struct rtsx_pcr *pcr)
 {
 	rts5249_init_params(pcr);
+	pcr->aspm_mode = ASPM_MODE_REG;
 	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 29, 11);
 	pcr->option.ltr_l1off_sspwrgate = LTR_L1OFF_SSPWRGATE_5250_DEF;
 	pcr->option.ltr_l1off_snooze_sspwrgate =
 void rts525a_init_params(struct rtsx_pcr *pcr)
 {
 	rts5249_init_params(pcr);
+	pcr->aspm_mode = ASPM_MODE_REG;
 	pcr->tx_initial_phase = SET_CLOCK_PHASE(25, 29, 11);
 	pcr->option.ltr_l1off_sspwrgate = LTR_L1OFF_SSPWRGATE_5250_DEF;
 	pcr->option.ltr_l1off_snooze_sspwrgate =

drivers/misc/cardreader/rts5260.c+1−0

@@ -628,6 +628,7 @@ void rts5260_init_params(struct rtsx_pcr *pcr) · 627 unmodified lines
628	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;	628	pcr->sd30_drive_sel_1v8 = CFG_DRIVER_TYPE_B;
629	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;	629	pcr->sd30_drive_sel_3v3 = CFG_DRIVER_TYPE_B;
630	pcr->aspm_en = ASPM_L1_EN;	630	pcr->aspm_en = ASPM_L1_EN;
		631	pcr->aspm_mode = ASPM_MODE_REG;
631	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 29, 11);	632	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 29, 11);
632	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);	633	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);
633		634

drivers/misc/cardreader/rts5261.c+1−0

@@ -783,6 +783,7 @@ void rts5261_init_params(struct rtsx_pcr *pcr) · 782 unmodified lines
783	pcr->sd30_drive_sel_1v8 = 0x00;	783	pcr->sd30_drive_sel_1v8 = 0x00;
784	pcr->sd30_drive_sel_3v3 = 0x00;	784	pcr->sd30_drive_sel_3v3 = 0x00;
785	pcr->aspm_en = ASPM_L1_EN;	785	pcr->aspm_en = ASPM_L1_EN;
		786	pcr->aspm_mode = ASPM_MODE_REG;
786	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 27, 11);	787	pcr->tx_initial_phase = SET_CLOCK_PHASE(27, 27, 11);
787	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);	788	pcr->rx_initial_phase = SET_CLOCK_PHASE(24, 6, 5);
788		789

drivers/misc/cardreader/rtsx_pcr.c+31−13

 	if (pcr->aspm_enabled == enable)
 		return;
-	if (pcr->aspm_en & 0x02)
+	if (pcr->aspm_mode == ASPM_MODE_CFG) {
-		rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, FORCE_ASPM_CTL0 |
+		pcie_capability_clear_and_set_word(pcr->pci, PCI_EXP_LNKCTL,
-			FORCE_ASPM_CTL1, enable ? 0 : FORCE_ASPM_CTL0 | FORCE_ASPM_CTL1);
+						PCI_EXP_LNKCTL_ASPMC,
-	else
+						enable ? pcr->aspm_en : 0);
-		rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, FORCE_ASPM_CTL0 |
+	} else if (pcr->aspm_mode == ASPM_MODE_REG) {
-			FORCE_ASPM_CTL1, FORCE_ASPM_CTL0 | FORCE_ASPM_CTL1);
+		if (pcr->aspm_en & 0x02)
+			rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, FORCE_ASPM_CTL0 |
+				FORCE_ASPM_CTL1, enable ? 0 : FORCE_ASPM_CTL0 | FORCE_ASPM_CTL1);
+		else
+			rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, FORCE_ASPM_CTL0 |
+				FORCE_ASPM_CTL1, FORCE_ASPM_CTL0 | FORCE_ASPM_CTL1);
+	}
 	if (!enable && (pcr->aspm_en & 0x02))
 		mdelay(10);
 			return err;
 	}
-	rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, 0x30, 0x30);
+	if (pcr->aspm_mode == ASPM_MODE_REG)
+		rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, 0x30, 0x30);
 	/* No CD interrupt if probing driver with card inserted.
 	 * So we need to initialize pcr->card_exist here.
 static int rtsx_pci_init_chip(struct rtsx_pcr *pcr)
 {
 	int err;
+	u16 cfg_val;
+	u8 val;
 	spin_lock_init(&pcr->lock);
 	mutex_init(&pcr->pcr_mutex);
 	if (!pcr->slots)
 		return -ENOMEM;
+	if (pcr->aspm_mode == ASPM_MODE_CFG) {
+		pcie_capability_read_word(pcr->pci, PCI_EXP_LNKCTL, &cfg_val);
+		if (cfg_val & PCI_EXP_LNKCTL_ASPM_L1)
+			pcr->aspm_enabled = true;
+		else
+			pcr->aspm_enabled = false;
+	} else if (pcr->aspm_mode == ASPM_MODE_REG) {
+		rtsx_pci_read_register(pcr, ASPM_FORCE_CTL, &val);
+		if (val & FORCE_ASPM_CTL0 && val & FORCE_ASPM_CTL1)
+			pcr->aspm_enabled = false;
+		else
+			pcr->aspm_enabled = true;
+	}
 	if (pcr->ops->fetch_vendor_settings)
 		pcr->ops->fetch_vendor_settings(pcr);
 	struct pcr_handle *handle;
 	u32 base, len;
 	int ret, i, bar = 0;
-	u8 val;
 	dev_dbg(&(pcidev->dev),
 		": Realtek PCI-E Card Reader found at %s [%04x:%04x] (rev %x)\n",
 	pcr->host_cmds_addr = pcr->rtsx_resv_buf_addr;
 	pcr->host_sg_tbl_ptr = pcr->rtsx_resv_buf + HOST_CMDS_BUF_LEN;
 	pcr->host_sg_tbl_addr = pcr->rtsx_resv_buf_addr + HOST_CMDS_BUF_LEN;
-	rtsx_pci_read_register(pcr, ASPM_FORCE_CTL, &val);
-	if (val & FORCE_ASPM_CTL0 && val & FORCE_ASPM_CTL1)
-		pcr->aspm_enabled = false;
-	else
-		pcr->aspm_enabled = true;
 	pcr->card_inserted = 0;
 	pcr->card_removed = 0;
 	INIT_DELAYED_WORK(&pcr->carddet_work, rtsx_pci_card_detect);

drivers/mmc/host/renesas_sdhi_core.c+7−2

 	/* Issue CMD19 twice for each tap */
 	for (i = 0; i < 2 * priv->tap_num; i++) {
+		int cmd_error;
 		/* Set sampling clock position */
 		sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_TAPSET, i % priv->tap_num);
-		if (mmc_send_tuning(mmc, opcode, NULL) == 0)
+		if (mmc_send_tuning(mmc, opcode, &cmd_error) == 0)
 			set_bit(i, priv->taps);
 		if (sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_SMPCMP) == 0)
 			set_bit(i, priv->smpcmp);
+		if (cmd_error)
+			mmc_abort_tuning(mmc, opcode);
 	}
 	ret = renesas_sdhi_select_tuning(host);
 	{ .soc_id = "r8a7795", .revision = "ES3.*", .data = &sdhi_quirks_bad_taps2367 },
 	{ .soc_id = "r8a7796", .revision = "ES1.[012]", .data = &sdhi_quirks_4tap_nohs400 },
 	{ .soc_id = "r8a7796", .revision = "ES1.*", .data = &sdhi_quirks_r8a7796_es13 },
-	{ .soc_id = "r8a7796", .revision = "ES3.*", .data = &sdhi_quirks_bad_taps1357 },
+	{ .soc_id = "r8a77961", .data = &sdhi_quirks_bad_taps1357 },
 	{ .soc_id = "r8a77965", .data = &sdhi_quirks_r8a77965 },
 	{ .soc_id = "r8a77980", .data = &sdhi_quirks_nohs400 },
 	{ .soc_id = "r8a77990", .data = &sdhi_quirks_r8a77990 },

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h+0−2

 			  bool persistent, u8 *smt_idx);
 int cxgb4_get_msix_idx_from_bmap(struct adapter *adap);
 void cxgb4_free_msix_idx_in_bmap(struct adapter *adap, u32 msix_idx);
-int cxgb_open(struct net_device *dev);
-int cxgb_close(struct net_device *dev);
 void cxgb4_enable_rx(struct adapter *adap, struct sge_rspq *q);
 void cxgb4_quiesce_rx(struct sge_rspq *q);
 int cxgb4_port_mirror_alloc(struct net_device *dev);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c+2−2

@@ -2834,7 +2834,7 @@ static void cxgb_down(struct adapter *adapter) · 2833 unmodified lines
2834	/*	2834	/*
2835	* net_device operations	2835	* net_device operations
2836	*/	2836	*/
2837	int cxgb_open(struct net_device *dev)	2837	static int cxgb_open(struct net_device *dev)
2838	{	2838	{
2839	struct port_info *pi = netdev_priv(dev);	2839	struct port_info *pi = netdev_priv(dev);
2840	struct adapter *adapter = pi->adapter;	2840	struct adapter *adapter = pi->adapter;
@@ -2882,7 +2882,7 @@ out_unlock: · 41 unmodified lines
2882	return err;	2882	return err;
2883	}	2883	}
2884		2884
2885	int cxgb_close(struct net_device *dev)	2885	static int cxgb_close(struct net_device *dev)
2886	{	2886	{
2887	struct port_info *pi = netdev_priv(dev);	2887	struct port_info *pi = netdev_priv(dev);
2888	struct adapter *adapter = pi->adapter;	2888	struct adapter *adapter = pi->adapter;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c+5−9

 	if (!ch_flower)
 		return -ENOENT;
+	rhashtable_remove_fast(&adap->flower_tbl, &ch_flower->node,
+			       adap->flower_ht_params);
 	ret = cxgb4_flow_rule_destroy(dev, ch_flower->fs.tc_prio,
 				      &ch_flower->fs, ch_flower->filter_id);
 	if (ret)
-		goto err;
+		netdev_err(dev, "Flow rule destroy failed for tid: %u, ret: %d",
+			   ch_flower->filter_id, ret);
-	ret = rhashtable_remove_fast(&adap->flower_tbl, &ch_flower->node,
-				     adap->flower_ht_params);
-	if (ret) {
-		netdev_err(dev, "Flow remove from rhashtable failed");
-		goto err;
-	}
 	kfree_rcu(ch_flower, rcu);
-err:
 	return ret;
 }

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_mqprio.c+6−3

 	 * down before configuring tc params.
 	 */
 	if (netif_running(dev)) {
-		cxgb_close(dev);
+		netif_tx_stop_all_queues(dev);
+		netif_carrier_off(dev);
 		needs_bring_up = true;
 	}
 	}
 out:
-	if (needs_bring_up)
+	if (needs_bring_up) {
-		cxgb_open(dev);
+		netif_tx_start_all_queues(dev);
+		netif_carrier_on(dev);
+	}
 	mutex_unlock(&adap->tc_mqprio->mqprio_mutex);
 	return ret;

drivers/net/ethernet/chelsio/cxgb4/sge.c+6−0

 	if (!eosw_txq)
 		return -ENOMEM;
+	if (!(adap->flags & CXGB4_FW_OK)) {
+		/* Don't stall caller when access to FW is lost */
+		complete(&eosw_txq->completion);
+		return -EIO;
+	}
 	skb = alloc_skb(len, GFP_KERNEL);
 	if (!skb)
 		return -ENOMEM;

drivers/net/ethernet/intel/i40e/i40e_txrx.c+6−1

 	case XDP_TX:
 		xdp_ring = rx_ring->vsi->xdp_rings[rx_ring->queue_index];
 		result = i40e_xmit_xdp_tx_ring(xdp, xdp_ring);
+		if (result == I40E_XDP_CONSUMED)
+			goto out_failure;
 		break;
 	case XDP_REDIRECT:
 		err = xdp_do_redirect(rx_ring->netdev, xdp, xdp_prog);
-		result = !err ? I40E_XDP_REDIR : I40E_XDP_CONSUMED;
+		if (err)
+			goto out_failure;
+		result = I40E_XDP_REDIR;
 		break;
 	default:
 		bpf_warn_invalid_xdp_action(act);
 		fallthrough;
 	case XDP_ABORTED:
+out_failure:
 		trace_xdp_exception(rx_ring->netdev, xdp_prog, act);
 		fallthrough; /* handle aborts by dropping packet */
 	case XDP_DROP:

drivers/net/ethernet/intel/i40e/i40e_xsk.c+6−2

 	if (likely(act == XDP_REDIRECT)) {
 		err = xdp_do_redirect(rx_ring->netdev, xdp, xdp_prog);
-		result = !err ? I40E_XDP_REDIR : I40E_XDP_CONSUMED;
+		if (err)
+			goto out_failure;
 		rcu_read_unlock();
-		return result;
+		return I40E_XDP_REDIR;
 	}
 	switch (act) {
 	case XDP_TX:
 		xdp_ring = rx_ring->vsi->xdp_rings[rx_ring->queue_index];
 		result = i40e_xmit_xdp_tx_ring(xdp, xdp_ring);
+		if (result == I40E_XDP_CONSUMED)
+			goto out_failure;
 		break;
 	default:
 		bpf_warn_invalid_xdp_action(act);
 		fallthrough;
 	case XDP_ABORTED:
+out_failure:
 		trace_xdp_exception(rx_ring->netdev, xdp_prog, act);
 		fallthrough; /* handle aborts by dropping packet */
 	case XDP_DROP:

drivers/net/ethernet/intel/ice/ice.h+5−3

 	struct ice_tc_cfg tc_cfg;
 	struct bpf_prog *xdp_prog;
 	struct ice_ring **xdp_rings;	 /* XDP ring array */
+	unsigned long *af_xdp_zc_qps;	 /* tracks AF_XDP ZC enabled qps */
 	u16 num_xdp_txq;		 /* Used XDP queues */
 	u8 xdp_mapping_mode;		 /* ICE_MAP_MODE_[CONTIG|SCATTER] */
  */
 static inline struct xsk_buff_pool *ice_xsk_pool(struct ice_ring *ring)
 {
+	struct ice_vsi *vsi = ring->vsi;
 	u16 qid = ring->q_index;
 	if (ice_ring_is_xdp(ring))
-		qid -= ring->vsi->num_xdp_txq;
+		qid -= vsi->num_xdp_txq;
-	if (!ice_is_xdp_ena_vsi(ring->vsi))
+	if (!ice_is_xdp_ena_vsi(vsi) || !test_bit(qid, vsi->af_xdp_zc_qps))
 		return NULL;
-	return xsk_get_pool_from_qid(ring->vsi->netdev, qid);
+	return xsk_get_pool_from_qid(vsi->netdev, qid);
 }
 /**

drivers/net/ethernet/intel/ice/ice_ethtool.c+6−45

@@ -1773,49 +1773,6 @@ ice_phy_type_to_ethtool(struct net_device *netdev, · 1772 unmodified lines
1773	ice_ethtool_advertise_link_mode(ICE_AQ_LINK_SPEED_100GB,	1773	ice_ethtool_advertise_link_mode(ICE_AQ_LINK_SPEED_100GB,
1774	100000baseKR4_Full);	1774	100000baseKR4_Full);
1775	}	1775	}
1776
1777	/* Autoneg PHY types */
1778	if (phy_types_low & ICE_PHY_TYPE_LOW_100BASE_TX \|\|
1779	phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_T \|\|
1780	phy_types_low & ICE_PHY_TYPE_LOW_1000BASE_KX \|\|
1781	phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_T \|\|
1782	phy_types_low & ICE_PHY_TYPE_LOW_2500BASE_KX \|\|
1783	phy_types_low & ICE_PHY_TYPE_LOW_5GBASE_T \|\|
1784	phy_types_low & ICE_PHY_TYPE_LOW_5GBASE_KR \|\|
1785	phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_T \|\|
1786	phy_types_low & ICE_PHY_TYPE_LOW_10GBASE_KR_CR1 \|\|
1787	phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_T \|\|
1788	phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR \|\|
1789	phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR_S \|\|
1790	phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_CR1 \|\|
1791	phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR \|\|
1792	phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR_S \|\|
1793	phy_types_low & ICE_PHY_TYPE_LOW_25GBASE_KR1 \|\|
1794	phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_CR4 \|\|
1795	phy_types_low & ICE_PHY_TYPE_LOW_40GBASE_KR4) {
1796	ethtool_link_ksettings_add_link_mode(ks, supported,
1797	Autoneg);
1798	ethtool_link_ksettings_add_link_mode(ks, advertising,
1799	Autoneg);
1800	}
1801	if (phy_types_low & ICE_PHY_TYPE_LOW_50GBASE_CR2 \|\|
1802	phy_types_low & ICE_PHY_TYPE_LOW_50GBASE_KR2 \|\|
1803	phy_types_low & ICE_PHY_TYPE_LOW_50GBASE_CP \|\|
1804	phy_types_low & ICE_PHY_TYPE_LOW_50GBASE_KR_PAM4) {
1805	ethtool_link_ksettings_add_link_mode(ks, supported,
1806	Autoneg);
1807	ethtool_link_ksettings_add_link_mode(ks, advertising,
1808	Autoneg);
1809	}
1810	if (phy_types_low & ICE_PHY_TYPE_LOW_100GBASE_CR4 \|\|
1811	phy_types_low & ICE_PHY_TYPE_LOW_100GBASE_KR4 \|\|
1812	phy_types_low & ICE_PHY_TYPE_LOW_100GBASE_KR_PAM4 \|\|
1813	phy_types_low & ICE_PHY_TYPE_LOW_100GBASE_CP2) {
1814	ethtool_link_ksettings_add_link_mode(ks, supported,
1815	Autoneg);
1816	ethtool_link_ksettings_add_link_mode(ks, advertising,
1817	Autoneg);
1818	}
1819	}	1776	}
1820		1777
1821	#define TEST_SET_BITS_TIMEOUT 50	1778	#define TEST_SET_BITS_TIMEOUT 50
@@ -1972,9 +1929,7 @@ ice_get_link_ksettings(struct net_device *netdev, · 150 unmodified lines
1972	ks->base.port = PORT_TP;	1929	ks->base.port = PORT_TP;
1973	break;	1930	break;
1974	case ICE_MEDIA_BACKPLANE:	1931	case ICE_MEDIA_BACKPLANE:
1975	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
1976	ethtool_link_ksettings_add_link_mode(ks, supported, Backplane);	1932	ethtool_link_ksettings_add_link_mode(ks, supported, Backplane);
1977	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
1978	ethtool_link_ksettings_add_link_mode(ks, advertising,	1933	ethtool_link_ksettings_add_link_mode(ks, advertising,
1979	Backplane);	1934	Backplane);
1980	ks->base.port = PORT_NONE;	1935	ks->base.port = PORT_NONE;
@@ -2049,6 +2004,12 @@ ice_get_link_ksettings(struct net_device *netdev, · 68 unmodified lines
2049	if (caps->link_fec_options & ICE_AQC_PHY_FEC_25G_RS_CLAUSE91_EN)	2004	if (caps->link_fec_options & ICE_AQC_PHY_FEC_25G_RS_CLAUSE91_EN)
2050	ethtool_link_ksettings_add_link_mode(ks, supported, FEC_RS);	2005	ethtool_link_ksettings_add_link_mode(ks, supported, FEC_RS);
2051		2006
		2007	/* Set supported and advertised autoneg */
		2008	if (ice_is_phy_caps_an_enabled(caps)) {
		2009	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
		2010	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
		2011	}
		2012
2052	done:	2013	done:
2053	kfree(caps);	2014	kfree(caps);
2054	return err;	2015	return err;

drivers/net/ethernet/intel/ice/ice_hw_autogen.h+1−0

@@ -31,6 +31,7 @@ · 30 unmodified lines
31	#define PF_FW_ATQLEN_ATQOVFL_M BIT(29)	31	#define PF_FW_ATQLEN_ATQOVFL_M BIT(29)
32	#define PF_FW_ATQLEN_ATQCRIT_M BIT(30)	32	#define PF_FW_ATQLEN_ATQCRIT_M BIT(30)
33	#define VF_MBX_ARQLEN(_VF) (0x0022BC00 + ((_VF) * 4))	33	#define VF_MBX_ARQLEN(_VF) (0x0022BC00 + ((_VF) * 4))
		34	#define VF_MBX_ATQLEN(_VF) (0x0022A800 + ((_VF) * 4))
34	#define PF_FW_ATQLEN_ATQENABLE_M BIT(31)	35	#define PF_FW_ATQLEN_ATQENABLE_M BIT(31)
35	#define PF_FW_ATQT 0x00080400	36	#define PF_FW_ATQT 0x00080400
36	#define PF_MBX_ARQBAH 0x0022E400	37	#define PF_MBX_ARQBAH 0x0022E400

drivers/net/ethernet/intel/ice/ice_lib.c+12−0

 	if (!vsi->q_vectors)
 		goto err_vectors;
+	vsi->af_xdp_zc_qps = bitmap_zalloc(max_t(int, vsi->alloc_txq, vsi->alloc_rxq), GFP_KERNEL);
+	if (!vsi->af_xdp_zc_qps)
+		goto err_zc_qps;
 	return 0;
+err_zc_qps:
+	devm_kfree(dev, vsi->q_vectors);
 err_vectors:
 	devm_kfree(dev, vsi->rxq_map);
 err_rxq_map:
 		break;
 	case ICE_VSI_VF:
 		vf = &pf->vf[vsi->vf_id];
+		if (vf->num_req_qs)
+			vf->num_vf_qs = vf->num_req_qs;
 		vsi->alloc_txq = vf->num_vf_qs;
 		vsi->alloc_rxq = vf->num_vf_qs;
 		/* pf->num_msix_per_vf includes (VF miscellaneous vector +
 	dev = ice_pf_to_dev(pf);
+	if (vsi->af_xdp_zc_qps) {
+		bitmap_free(vsi->af_xdp_zc_qps);
+		vsi->af_xdp_zc_qps = NULL;
+	}
 	/* free the ring and vector containers */
 	if (vsi->q_vectors) {
 		devm_kfree(dev, vsi->q_vectors);

drivers/net/ethernet/intel/ice/ice_txrx.c+13−4

 	    struct bpf_prog *xdp_prog)
 {
 	struct ice_ring *xdp_ring;
-	int err;
+	int err, result;
 	u32 act;
 	act = bpf_prog_run_xdp(xdp_prog, xdp);
 		return ICE_XDP_PASS;
 	case XDP_TX:
 		xdp_ring = rx_ring->vsi->xdp_rings[smp_processor_id()];
-		return ice_xmit_xdp_buff(xdp, xdp_ring);
+		result = ice_xmit_xdp_buff(xdp, xdp_ring);
+		if (result == ICE_XDP_CONSUMED)
+			goto out_failure;
+		return result;
 	case XDP_REDIRECT:
 		err = xdp_do_redirect(rx_ring->netdev, xdp, xdp_prog);
-		return !err ? ICE_XDP_REDIR : ICE_XDP_CONSUMED;
+		if (err)
+			goto out_failure;
+		return ICE_XDP_REDIR;
 	default:
 		bpf_warn_invalid_xdp_action(act);
 		fallthrough;
 	case XDP_ABORTED:
+out_failure:
 		trace_xdp_exception(rx_ring->netdev, xdp_prog, act);
 		fallthrough;
 	case XDP_DROP:
 	struct ice_tx_offload_params offload = { 0 };
 	struct ice_vsi *vsi = tx_ring->vsi;
 	struct ice_tx_buf *first;
+	struct ethhdr *eth;
 	unsigned int count;
 	int tso, csum;
 		goto out_drop;
 	/* allow CONTROL frames egress from main VSI if FW LLDP disabled */
-	if (unlikely(skb->priority == TC_PRIO_CONTROL &&
+	eth = (struct ethhdr *)skb_mac_header(skb);
+	if (unlikely((skb->priority == TC_PRIO_CONTROL ||
+		      eth->h_proto == htons(ETH_P_LLDP)) &&
 		     vsi->type == ICE_VSI_PF &&
 		     vsi->port_info->qos_cfg.is_sw_lldp))
 		offload.cd_qw1 |= (u64)(ICE_TX_DESC_DTYPE_CTX |

drivers/net/ethernet/intel/ice/ice_virtchnl_pf.c+13−6

@@ -713,13 +713,15 @@ static void ice_trigger_vf_reset(struct ice_vf *vf, bool is_vflr, bool is_pfr) · 712 unmodified lines
713	*/	713	*/
714	clear_bit(ICE_VF_STATE_INIT, vf->vf_states);	714	clear_bit(ICE_VF_STATE_INIT, vf->vf_states);
715		715
716	/* VF_MBX_ARQLEN is cleared by PFR, so the driver needs to clear it	716	/* VF_MBX_ARQLEN and VF_MBX_ATQLEN are cleared by PFR, so the driver
717	* in the case of VFR. If this is done for PFR, it can mess up VF	717	* needs to clear them in the case of VFR/VFLR. If this is done for
718	* resets because the VF driver may already have started cleanup	718	* PFR, it can mess up VF resets because the VF driver may already
719	* by the time we get here.	719	* have started cleanup by the time we get here.
720	*/	720	*/
721	if (!is_pfr)	721	if (!is_pfr) {
722	wr32(hw, VF_MBX_ARQLEN(vf->vf_id), 0);	722	wr32(hw, VF_MBX_ARQLEN(vf->vf_id), 0);
		723	wr32(hw, VF_MBX_ATQLEN(vf->vf_id), 0);
		724	}
723		725
724	/* In the case of a VFLR, the HW has already reset the VF and we	726	/* In the case of a VFLR, the HW has already reset the VF and we
725	* just need to clean up, so don't hit the VFRTRIG register.	727	* just need to clean up, so don't hit the VFRTRIG register.
@@ -1698,7 +1700,12 @@ bool ice_reset_vf(struct ice_vf *vf, bool is_vflr) · 972 unmodified lines
1698	ice_vf_ctrl_vsi_release(vf);	1700	ice_vf_ctrl_vsi_release(vf);
1699		1701
1700	ice_vf_pre_vsi_rebuild(vf);	1702	ice_vf_pre_vsi_rebuild(vf);
1701	ice_vf_rebuild_vsi_with_release(vf);	1703
		1704	if (ice_vf_rebuild_vsi_with_release(vf)) {
		1705	dev_err(dev, "Failed to release and setup the VF%u's VSI\n", vf->vf_id);
		1706	return false;
		1707	}
		1708
1702	ice_vf_post_vsi_rebuild(vf);	1709	ice_vf_post_vsi_rebuild(vf);
1703		1710
1704	/* if the VF has been reset allow it to come up again */	1711	/* if the VF has been reset allow it to come up again */

drivers/net/ethernet/intel/ice/ice_xsk.c+9−2

 	if (!pool)
 		return -EINVAL;
+	clear_bit(qid, vsi->af_xdp_zc_qps);
 	xsk_pool_dma_unmap(pool, ICE_RX_DMA_ATTR);
 	return 0;
 	if (err)
 		return err;
+	set_bit(qid, vsi->af_xdp_zc_qps);
 	return 0;
 }
 	if (likely(act == XDP_REDIRECT)) {
 		err = xdp_do_redirect(rx_ring->netdev, xdp, xdp_prog);
-		result = !err ? ICE_XDP_REDIR : ICE_XDP_CONSUMED;
+		if (err)
+			goto out_failure;
 		rcu_read_unlock();
-		return result;
+		return ICE_XDP_REDIR;
 	}
 	switch (act) {
 	case XDP_TX:
 		xdp_ring = rx_ring->vsi->xdp_rings[rx_ring->q_index];
 		result = ice_xmit_xdp_buff(xdp, xdp_ring);
+		if (result == ICE_XDP_CONSUMED)
+			goto out_failure;
 		break;
 	default:
 		bpf_warn_invalid_xdp_action(act);
 		fallthrough;
 	case XDP_ABORTED:
+out_failure:
 		trace_xdp_exception(rx_ring->netdev, xdp_prog, act);
 		fallthrough;
 	case XDP_DROP:

drivers/net/ethernet/intel/igb/igb.h+1−1

@@ -749,7 +749,7 @@ void igb_ptp_rx_hang(struct igb_adapter *adapter); · 748 unmodified lines
749	void igb_ptp_tx_hang(struct igb_adapter *adapter);	749	void igb_ptp_tx_hang(struct igb_adapter *adapter);
750	void igb_ptp_rx_rgtstamp(struct igb_q_vector q_vector, struct sk_buff skb);	750	void igb_ptp_rx_rgtstamp(struct igb_q_vector q_vector, struct sk_buff skb);
751	int igb_ptp_rx_pktstamp(struct igb_q_vector q_vector, void va,	751	int igb_ptp_rx_pktstamp(struct igb_q_vector q_vector, void va,
752	struct sk_buff *skb);	752	ktime_t *timestamp);
753	int igb_ptp_set_ts_config(struct net_device netdev, struct ifreq ifr);	753	int igb_ptp_set_ts_config(struct net_device netdev, struct ifreq ifr);
754	int igb_ptp_get_ts_config(struct net_device netdev, struct ifreq ifr);	754	int igb_ptp_get_ts_config(struct net_device netdev, struct ifreq ifr);
755	void igb_set_flag_queue_pairs(struct igb_adapter *, const u32);	755	void igb_set_flag_queue_pairs(struct igb_adapter *, const u32);

drivers/net/ethernet/intel/igb/igb_main.c+32−23

 static struct sk_buff *igb_construct_skb(struct igb_ring *rx_ring,
 					 struct igb_rx_buffer *rx_buffer,
 					 struct xdp_buff *xdp,
-					 union e1000_adv_rx_desc *rx_desc)
+					 ktime_t timestamp)
 {
 #if (PAGE_SIZE < 8192)
 	unsigned int truesize = igb_rx_pg_size(rx_ring) / 2;
 	if (unlikely(!skb))
 		return NULL;
-	if (unlikely(igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP))) {
+	if (timestamp)
-		if (!igb_ptp_rx_pktstamp(rx_ring->q_vector, xdp->data, skb)) {
+		skb_hwtstamps(skb)->hwtstamp = timestamp;
-			xdp->data += IGB_TS_HDR_LEN;
-			size -= IGB_TS_HDR_LEN;
-		}
-	}
 	/* Determine available headroom for copy */
 	headlen = size;
 static struct sk_buff *igb_build_skb(struct igb_ring *rx_ring,
 				     struct igb_rx_buffer *rx_buffer,
 				     struct xdp_buff *xdp,
-				     union e1000_adv_rx_desc *rx_desc)
+				     ktime_t timestamp)
 {
 #if (PAGE_SIZE < 8192)
 	unsigned int truesize = igb_rx_pg_size(rx_ring) / 2;
 	if (metasize)
 		skb_metadata_set(skb, metasize);
-	/* pull timestamp out of packet data */
+	if (timestamp)
-	if (igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP)) {
+		skb_hwtstamps(skb)->hwtstamp = timestamp;
-		if (!igb_ptp_rx_pktstamp(rx_ring->q_vector, skb->data, skb))
-			__skb_pull(skb, IGB_TS_HDR_LEN);
-	}
 	/* update buffer offset */
 #if (PAGE_SIZE < 8192)
 		break;
 	case XDP_TX:
 		result = igb_xdp_xmit_back(adapter, xdp);
+		if (result == IGB_XDP_CONSUMED)
+			goto out_failure;
 		break;
 	case XDP_REDIRECT:
 		err = xdp_do_redirect(adapter->netdev, xdp, xdp_prog);
-		if (!err)
+		if (err)
-			result = IGB_XDP_REDIR;
+			goto out_failure;
-		else
+		result = IGB_XDP_REDIR;
-			result = IGB_XDP_CONSUMED;
 		break;
 	default:
 		bpf_warn_invalid_xdp_action(act);
 		fallthrough;
 	case XDP_ABORTED:
+out_failure:
 		trace_xdp_exception(rx_ring->netdev, xdp_prog, act);
 		fallthrough;
 	case XDP_DROP:
 	while (likely(total_packets < budget)) {
 		union e1000_adv_rx_desc *rx_desc;
 		struct igb_rx_buffer *rx_buffer;
+		ktime_t timestamp = 0;
+		int pkt_offset = 0;
 		unsigned int size;
+		void *pktbuf;
 		/* return some buffers to hardware, one at a time is too slow */
 		if (cleaned_count >= IGB_RX_BUFFER_WRITE) {
 		dma_rmb();
 		rx_buffer = igb_get_rx_buffer(rx_ring, size, &rx_buf_pgcnt);
+		pktbuf = page_address(rx_buffer->page) + rx_buffer->page_offset;
+		/* pull rx packet timestamp if available and valid */
+		if (igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP)) {
+			int ts_hdr_len;
+			ts_hdr_len = igb_ptp_rx_pktstamp(rx_ring->q_vector,
+							 pktbuf, &timestamp);
+			pkt_offset += ts_hdr_len;
+			size -= ts_hdr_len;
+		}
 		/* retrieve a buffer from the ring */
 		if (!skb) {
-			unsigned int offset = igb_rx_offset(rx_ring);
+			unsigned char *hard_start = pktbuf - igb_rx_offset(rx_ring);
-			unsigned char *hard_start;
+			unsigned int offset = pkt_offset + igb_rx_offset(rx_ring);
-			hard_start = page_address(rx_buffer->page) +
-				     rx_buffer->page_offset - offset;
 			xdp_prepare_buff(&xdp, hard_start, offset, size, true);
 #if (PAGE_SIZE > 4096)
 			/* At larger PAGE_SIZE, frame_sz depend on len size */
 		} else if (skb)
 			igb_add_rx_frag(rx_ring, rx_buffer, skb, size);
 		else if (ring_uses_build_skb(rx_ring))
-			skb = igb_build_skb(rx_ring, rx_buffer, &xdp, rx_desc);
+			skb = igb_build_skb(rx_ring, rx_buffer, &xdp,
+					    timestamp);
 		else
 			skb = igb_construct_skb(rx_ring, rx_buffer,
-						&xdp, rx_desc);
+						&xdp, timestamp);
 		/* exit if we failed to retrieve a buffer */
 		if (!skb) {

drivers/net/ethernet/intel/igb/igb_ptp.c+10−13

 	dev_kfree_skb_any(skb);
 }
-#define IGB_RET_PTP_DISABLED 1
-#define IGB_RET_PTP_INVALID 2
 /**
  * igb_ptp_rx_pktstamp - retrieve Rx per packet timestamp
  * @q_vector: Pointer to interrupt specific structure
  * @va: Pointer to address containing Rx buffer
- * @skb: Buffer containing timestamp and packet
+ * @timestamp: Pointer where timestamp will be stored
  *
  * This function is meant to retrieve a timestamp from the first buffer of an
  * incoming frame.  The value is stored in little endian format starting on
  * byte 8
  *
- * Returns: 0 if success, nonzero if failure
+ * Returns: The timestamp header length or 0 if not available
  **/
 int igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector, void *va,
-			struct sk_buff *skb)
+			ktime_t *timestamp)
 {
 	struct igb_adapter *adapter = q_vector->adapter;
+	struct skb_shared_hwtstamps ts;
 	__le64 *regval = (__le64 *)va;
 	int adjust = 0;
 	if (!(adapter->ptp_flags & IGB_PTP_ENABLED))
-		return IGB_RET_PTP_DISABLED;
+		return 0;
 	/* The timestamp is recorded in little endian format.
 	 * DWORD: 0        1        2        3
 	/* check reserved dwords are zero, be/le doesn't matter for zero */
 	if (regval[0])
-		return IGB_RET_PTP_INVALID;
+		return 0;
-	igb_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb),
+	igb_ptp_systim_to_hwtstamp(adapter, &ts, le64_to_cpu(regval[1]));
-				   le64_to_cpu(regval[1]));
 	/* adjust timestamp for the RX latency based on link speed */
 	if (adapter->hw.mac.type == e1000_i210) {
 			break;
 		}
 	}
-	skb_hwtstamps(skb)->hwtstamp =
-		ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust);
-	return 0;
+	*timestamp = ktime_sub_ns(ts.hwtstamp, adjust);
+	return IGB_TS_HDR_LEN;
 }
 /**

drivers/net/ethernet/intel/igc/igc_main.c+5−6

 		break;
 	case XDP_TX:
 		if (igc_xdp_xmit_back(adapter, xdp) < 0)
-			res = IGC_XDP_CONSUMED;
+			goto out_failure;
-		else
+		res = IGC_XDP_TX;
-			res = IGC_XDP_TX;
 		break;
 	case XDP_REDIRECT:
 		if (xdp_do_redirect(adapter->netdev, xdp, prog) < 0)
-			res = IGC_XDP_CONSUMED;
+			goto out_failure;
-		else
+		res = IGC_XDP_REDIRECT;
-			res = IGC_XDP_REDIRECT;
 		break;
 	default:
 		bpf_warn_invalid_xdp_action(act);
 		fallthrough;
 	case XDP_ABORTED:
+out_failure:
 		trace_xdp_exception(adapter->netdev, prog, act);
 		fallthrough;
 	case XDP_DROP:

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c+8−8

 		break;
 	case XDP_TX:
 		xdpf = xdp_convert_buff_to_frame(xdp);
-		if (unlikely(!xdpf)) {
+		if (unlikely(!xdpf))
-			result = IXGBE_XDP_CONSUMED;
+			goto out_failure;
-			break;
-		}
 		result = ixgbe_xmit_xdp_ring(adapter, xdpf);
+		if (result == IXGBE_XDP_CONSUMED)
+			goto out_failure;
 		break;
 	case XDP_REDIRECT:
 		err = xdp_do_redirect(adapter->netdev, xdp, xdp_prog);
-		if (!err)
+		if (err)
-			result = IXGBE_XDP_REDIR;
+			goto out_failure;
-		else
+		result = IXGBE_XDP_REDIR;
-			result = IXGBE_XDP_CONSUMED;
 		break;
 	default:
 		bpf_warn_invalid_xdp_action(act);
 		fallthrough;
 	case XDP_ABORTED:
+out_failure:
 		trace_xdp_exception(rx_ring->netdev, xdp_prog, act);
 		fallthrough; /* handle aborts by dropping packet */
 	case XDP_DROP:

drivers/net/ethernet/intel/ixgbe/ixgbe_xsk.c+8−6

 	if (likely(act == XDP_REDIRECT)) {
 		err = xdp_do_redirect(rx_ring->netdev, xdp, xdp_prog);
-		result = !err ? IXGBE_XDP_REDIR : IXGBE_XDP_CONSUMED;
+		if (err)
+			goto out_failure;
 		rcu_read_unlock();
-		return result;
+		return IXGBE_XDP_REDIR;
 	}
 	switch (act) {
 		break;
 	case XDP_TX:
 		xdpf = xdp_convert_buff_to_frame(xdp);
-		if (unlikely(!xdpf)) {
+		if (unlikely(!xdpf))
-			result = IXGBE_XDP_CONSUMED;
+			goto out_failure;
-			break;
-		}
 		result = ixgbe_xmit_xdp_ring(adapter, xdpf);
+		if (result == IXGBE_XDP_CONSUMED)
+			goto out_failure;
 		break;
 	default:
 		bpf_warn_invalid_xdp_action(act);
 		fallthrough;
 	case XDP_ABORTED:
+out_failure:
 		trace_xdp_exception(rx_ring->netdev, xdp_prog, act);
 		fallthrough; /* handle aborts by dropping packet */
 	case XDP_DROP:

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c+3−0

 	case XDP_TX:
 		xdp_ring = adapter->xdp_ring[rx_ring->queue_index];
 		result = ixgbevf_xmit_xdp_ring(xdp_ring, xdp);
+		if (result == IXGBEVF_XDP_CONSUMED)
+			goto out_failure;
 		break;
 	default:
 		bpf_warn_invalid_xdp_action(act);
 		fallthrough;
 	case XDP_ABORTED:
+out_failure:
 		trace_xdp_exception(rx_ring->netdev, xdp_prog, act);
 		fallthrough; /* handle aborts by dropping packet */
 	case XDP_DROP:

drivers/net/ethernet/mellanox/mlx4/fw.c+3−0

 #define QUERY_DEV_CAP_MAD_DEMUX_OFFSET		0xb0
 #define QUERY_DEV_CAP_DMFS_HIGH_RATE_QPN_BASE_OFFSET	0xa8
 #define QUERY_DEV_CAP_DMFS_HIGH_RATE_QPN_RANGE_OFFSET	0xac
+#define QUERY_DEV_CAP_MAP_CLOCK_TO_USER 0xc1
 #define QUERY_DEV_CAP_QP_RATE_LIMIT_NUM_OFFSET	0xcc
 #define QUERY_DEV_CAP_QP_RATE_LIMIT_MAX_OFFSET	0xd0
 #define QUERY_DEV_CAP_QP_RATE_LIMIT_MIN_OFFSET	0xd2
 	if (mlx4_is_mfunc(dev))
 		disable_unsupported_roce_caps(outbox);
+	MLX4_GET(field, outbox, QUERY_DEV_CAP_MAP_CLOCK_TO_USER);
+	dev_cap->map_clock_to_user = field & 0x80;
 	MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_QP_OFFSET);
 	dev_cap->reserved_qps = 1 << (field & 0xf);
 	MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_QP_OFFSET);

drivers/net/ethernet/mellanox/mlx4/fw.h+1−0

@@ -131,6 +131,7 @@ struct mlx4_dev_cap { · 130 unmodified lines
131	u32 health_buffer_addrs;	131	u32 health_buffer_addrs;
132	struct mlx4_port_cap port_cap[MLX4_MAX_PORTS + 1];	132	struct mlx4_port_cap port_cap[MLX4_MAX_PORTS + 1];
133	bool wol_port[MLX4_MAX_PORTS + 1];	133	bool wol_port[MLX4_MAX_PORTS + 1];
		134	bool map_clock_to_user;
134	};	135	};
135		136
136	struct mlx4_func_cap {	137	struct mlx4_func_cap {

drivers/net/ethernet/mellanox/mlx4/main.c+6−0

 		}
 	}
+	dev->caps.map_clock_to_user  = dev_cap->map_clock_to_user;
 	dev->caps.uar_page_size	     = PAGE_SIZE;
 	dev->caps.num_uars	     = dev_cap->uar_size / PAGE_SIZE;
 	dev->caps.local_ca_ack_delay = dev_cap->local_ca_ack_delay;
 	if (mlx4_is_slave(dev))
 		return -EOPNOTSUPP;
+	if (!dev->caps.map_clock_to_user) {
+		mlx4_dbg(dev, "Map clock to user is not supported.\n");
+		return -EOPNOTSUPP;
+	}
 	if (!params)
 		return -EINVAL;

drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c+10−2

 {
 	struct mlx5e_priv *priv = netdev_priv(netdev);
 	struct mlx5_core_dev *mdev = priv->mdev;
+	unsigned long fec_bitmap;
 	u16 fec_policy = 0;
 	int mode;
 	int err;
-	if (bitmap_weight((unsigned long *)&fecparam->fec,
+	bitmap_from_arr32(&fec_bitmap, &fecparam->fec, sizeof(fecparam->fec) * BITS_PER_BYTE);
-			  ETHTOOL_FEC_LLRS_BIT + 1) > 1)
+	if (bitmap_weight(&fec_bitmap, ETHTOOL_FEC_LLRS_BIT + 1) > 1)
 		return -EOPNOTSUPP;
 	for (mode = 0; mode < ARRAY_SIZE(pplm_fec_2_ethtool); mode++) {
 	if (curr_val == new_val)
 		return 0;
+	if (new_val && !priv->profile->rx_ptp_support &&
+	    priv->tstamp.rx_filter != HWTSTAMP_FILTER_NONE) {
+		netdev_err(priv->netdev,
+			   "Profile doesn't support enabling of CQE compression while hardware time-stamping is enabled.\n");
+		return -EINVAL;
+	}
 	new_params = priv->channels.params;
 	MLX5E_SET_PFLAG(&new_params, MLX5E_PFLAG_RX_CQE_COMPRESS, new_val);
 	if (priv->tstamp.rx_filter != HWTSTAMP_FILTER_NONE)

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+62−15

 			netdev_warn(netdev, "Disabling rxhash, not supported when CQE compress is active\n");
 	}
+	if (mlx5e_is_uplink_rep(priv)) {
+		features &= ~NETIF_F_HW_TLS_RX;
+		if (netdev->features & NETIF_F_HW_TLS_RX)
+			netdev_warn(netdev, "Disabling hw_tls_rx, not supported in switchdev mode\n");
+		features &= ~NETIF_F_HW_TLS_TX;
+		if (netdev->features & NETIF_F_HW_TLS_TX)
+			netdev_warn(netdev, "Disabling hw_tls_tx, not supported in switchdev mode\n");
+	}
 	mutex_unlock(&priv->state_lock);
 	return features;
 	return mlx5e_ptp_rx_manage_fs(priv, set);
 }
-int mlx5e_hwstamp_set(struct mlx5e_priv *priv, struct ifreq *ifr)
+static int mlx5e_hwstamp_config_no_ptp_rx(struct mlx5e_priv *priv, bool rx_filter)
+{
+	bool rx_cqe_compress_def = priv->channels.params.rx_cqe_compress_def;
+	int err;
+	if (!rx_filter)
+		/* Reset CQE compression to Admin default */
+		return mlx5e_modify_rx_cqe_compression_locked(priv, rx_cqe_compress_def);
+	if (!MLX5E_GET_PFLAG(&priv->channels.params, MLX5E_PFLAG_RX_CQE_COMPRESS))
+		return 0;
+	/* Disable CQE compression */
+	netdev_warn(priv->netdev, "Disabling RX cqe compression\n");
+	err = mlx5e_modify_rx_cqe_compression_locked(priv, false);
+	if (err)
+		netdev_err(priv->netdev, "Failed disabling cqe compression err=%d\n", err);
+	return err;
+}
+static int mlx5e_hwstamp_config_ptp_rx(struct mlx5e_priv *priv, bool ptp_rx)
 {
 	struct mlx5e_params new_params;
+	if (ptp_rx == priv->channels.params.ptp_rx)
+		return 0;
+	new_params = priv->channels.params;
+	new_params.ptp_rx = ptp_rx;
+	return mlx5e_safe_switch_params(priv, &new_params, mlx5e_ptp_rx_manage_fs_ctx,
+					&new_params.ptp_rx, true);
+}
+int mlx5e_hwstamp_set(struct mlx5e_priv *priv, struct ifreq *ifr)
+{
 	struct hwtstamp_config config;
 	bool rx_cqe_compress_def;
+	bool ptp_rx;
 	int err;
 	if (!MLX5_CAP_GEN(priv->mdev, device_frequency_khz) ||
 	}
 	mutex_lock(&priv->state_lock);
-	new_params = priv->channels.params;
 	rx_cqe_compress_def = priv->channels.params.rx_cqe_compress_def;
 	/* RX HW timestamp */
 	switch (config.rx_filter) {
 	case HWTSTAMP_FILTER_NONE:
-		new_params.ptp_rx = false;
+		ptp_rx = false;
 		break;
 	case HWTSTAMP_FILTER_ALL:
 	case HWTSTAMP_FILTER_SOME:
 	case HWTSTAMP_FILTER_PTP_V2_SYNC:
 	case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
 	case HWTSTAMP_FILTER_NTP_ALL:
-		new_params.ptp_rx = rx_cqe_compress_def;
 		config.rx_filter = HWTSTAMP_FILTER_ALL;
+		/* ptp_rx is set if both HW TS is set and CQE
+		 * compression is set
+		 */
+		ptp_rx = rx_cqe_compress_def;
 		break;
 	default:
-		mutex_unlock(&priv->state_lock);
+		err = -ERANGE;
-		return -ERANGE;
+		goto err_unlock;
 	}
-	if (new_params.ptp_rx == priv->channels.params.ptp_rx)
+	if (!priv->profile->rx_ptp_support)
-		goto out;
+		err = mlx5e_hwstamp_config_no_ptp_rx(priv,
+						     config.rx_filter != HWTSTAMP_FILTER_NONE);
+	else
+		err = mlx5e_hwstamp_config_ptp_rx(priv, ptp_rx);
+	if (err)
+		goto err_unlock;
-	err = mlx5e_safe_switch_params(priv, &new_params, mlx5e_ptp_rx_manage_fs_ctx,
-				       &new_params.ptp_rx, true);
-	if (err) {
-		mutex_unlock(&priv->state_lock);
-		return err;
-	}
-out:
 	memcpy(&priv->tstamp, &config, sizeof(config));
 	mutex_unlock(&priv->state_lock);
 	return copy_to_user(ifr->ifr_data, &config,
 			    sizeof(config)) ? -EFAULT : 0;
+err_unlock:
+	mutex_unlock(&priv->state_lock);
+	return err;
 }
 int mlx5e_hwstamp_get(struct mlx5e_priv *priv, struct ifreq *ifr)

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c+9−0

 				    misc_parameters_3);
 	struct flow_rule *rule = flow_cls_offload_flow_rule(f);
 	struct flow_dissector *dissector = rule->match.dissector;
+	enum fs_flow_table_type fs_type;
 	u16 addr_type = 0;
 	u8 ip_proto = 0;
 	u8 *match_level;
 	int err;
+	fs_type = mlx5e_is_eswitch_flow(flow) ? FS_FT_FDB : FS_FT_NIC_RX;
 	match_level = outer_match_level;
 	if (dissector->used_keys &
 		if (match.mask->vlan_id ||
 		    match.mask->vlan_priority ||
 		    match.mask->vlan_tpid) {
+			if (!MLX5_CAP_FLOWTABLE_TYPE(priv->mdev, ft_field_support.outer_second_vid,
+						     fs_type)) {
+				NL_SET_ERR_MSG_MOD(extack,
+						   "Matching on CVLAN is not supported");
+				return -EOPNOTSUPP;
+			}
 			if (match.key->vlan_tpid == htons(ETH_P_8021AD)) {
 				MLX5_SET(fte_match_set_misc, misc_c,
 					 outer_second_svlan_tag, 1);

drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c+2−1

 			 struct mlx5_fs_chains *chains,
 			 int i)
 {
-	flow_act->flags |= FLOW_ACT_IGNORE_FLOW_LEVEL;
+	if (mlx5_chains_ignore_flow_level_supported(chains))
+		flow_act->flags |= FLOW_ACT_IGNORE_FLOW_LEVEL;
 	dest[i].type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
 	dest[i].ft = mlx5_chains_get_tc_end_ft(chains);
 }

drivers/net/ethernet/mellanox/mlx5/core/fw_reset.c+3−0

@@ -349,6 +349,9 @@ static void mlx5_sync_reset_abort_event(struct work_struct *work) · 348 unmodified lines
349	reset_abort_work);	349	reset_abort_work);
350	struct mlx5_core_dev *dev = fw_reset->dev;	350	struct mlx5_core_dev *dev = fw_reset->dev;
351		351
		352	if (!test_bit(MLX5_FW_RESET_FLAGS_RESET_REQUESTED, &fw_reset->reset_flags))
		353	return;
		354
352	mlx5_sync_reset_clear_reset_requested(dev, true);	355	mlx5_sync_reset_clear_reset_requested(dev, true);
353	mlx5_core_warn(dev, "PCI Sync FW Update Reset Aborted.\n");	356	mlx5_core_warn(dev, "PCI Sync FW Update Reset Aborted.\n");
354	}	357	}

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c+1−1

@@ -107,7 +107,7 @@ bool mlx5_chains_prios_supported(struct mlx5_fs_chains *chains) · 106 unmodified lines
107	return chains->flags & MLX5_CHAINS_AND_PRIOS_SUPPORTED;	107	return chains->flags & MLX5_CHAINS_AND_PRIOS_SUPPORTED;
108	}	108	}
109		109
110	static bool mlx5_chains_ignore_flow_level_supported(struct mlx5_fs_chains *chains)	110	bool mlx5_chains_ignore_flow_level_supported(struct mlx5_fs_chains *chains)
111	{	111	{
112	return chains->flags & MLX5_CHAINS_IGNORE_FLOW_LEVEL_SUPPORTED;	112	return chains->flags & MLX5_CHAINS_IGNORE_FLOW_LEVEL_SUPPORTED;
113	}	113	}

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.h+5−0

 bool
 mlx5_chains_prios_supported(struct mlx5_fs_chains *chains);
+bool mlx5_chains_ignore_flow_level_supported(struct mlx5_fs_chains *chains);
 bool
 mlx5_chains_backwards_supported(struct mlx5_fs_chains *chains);
 u32
 #else /* CONFIG_MLX5_CLS_ACT */
+static inline bool
+mlx5_chains_ignore_flow_level_supported(struct mlx5_fs_chains *chains)
+{ return false; }
 static inline struct mlx5_flow_table *
 mlx5_chains_get_table(struct mlx5_fs_chains *chains, u32 chain, u32 prio,
 		      u32 level) { return ERR_PTR(-EOPNOTSUPP); }

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_fw.c+2−1

@@ -112,7 +112,8 @@ int mlx5dr_fw_create_md_tbl(struct mlx5dr_domain *dmn, · 111 unmodified lines
112	int ret;	112	int ret;
113		113
114	ft_attr.table_type = MLX5_FLOW_TABLE_TYPE_FDB;	114	ft_attr.table_type = MLX5_FLOW_TABLE_TYPE_FDB;
115	ft_attr.level = dmn->info.caps.max_ft_level - 2;	115	ft_attr.level = min_t(int, dmn->info.caps.max_ft_level - 2,
		116	MLX5_FT_MAX_MULTIPATH_LEVEL);
116	ft_attr.reformat_en = reformat_req;	117	ft_attr.reformat_en = reformat_req;
117	ft_attr.decap_en = reformat_req;	118	ft_attr.decap_en = reformat_req;
118		119

drivers/net/ethernet/myricom/myri10ge/myri10ge.c+1−0

@@ -3815,6 +3815,7 @@ static int myri10ge_probe(struct pci_dev pdev, const struct pci_device_id ent) · 3814 unmodified lines
3815	dev_err(&pdev->dev,	3815	dev_err(&pdev->dev,
3816	"invalid sram_size %dB or board span %ldB\n",	3816	"invalid sram_size %dB or board span %ldB\n",
3817	mgp->sram_size, mgp->board_span);	3817	mgp->sram_size, mgp->board_span);
		3818	status = -EINVAL;
3818	goto abort_with_ioremap;	3819	goto abort_with_ioremap;
3819	}	3820	}
3820	memcpy_fromio(mgp->eeprom_strings,	3821	memcpy_fromio(mgp->eeprom_strings,

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

 	priv->phylink_config.dev = &priv->dev->dev;
 	priv->phylink_config.type = PHYLINK_NETDEV;
 	priv->phylink_config.pcs_poll = true;
-	priv->phylink_config.ovr_an_inband =
+	if (priv->plat->mdio_bus_data)
-		priv->plat->mdio_bus_data->xpcs_an_inband;
+		priv->phylink_config.ovr_an_inband =
+			priv->plat->mdio_bus_data->xpcs_an_inband;
 	if (!fwnode)
 		fwnode = dev_fwnode(priv->device);
 	stmmac_napi_del(ndev);
 error_hw_init:
 	destroy_workqueue(priv->wq);
-	stmmac_bus_clks_config(priv, false);
 	bitmap_free(priv->af_xdp_zc_qps);
 	return ret;

drivers/net/ieee802154/mrf24j40.c+2−2

 #include <linux/spi/spi.h>
 #include <linux/interrupt.h>
+#include <linux/mod_devicetable.h>
 #include <linux/module.h>
-#include <linux/of.h>
 #include <linux/regmap.h>
 #include <linux/ieee802154.h>
 #include <linux/irq.h>
 static struct spi_driver mrf24j40_driver = {
 	.driver = {
-		.of_match_table = of_match_ptr(mrf24j40_of_match),
+		.of_match_table = mrf24j40_of_match,
 		.name = "mrf24j40",
 	},
 	.id_table = mrf24j40_ids,

drivers/net/virtio_net.c+8−12

 	/* If headroom is not 0, there is an offset between the beginning of the
 	 * data and the allocated space, otherwise the data and the allocated
 	 * space are aligned.
+	 *
+	 * Buffers with headroom use PAGE_SIZE as alloc size, see
+	 * add_recvbuf_mergeable() + get_mergeable_buf_len()
 	 */
-	if (headroom) {
+	truesize = headroom ? PAGE_SIZE : truesize;
-		/* Buffers with headroom use PAGE_SIZE as alloc size,
+	tailroom = truesize - len - headroom - (hdr_padded_len - hdr_len);
-		 * see add_recvbuf_mergeable() + get_mergeable_buf_len()
+	buf = p - headroom;
-		 */
-		truesize = PAGE_SIZE;
-		tailroom = truesize - len - offset;
-		buf = page_address(page);
-	} else {
-		tailroom = truesize - len;
-		buf = p;
-	}
 	len -= hdr_len;
 	offset += hdr_padded_len;
 				put_page(page);
 				head_skb = page_to_skb(vi, rq, xdp_page, offset,
 						       len, PAGE_SIZE, false,
-						       metasize, headroom);
+						       metasize,
+						       VIRTIO_XDP_HEADROOM);
 				return head_skb;
 			}
 			break;

drivers/net/wireguard/Makefile+1−2

@@ -1,5 +1,4 @@
1	ccflags-y := -O3	1	ccflags-y := -D'pr_fmt(fmt)=KBUILD_MODNAME ": " fmt'
2	ccflags-y += -D'pr_fmt(fmt)=KBUILD_MODNAME ": " fmt'
3	ccflags-$(CONFIG_WIREGUARD_DEBUG) += -DDEBUG	2	ccflags-$(CONFIG_WIREGUARD_DEBUG) += -DDEBUG
4	wireguard-y := main.o	3	wireguard-y := main.o
5	wireguard-y += noise.o	4	wireguard-y += noise.o

drivers/net/wireguard/allowedips.c+99−90

@@ -6,6 +6,8 @@ · 5 unmodified lines
6	#include "allowedips.h"	6	#include "allowedips.h"
7	#include "peer.h"	7	#include "peer.h"
8		8
		9	static struct kmem_cache *node_cache;
		10
9	static void swap_endian(u8 dst, const u8 src, u8 bits)	11	static void swap_endian(u8 dst, const u8 src, u8 bits)
10	{	12	{
11	if (bits == 32) {	13	if (bits == 32) {
@@ -28,8 +30,11 @@ static void copy_and_assign_cidr(struct allowedips_node node, const u8 src, · 16 unmodified lines
28	node->bitlen = bits;	30	node->bitlen = bits;
29	memcpy(node->bits, src, bits / 8U);	31	memcpy(node->bits, src, bits / 8U);
30	}	32	}
31	#define CHOOSE_NODE(parent, key) \	33
32	parent->bit[(key[parent->bit_at_a] >> parent->bit_at_b) & 1]	34	static inline u8 choose(struct allowedips_node node, const u8 key)
		35	{
		36	return (key[node->bit_at_a] >> node->bit_at_b) & 1;
		37	}
33		38
34	static void push_rcu(struct allowedips_node **stack,	39	static void push_rcu(struct allowedips_node **stack,
35	struct allowedips_node __rcu p, unsigned int len)	40	struct allowedips_node __rcu p, unsigned int len)
@@ -40,6 +45,11 @@ static void push_rcu(struct allowedips_node **stack, · 4 unmodified lines
40	}	45	}
41	}	46	}
42		47
		48	static void node_free_rcu(struct rcu_head *rcu)
		49	{
		50	kmem_cache_free(node_cache, container_of(rcu, struct allowedips_node, rcu));
		51	}
		52
43	static void root_free_rcu(struct rcu_head *rcu)	53	static void root_free_rcu(struct rcu_head *rcu)
44	{	54	{
45	struct allowedips_node node, stack[128] = {	55	struct allowedips_node node, stack[128] = {
@@ -49,7 +59,7 @@ static void root_free_rcu(struct rcu_head *rcu) · 3 unmodified lines
49	while (len > 0 && (node = stack[--len])) {	59	while (len > 0 && (node = stack[--len])) {
50	push_rcu(stack, node->bit[0], &len);	60	push_rcu(stack, node->bit[0], &len);
51	push_rcu(stack, node->bit[1], &len);	61	push_rcu(stack, node->bit[1], &len);
52	kfree(node);	62	kmem_cache_free(node_cache, node);
53	}	63	}
54	}	64	}
55		65
@@ -66,60 +76,6 @@ static void root_remove_peer_lists(struct allowedips_node *root) · 10 unmodified lines
66	}	76	}
67	}	77	}
68		78
69	static void walk_remove_by_peer(struct allowedips_node __rcu **top,
70	struct wg_peer peer, struct mutex lock)
71	{
72	#define REF(p) rcu_access_pointer(p)
73	#define DEREF(p) rcu_dereference_protected(*(p), lockdep_is_held(lock))
74	#define PUSH(p) ({ \
75	WARN_ON(IS_ENABLED(DEBUG) && len >= 128); \
76	stack[len++] = p; \
77	})
78
79	struct allowedips_node __rcu stack[128], nptr;
80	struct allowedips_node node, prev;
81	unsigned int len;
82
83	if (unlikely(!peer \|\| !REF(*top)))
84	return;
85
86	for (prev = NULL, len = 0, PUSH(top); len > 0; prev = node) {
87	nptr = stack[len - 1];
88	node = DEREF(nptr);
89	if (!node) {
90	--len;
91	continue;
92	}
93	if (!prev \|\| REF(prev->bit[0]) == node \|\|
94	REF(prev->bit[1]) == node) {
95	if (REF(node->bit[0]))
96	PUSH(&node->bit[0]);
97	else if (REF(node->bit[1]))
98	PUSH(&node->bit[1]);
99	} else if (REF(node->bit[0]) == prev) {
100	if (REF(node->bit[1]))
101	PUSH(&node->bit[1]);
102	} else {
103	if (rcu_dereference_protected(node->peer,
104	lockdep_is_held(lock)) == peer) {
105	RCU_INIT_POINTER(node->peer, NULL);
106	list_del_init(&node->peer_list);
107	if (!node->bit[0] \|\| !node->bit[1]) {
108	rcu_assign_pointer(*nptr, DEREF(
109	&node->bit[!REF(node->bit[0])]));
110	kfree_rcu(node, rcu);
111	node = DEREF(nptr);
112	}
113	}
114	--len;
115	}
116	}
117
118	#undef REF
119	#undef DEREF
120	#undef PUSH
121	}
122
123	static unsigned int fls128(u64 a, u64 b)	79	static unsigned int fls128(u64 a, u64 b)
124	{	80	{
125	return a ? fls64(a) + 64U : fls64(b);	81	return a ? fls64(a) + 64U : fls64(b);
@@ -159,7 +115,7 @@ static struct allowedips_node find_node(struct allowedips_node trie, u8 bits, · 33 unmodified lines
159	found = node;	115	found = node;
160	if (node->cidr == bits)	116	if (node->cidr == bits)
161	break;	117	break;
162	node = rcu_dereference_bh(CHOOSE_NODE(node, key));	118	node = rcu_dereference_bh(node->bit[choose(node, key)]);
163	}	119	}
164	return found;	120	return found;
165	}	121	}
@@ -191,8 +147,7 @@ static bool node_placement(struct allowedips_node __rcu trie, const u8 key, · 25 unmodified lines
191	u8 cidr, u8 bits, struct allowedips_node **rnode,	147	u8 cidr, u8 bits, struct allowedips_node **rnode,
192	struct mutex *lock)	148	struct mutex *lock)
193	{	149	{
194	struct allowedips_node *node = rcu_dereference_protected(trie,	150	struct allowedips_node *node = rcu_dereference_protected(trie, lockdep_is_held(lock));
195	lockdep_is_held(lock));
196	struct allowedips_node *parent = NULL;	151	struct allowedips_node *parent = NULL;
197	bool exact = false;	152	bool exact = false;
198		153
@@ -202,13 +157,24 @@ static bool node_placement(struct allowedips_node __rcu trie, const u8 key, · 3 unmodified lines
202	exact = true;	157	exact = true;
203	break;	158	break;
204	}	159	}
205	node = rcu_dereference_protected(CHOOSE_NODE(parent, key),	160	node = rcu_dereference_protected(parent->bit[choose(parent, key)], lockdep_is_held(lock));
206	lockdep_is_held(lock));
207	}	161	}
208	*rnode = parent;	162	*rnode = parent;
209	return exact;	163	return exact;
210	}	164	}
211		165
		166	static inline void connect_node(struct allowedips_node *parent, u8 bit, struct allowedips_node node)
		167	{
		168	node->parent_bit_packed = (unsigned long)parent \| bit;
		169	rcu_assign_pointer(*parent, node);
		170	}
		171
		172	static inline void choose_and_connect_node(struct allowedips_node parent, struct allowedips_node node)
		173	{
		174	u8 bit = choose(parent, node->bits);
		175	connect_node(&parent->bit[bit], bit, node);
		176	}
		177
212	static int add(struct allowedips_node __rcu *trie, u8 bits, const u8 key,	178	static int add(struct allowedips_node __rcu *trie, u8 bits, const u8 key,
213	u8 cidr, struct wg_peer peer, struct mutex lock)	179	u8 cidr, struct wg_peer peer, struct mutex lock)
214	{	180	{
@@ -218,13 +184,13 @@ static int add(struct allowedips_node __rcu *trie, u8 bits, const u8 key, · 3 unmodified lines
218	return -EINVAL;	184	return -EINVAL;
219		185
220	if (!rcu_access_pointer(*trie)) {	186	if (!rcu_access_pointer(*trie)) {
221	node = kzalloc(sizeof(*node), GFP_KERNEL);	187	node = kmem_cache_zalloc(node_cache, GFP_KERNEL);
222	if (unlikely(!node))	188	if (unlikely(!node))
223	return -ENOMEM;	189	return -ENOMEM;
224	RCU_INIT_POINTER(node->peer, peer);	190	RCU_INIT_POINTER(node->peer, peer);
225	list_add_tail(&node->peer_list, &peer->allowedips_list);	191	list_add_tail(&node->peer_list, &peer->allowedips_list);
226	copy_and_assign_cidr(node, key, cidr, bits);	192	copy_and_assign_cidr(node, key, cidr, bits);
227	rcu_assign_pointer(*trie, node);	193	connect_node(trie, 2, node);
228	return 0;	194	return 0;
229	}	195	}
230	if (node_placement(*trie, key, cidr, bits, &node, lock)) {	196	if (node_placement(*trie, key, cidr, bits, &node, lock)) {
@@ -233,7 +199,7 @@ static int add(struct allowedips_node __rcu *trie, u8 bits, const u8 key, · 2 unmodified lines
233	return 0;	199	return 0;
234	}	200	}
235		201
236	newnode = kzalloc(sizeof(*newnode), GFP_KERNEL);	202	newnode = kmem_cache_zalloc(node_cache, GFP_KERNEL);
237	if (unlikely(!newnode))	203	if (unlikely(!newnode))
238	return -ENOMEM;	204	return -ENOMEM;
239	RCU_INIT_POINTER(newnode->peer, peer);	205	RCU_INIT_POINTER(newnode->peer, peer);
@@ -243,10 +209,10 @@ static int add(struct allowedips_node __rcu *trie, u8 bits, const u8 key, · 3 unmodified lines
243	if (!node) {	209	if (!node) {
244	down = rcu_dereference_protected(*trie, lockdep_is_held(lock));	210	down = rcu_dereference_protected(*trie, lockdep_is_held(lock));
245	} else {	211	} else {
246	down = rcu_dereference_protected(CHOOSE_NODE(node, key),	212	const u8 bit = choose(node, key);
247	lockdep_is_held(lock));	213	down = rcu_dereference_protected(node->bit[bit], lockdep_is_held(lock));
248	if (!down) {	214	if (!down) {
249	rcu_assign_pointer(CHOOSE_NODE(node, key), newnode);	215	connect_node(&node->bit[bit], bit, newnode);
250	return 0;	216	return 0;
251	}	217	}
252	}	218	}
@@ -254,30 +220,29 @@ static int add(struct allowedips_node __rcu *trie, u8 bits, const u8 key, · 1 unmodified line
254	parent = node;	220	parent = node;
255		221
256	if (newnode->cidr == cidr) {	222	if (newnode->cidr == cidr) {
257	rcu_assign_pointer(CHOOSE_NODE(newnode, down->bits), down);	223	choose_and_connect_node(newnode, down);
258	if (!parent)	224	if (!parent)
259	rcu_assign_pointer(*trie, newnode);	225	connect_node(trie, 2, newnode);
260	else	226	else
261	rcu_assign_pointer(CHOOSE_NODE(parent, newnode->bits),	227	choose_and_connect_node(parent, newnode);
262	newnode);	228	return 0;
263	} else {	229	}
264	node = kzalloc(sizeof(*node), GFP_KERNEL);
265	if (unlikely(!node)) {
266	list_del(&newnode->peer_list);
267	kfree(newnode);
268	return -ENOMEM;
269	}
270	INIT_LIST_HEAD(&node->peer_list);
271	copy_and_assign_cidr(node, newnode->bits, cidr, bits);
272		230
273	rcu_assign_pointer(CHOOSE_NODE(node, down->bits), down);	231	node = kmem_cache_zalloc(node_cache, GFP_KERNEL);
274	rcu_assign_pointer(CHOOSE_NODE(node, newnode->bits), newnode);	232	if (unlikely(!node)) {
275	if (!parent)	233	list_del(&newnode->peer_list);
276	rcu_assign_pointer(*trie, node);	234	kmem_cache_free(node_cache, newnode);
277	else	235	return -ENOMEM;
278	rcu_assign_pointer(CHOOSE_NODE(parent, node->bits),
279	node);
280	}	236	}
		237	INIT_LIST_HEAD(&node->peer_list);
		238	copy_and_assign_cidr(node, newnode->bits, cidr, bits);
		239
		240	choose_and_connect_node(node, down);
		241	choose_and_connect_node(node, newnode);
		242	if (!parent)
		243	connect_node(trie, 2, node);
		244	else
		245	choose_and_connect_node(parent, node);
281	return 0;	246	return 0;
282	}	247	}
283		248
@@ -335,9 +300,41 @@ int wg_allowedips_insert_v6(struct allowedips table, const struct in6_addr ip, · 51 unmodified lines
335	void wg_allowedips_remove_by_peer(struct allowedips *table,	300	void wg_allowedips_remove_by_peer(struct allowedips *table,
336	struct wg_peer peer, struct mutex lock)	301	struct wg_peer peer, struct mutex lock)
337	{	302	{
		303	struct allowedips_node node, child, *parent_bit, parent, *tmp;
		304	bool free_parent;
		305
		306	if (list_empty(&peer->allowedips_list))
		307	return;
338	++table->seq;	308	++table->seq;
339	walk_remove_by_peer(&table->root4, peer, lock);	309	list_for_each_entry_safe(node, tmp, &peer->allowedips_list, peer_list) {
340	walk_remove_by_peer(&table->root6, peer, lock);	310	list_del_init(&node->peer_list);
		311	RCU_INIT_POINTER(node->peer, NULL);
		312	if (node->bit[0] && node->bit[1])
		313	continue;
		314	child = rcu_dereference_protected(node->bit[!rcu_access_pointer(node->bit[0])],
		315	lockdep_is_held(lock));
		316	if (child)
		317	child->parent_bit_packed = node->parent_bit_packed;
		318	parent_bit = (struct allowedips_node **)(node->parent_bit_packed & ~3UL);
		319	*parent_bit = child;
		320	parent = (void *)parent_bit -
		321	offsetof(struct allowedips_node, bit[node->parent_bit_packed & 1]);
		322	free_parent = !rcu_access_pointer(node->bit[0]) &&
		323	!rcu_access_pointer(node->bit[1]) &&
		324	(node->parent_bit_packed & 3) <= 1 &&
		325	!rcu_access_pointer(parent->peer);
		326	if (free_parent)
		327	child = rcu_dereference_protected(
		328	parent->bit[!(node->parent_bit_packed & 1)],
		329	lockdep_is_held(lock));
		330	call_rcu(&node->rcu, node_free_rcu);
		331	if (!free_parent)
		332	continue;
		333	if (child)
		334	child->parent_bit_packed = parent->parent_bit_packed;
		335	(struct allowedips_node *)(parent->parent_bit_packed & ~3UL) = child;
		336	call_rcu(&parent->rcu, node_free_rcu);
		337	}
341	}	338	}
342		339
343	int wg_allowedips_read_node(struct allowedips_node node, u8 ip[16], u8 cidr)	340	int wg_allowedips_read_node(struct allowedips_node node, u8 ip[16], u8 cidr)
@@ -374,4 +371,16 @@ struct wg_peer wg_allowedips_lookup_src(struct allowedips table, · 30 unmodified lines
374	return NULL;	371	return NULL;
375	}	372	}
376		373
		374	int __init wg_allowedips_slab_init(void)
		375	{
		376	node_cache = KMEM_CACHE(allowedips_node, 0);
		377	return node_cache ? 0 : -ENOMEM;
		378	}
		379
		380	void wg_allowedips_slab_uninit(void)
		381	{
		382	rcu_barrier();
		383	kmem_cache_destroy(node_cache);
		384	}
		385
377	#include "selftest/allowedips.c"	386	#include "selftest/allowedips.c"

drivers/net/wireguard/allowedips.h+7−7

 struct allowedips_node {
 	struct wg_peer __rcu *peer;
 	struct allowedips_node __rcu *bit[2];
-	/* While it may seem scandalous that we waste space for v4,
-	 * we're alloc'ing to the nearest power of 2 anyway, so this
-	 * doesn't actually make a difference.
-	 */
-	u8 bits[16] __aligned(__alignof(u64));
 	u8 cidr, bit_at_a, bit_at_b, bitlen;
+	u8 bits[16] __aligned(__alignof(u64));
-	/* Keep rarely used list at bottom to be beyond cache line. */
+	/* Keep rarely used members at bottom to be beyond cache line. */
+	unsigned long parent_bit_packed;
 	union {
 		struct list_head peer_list;
 		struct rcu_head rcu;
 	struct allowedips_node __rcu *root4;
 	struct allowedips_node __rcu *root6;
 	u64 seq;
-};
+} __aligned(4); /* We pack the lower 2 bits of &root, but m68k only gives 16-bit alignment. */
 void wg_allowedips_init(struct allowedips *table);
 void wg_allowedips_free(struct allowedips *table, struct mutex *mutex);
 bool wg_allowedips_selftest(void);
 #endif
+int wg_allowedips_slab_init(void);
+void wg_allowedips_slab_uninit(void);
 #endif /* _WG_ALLOWEDIPS_H */

drivers/net/wireguard/main.c+16−1

 {
 	int ret;
+	ret = wg_allowedips_slab_init();
+	if (ret < 0)
+		goto err_allowedips;
 #ifdef DEBUG
+	ret = -ENOTRECOVERABLE;
 	if (!wg_allowedips_selftest() || !wg_packet_counter_selftest() ||
 	    !wg_ratelimiter_selftest())
-		return -ENOTRECOVERABLE;
+		goto err_peer;
 #endif
 	wg_noise_init();
+	ret = wg_peer_init();
+	if (ret < 0)
+		goto err_peer;
 	ret = wg_device_init();
 	if (ret < 0)
 		goto err_device;
 err_netlink:
 	wg_device_uninit();
 err_device:
+	wg_peer_uninit();
+err_peer:
+	wg_allowedips_slab_uninit();
+err_allowedips:
 	return ret;
 }
 {
 	wg_genetlink_uninit();
 	wg_device_uninit();
+	wg_peer_uninit();
+	wg_allowedips_slab_uninit();
 }
 module_init(mod_init);

drivers/net/wireguard/peer.c+20−7

 #include <linux/rcupdate.h>
 #include <linux/list.h>
+static struct kmem_cache *peer_cache;
 static atomic64_t peer_counter = ATOMIC64_INIT(0);
 struct wg_peer *wg_peer_create(struct wg_device *wg,
 	if (wg->num_peers >= MAX_PEERS_PER_DEVICE)
 		return ERR_PTR(ret);
-	peer = kzalloc(sizeof(*peer), GFP_KERNEL);
+	peer = kmem_cache_zalloc(peer_cache, GFP_KERNEL);
 	if (unlikely(!peer))
 		return ERR_PTR(ret);
-	if (dst_cache_init(&peer->endpoint_cache, GFP_KERNEL))
+	if (unlikely(dst_cache_init(&peer->endpoint_cache, GFP_KERNEL)))
 		goto err;
 	peer->device = wg;
 	return peer;
 err:
-	kfree(peer);
+	kmem_cache_free(peer_cache, peer);
 	return ERR_PTR(ret);
 }
 	/* Mark as dead, so that we don't allow jumping contexts after. */
 	WRITE_ONCE(peer->is_dead, true);
-	/* The caller must now synchronize_rcu() for this to take effect. */
+	/* The caller must now synchronize_net() for this to take effect. */
 }
 static void peer_remove_after_dead(struct wg_peer *peer)
 	lockdep_assert_held(&peer->device->device_update_lock);
 	peer_make_dead(peer);
-	synchronize_rcu();
+	synchronize_net();
 	peer_remove_after_dead(peer);
 }
 		peer_make_dead(peer);
 		list_add_tail(&peer->peer_list, &dead_peers);
 	}
-	synchronize_rcu();
+	synchronize_net();
 	list_for_each_entry_safe(peer, temp, &dead_peers, peer_list)
 		peer_remove_after_dead(peer);
 }
 	/* The final zeroing takes care of clearing any remaining handshake key
 	 * material and other potentially sensitive information.
 	 */
-	kfree_sensitive(peer);
+	memzero_explicit(peer, sizeof(*peer));
+	kmem_cache_free(peer_cache, peer);
 }
 static void kref_release(struct kref *refcount)
 		return;
 	kref_put(&peer->refcount, kref_release);
 }
+int __init wg_peer_init(void)
+{
+	peer_cache = KMEM_CACHE(wg_peer, 0);
+	return peer_cache ? 0 : -ENOMEM;
+}
+void wg_peer_uninit(void)
+{
+	kmem_cache_destroy(peer_cache);
+}

drivers/net/wireguard/peer.h+3−0

@@ -80,4 +80,7 @@ void wg_peer_put(struct wg_peer *peer); · 79 unmodified lines
80	void wg_peer_remove(struct wg_peer *peer);	80	void wg_peer_remove(struct wg_peer *peer);
81	void wg_peer_remove_all(struct wg_device *wg);	81	void wg_peer_remove_all(struct wg_device *wg);
82		82
		83	int wg_peer_init(void);
		84	void wg_peer_uninit(void);
		85
83	#endif /* _WG_PEER_H */	86	#endif /* _WG_PEER_H */

drivers/net/wireguard/selftest/allowedips.c+79−86

@@ -19,32 +19,22 @@ · 18 unmodified lines
19		19
20	#include <linux/siphash.h>	20	#include <linux/siphash.h>
21		21
22	static __init void swap_endian_and_apply_cidr(u8 dst, const u8 src, u8 bits,
23	u8 cidr)
24	{
25	swap_endian(dst, src, bits);
26	memset(dst + (cidr + 7) / 8, 0, bits / 8 - (cidr + 7) / 8);
27	if (cidr)
28	dst[(cidr + 7) / 8 - 1] &= ~0U << ((8 - (cidr % 8)) % 8);
29	}
30
31	static __init void print_node(struct allowedips_node *node, u8 bits)	22	static __init void print_node(struct allowedips_node *node, u8 bits)
32	{	23	{
33	char *fmt_connection = KERN_DEBUG "\t\"%p/%d\" -> \"%p/%d\";\n";	24	char *fmt_connection = KERN_DEBUG "\t\"%p/%d\" -> \"%p/%d\";\n";
34	char *fmt_declaration = KERN_DEBUG	25	char *fmt_declaration = KERN_DEBUG "\t\"%p/%d\"[style=%s, color=\"#%06x\"];\n";
35	"\t\"%p/%d\"[style=%s, color=\"#%06x\"];\n";	26	u8 ip1[16], ip2[16], cidr1, cidr2;
36	char *style = "dotted";	27	char *style = "dotted";
37	u8 ip1[16], ip2[16];
38	u32 color = 0;	28	u32 color = 0;
39		29
		30	if (node == NULL)
		31	return;
40	if (bits == 32) {	32	if (bits == 32) {
41	fmt_connection = KERN_DEBUG "\t\"%pI4/%d\" -> \"%pI4/%d\";\n";	33	fmt_connection = KERN_DEBUG "\t\"%pI4/%d\" -> \"%pI4/%d\";\n";
42	fmt_declaration = KERN_DEBUG	34	fmt_declaration = KERN_DEBUG "\t\"%pI4/%d\"[style=%s, color=\"#%06x\"];\n";
43	"\t\"%pI4/%d\"[style=%s, color=\"#%06x\"];\n";
44	} else if (bits == 128) {	35	} else if (bits == 128) {
45	fmt_connection = KERN_DEBUG "\t\"%pI6/%d\" -> \"%pI6/%d\";\n";	36	fmt_connection = KERN_DEBUG "\t\"%pI6/%d\" -> \"%pI6/%d\";\n";
46	fmt_declaration = KERN_DEBUG	37	fmt_declaration = KERN_DEBUG "\t\"%pI6/%d\"[style=%s, color=\"#%06x\"];\n";
47	"\t\"%pI6/%d\"[style=%s, color=\"#%06x\"];\n";
48	}	38	}
49	if (node->peer) {	39	if (node->peer) {
50	hsiphash_key_t key = { { 0 } };	40	hsiphash_key_t key = { { 0 } };
@@ -55,24 +45,20 @@ static __init void print_node(struct allowedips_node *node, u8 bits) · 4 unmodified lines
55	hsiphash_1u32(0xabad1dea, &key) % 200;	45	hsiphash_1u32(0xabad1dea, &key) % 200;
56	style = "bold";	46	style = "bold";
57	}	47	}
58	swap_endian_and_apply_cidr(ip1, node->bits, bits, node->cidr);	48	wg_allowedips_read_node(node, ip1, &cidr1);
59	printk(fmt_declaration, ip1, node->cidr, style, color);	49	printk(fmt_declaration, ip1, cidr1, style, color);
60	if (node->bit[0]) {	50	if (node->bit[0]) {
61	swap_endian_and_apply_cidr(ip2,	51	wg_allowedips_read_node(rcu_dereference_raw(node->bit[0]), ip2, &cidr2);
62	rcu_dereference_raw(node->bit[0])->bits, bits,	52	printk(fmt_connection, ip1, cidr1, ip2, cidr2);
63	node->cidr);
64	printk(fmt_connection, ip1, node->cidr, ip2,
65	rcu_dereference_raw(node->bit[0])->cidr);
66	print_node(rcu_dereference_raw(node->bit[0]), bits);
67	}	53	}
68	if (node->bit[1]) {	54	if (node->bit[1]) {
69	swap_endian_and_apply_cidr(ip2,	55	wg_allowedips_read_node(rcu_dereference_raw(node->bit[1]), ip2, &cidr2);
70	rcu_dereference_raw(node->bit[1])->bits,	56	printk(fmt_connection, ip1, cidr1, ip2, cidr2);
71	bits, node->cidr);
72	printk(fmt_connection, ip1, node->cidr, ip2,
73	rcu_dereference_raw(node->bit[1])->cidr);
74	print_node(rcu_dereference_raw(node->bit[1]), bits);
75	}	57	}
		58	if (node->bit[0])
		59	print_node(rcu_dereference_raw(node->bit[0]), bits);
		60	if (node->bit[1])
		61	print_node(rcu_dereference_raw(node->bit[1]), bits);
76	}	62	}
77		63
78	static __init void print_tree(struct allowedips_node __rcu *top, u8 bits)	64	static __init void print_tree(struct allowedips_node __rcu *top, u8 bits)
@@ -121,8 +107,8 @@ static __init inline union nf_inet_addr horrible_cidr_to_mask(u8 cidr) · 42 unmodified lines
121	{	107	{
122	union nf_inet_addr mask;	108	union nf_inet_addr mask;
123		109
124	memset(&mask, 0x00, 128 / 8);	110	memset(&mask, 0, sizeof(mask));
125	memset(&mask, 0xff, cidr / 8);	111	memset(&mask.all, 0xff, cidr / 8);
126	if (cidr % 32)	112	if (cidr % 32)
127	mask.all[cidr / 32] = (__force u32)htonl(	113	mask.all[cidr / 32] = (__force u32)htonl(
128	(0xFFFFFFFFUL << (32 - (cidr % 32))) & 0xFFFFFFFFUL);	114	(0xFFFFFFFFUL << (32 - (cidr % 32))) & 0xFFFFFFFFUL);
@@ -149,42 +135,36 @@ horrible_mask_self(struct horrible_allowedips_node *node) · 20 unmodified lines
149	}	135	}
150		136
151	static __init inline bool	137	static __init inline bool
152	horrible_match_v4(const struct horrible_allowedips_node *node,	138	horrible_match_v4(const struct horrible_allowedips_node node, struct in_addr ip)
153	struct in_addr *ip)
154	{	139	{
155	return (ip->s_addr & node->mask.ip) == node->ip.ip;	140	return (ip->s_addr & node->mask.ip) == node->ip.ip;
156	}	141	}
157		142
158	static __init inline bool	143	static __init inline bool
159	horrible_match_v6(const struct horrible_allowedips_node *node,	144	horrible_match_v6(const struct horrible_allowedips_node node, struct in6_addr ip)
160	struct in6_addr *ip)
161	{	145	{
162	return (ip->in6_u.u6_addr32[0] & node->mask.ip6[0]) ==	146	return (ip->in6_u.u6_addr32[0] & node->mask.ip6[0]) == node->ip.ip6[0] &&
163	node->ip.ip6[0] &&	147	(ip->in6_u.u6_addr32[1] & node->mask.ip6[1]) == node->ip.ip6[1] &&
164	(ip->in6_u.u6_addr32[1] & node->mask.ip6[1]) ==	148	(ip->in6_u.u6_addr32[2] & node->mask.ip6[2]) == node->ip.ip6[2] &&
165	node->ip.ip6[1] &&
166	(ip->in6_u.u6_addr32[2] & node->mask.ip6[2]) ==
167	node->ip.ip6[2] &&
168	(ip->in6_u.u6_addr32[3] & node->mask.ip6[3]) == node->ip.ip6[3];	149	(ip->in6_u.u6_addr32[3] & node->mask.ip6[3]) == node->ip.ip6[3];
169	}	150	}
170		151
171	static __init void	152	static __init void
172	horrible_insert_ordered(struct horrible_allowedips *table,	153	horrible_insert_ordered(struct horrible_allowedips table, struct horrible_allowedips_node node)
173	struct horrible_allowedips_node *node)
174	{	154	{
175	struct horrible_allowedips_node other = NULL, where = NULL;	155	struct horrible_allowedips_node other = NULL, where = NULL;
176	u8 my_cidr = horrible_mask_to_cidr(node->mask);	156	u8 my_cidr = horrible_mask_to_cidr(node->mask);
177		157
178	hlist_for_each_entry(other, &table->head, table) {	158	hlist_for_each_entry(other, &table->head, table) {
179	if (!memcmp(&other->mask, &node->mask,	159	if (other->ip_version == node->ip_version &&
180	sizeof(union nf_inet_addr)) &&	160	!memcmp(&other->mask, &node->mask, sizeof(union nf_inet_addr)) &&
181	!memcmp(&other->ip, &node->ip,	161	!memcmp(&other->ip, &node->ip, sizeof(union nf_inet_addr))) {
182	sizeof(union nf_inet_addr)) &&
183	other->ip_version == node->ip_version) {
184	other->value = node->value;	162	other->value = node->value;
185	kfree(node);	163	kfree(node);
186	return;	164	return;
187	}	165	}
		166	}
		167	hlist_for_each_entry(other, &table->head, table) {
188	where = other;	168	where = other;
189	if (horrible_mask_to_cidr(other->mask) <= my_cidr)	169	if (horrible_mask_to_cidr(other->mask) <= my_cidr)
190	break;	170	break;
@@ -201,8 +181,7 @@ static __init int · 10 unmodified lines
201	horrible_allowedips_insert_v4(struct horrible_allowedips *table,	181	horrible_allowedips_insert_v4(struct horrible_allowedips *table,
202	struct in_addr ip, u8 cidr, void value)	182	struct in_addr ip, u8 cidr, void value)
203	{	183	{
204	struct horrible_allowedips_node node = kzalloc(sizeof(node),	184	struct horrible_allowedips_node node = kzalloc(sizeof(node), GFP_KERNEL);
205	GFP_KERNEL);
206		185
207	if (unlikely(!node))	186	if (unlikely(!node))
208	return -ENOMEM;	187	return -ENOMEM;
@@ -219,8 +198,7 @@ static __init int · 10 unmodified lines
219	horrible_allowedips_insert_v6(struct horrible_allowedips *table,	198	horrible_allowedips_insert_v6(struct horrible_allowedips *table,
220	struct in6_addr ip, u8 cidr, void value)	199	struct in6_addr ip, u8 cidr, void value)
221	{	200	{
222	struct horrible_allowedips_node node = kzalloc(sizeof(node),	201	struct horrible_allowedips_node node = kzalloc(sizeof(node), GFP_KERNEL);
223	GFP_KERNEL);
224		202
225	if (unlikely(!node))	203	if (unlikely(!node))
226	return -ENOMEM;	204	return -ENOMEM;
@@ -234,39 +212,43 @@ horrible_allowedips_insert_v6(struct horrible_allowedips *table, · 7 unmodified lines
234	}	212	}
235		213
236	static __init void *	214	static __init void *
237	horrible_allowedips_lookup_v4(struct horrible_allowedips *table,	215	horrible_allowedips_lookup_v4(struct horrible_allowedips table, struct in_addr ip)
238	struct in_addr *ip)
239	{	216	{
240	struct horrible_allowedips_node *node;	217	struct horrible_allowedips_node *node;
241	void *ret = NULL;
242		218
243	hlist_for_each_entry(node, &table->head, table) {	219	hlist_for_each_entry(node, &table->head, table) {
244	if (node->ip_version != 4)	220	if (node->ip_version == 4 && horrible_match_v4(node, ip))
245	continue;	221	return node->value;
246	if (horrible_match_v4(node, ip)) {
247	ret = node->value;
248	break;
249	}
250	}	222	}
251	return ret;	223	return NULL;
252	}	224	}
253		225
254	static __init void *	226	static __init void *
255	horrible_allowedips_lookup_v6(struct horrible_allowedips *table,	227	horrible_allowedips_lookup_v6(struct horrible_allowedips table, struct in6_addr ip)
256	struct in6_addr *ip)
257	{	228	{
258	struct horrible_allowedips_node *node;	229	struct horrible_allowedips_node *node;
259	void *ret = NULL;
260		230
261	hlist_for_each_entry(node, &table->head, table) {	231	hlist_for_each_entry(node, &table->head, table) {
262	if (node->ip_version != 6)	232	if (node->ip_version == 6 && horrible_match_v6(node, ip))
		233	return node->value;
		234	}
		235	return NULL;
		236	}
		237
		238
		239	static __init void
		240	horrible_allowedips_remove_by_value(struct horrible_allowedips table, void value)
		241	{
		242	struct horrible_allowedips_node *node;
		243	struct hlist_node *h;
		244
		245	hlist_for_each_entry_safe(node, h, &table->head, table) {
		246	if (node->value != value)
263	continue;	247	continue;
264	if (horrible_match_v6(node, ip)) {	248	hlist_del(&node->table);
265	ret = node->value;	249	kfree(node);
266	break;
267	}
268	}	250	}
269	return ret;	251
270	}	252	}
271		253
272	static __init bool randomized_test(void)	254	static __init bool randomized_test(void)
@@ -296,6 +278,7 @@ static __init bool randomized_test(void) · 23 unmodified lines
296	goto free;	278	goto free;
297	}	279	}
298	kref_init(&peers[i]->refcount);	280	kref_init(&peers[i]->refcount);
		281	INIT_LIST_HEAD(&peers[i]->allowedips_list);
299	}	282	}
300		283
301	mutex_lock(&mutex);	284	mutex_lock(&mutex);
@@ -333,7 +316,7 @@ static __init bool randomized_test(void) · 31 unmodified lines
333	if (wg_allowedips_insert_v4(&t,	316	if (wg_allowedips_insert_v4(&t,
334	(struct in_addr *)mutated,	317	(struct in_addr *)mutated,
335	cidr, peer, &mutex) < 0) {	318	cidr, peer, &mutex) < 0) {
336	pr_err("allowedips random malloc: FAIL\n");	319	pr_err("allowedips random self-test malloc: FAIL\n");
337	goto free_locked;	320	goto free_locked;
338	}	321	}
339	if (horrible_allowedips_insert_v4(&h,	322	if (horrible_allowedips_insert_v4(&h,
@@ -396,23 +379,33 @@ static __init bool randomized_test(void) · 56 unmodified lines
396	print_tree(t.root6, 128);	379	print_tree(t.root6, 128);
397	}	380	}
398		381
399	for (i = 0; i < NUM_QUERIES; ++i) {	382	for (j = 0;; ++j) {
400	prandom_bytes(ip, 4);	383	for (i = 0; i < NUM_QUERIES; ++i) {
401	if (lookup(t.root4, 32, ip) !=	384	prandom_bytes(ip, 4);
402	horrible_allowedips_lookup_v4(&h, (struct in_addr *)ip)) {	385	if (lookup(t.root4, 32, ip) != horrible_allowedips_lookup_v4(&h, (struct in_addr *)ip)) {
403	pr_err("allowedips random self-test: FAIL\n");	386	horrible_allowedips_lookup_v4(&h, (struct in_addr *)ip);
404	goto free;	387	pr_err("allowedips random v4 self-test: FAIL\n");
		388	goto free;
		389	}
		390	prandom_bytes(ip, 16);
		391	if (lookup(t.root6, 128, ip) != horrible_allowedips_lookup_v6(&h, (struct in6_addr *)ip)) {
		392	pr_err("allowedips random v6 self-test: FAIL\n");
		393	goto free;
		394	}
405	}	395	}
		396	if (j >= NUM_PEERS)
		397	break;
		398	mutex_lock(&mutex);
		399	wg_allowedips_remove_by_peer(&t, peers[j], &mutex);
		400	mutex_unlock(&mutex);
		401	horrible_allowedips_remove_by_value(&h, peers[j]);
406	}	402	}
407		403
408	for (i = 0; i < NUM_QUERIES; ++i) {	404	if (t.root4 \|\| t.root6) {
409	prandom_bytes(ip, 16);	405	pr_err("allowedips random self-test removal: FAIL\n");
410	if (lookup(t.root6, 128, ip) !=	406	goto free;
411	horrible_allowedips_lookup_v6(&h, (struct in6_addr *)ip)) {
412	pr_err("allowedips random self-test: FAIL\n");
413	goto free;
414	}
415	}	407	}
		408
416	ret = true;	409	ret = true;
417		410
418	free:	411	free:

drivers/net/wireguard/socket.c+1−1

@@ -430,7 +430,7 @@ void wg_socket_reinit(struct wg_device wg, struct sock new4, · 429 unmodified lines
430	if (new4)	430	if (new4)
431	wg->incoming_port = ntohs(inet_sk(new4)->inet_sport);	431	wg->incoming_port = ntohs(inet_sk(new4)->inet_sport);
432	mutex_unlock(&wg->socket_update_lock);	432	mutex_unlock(&wg->socket_update_lock);
433	synchronize_rcu();	433	synchronize_net();
434	sock_free(old4);	434	sock_free(old4);
435	sock_free(old6);	435	sock_free(old6);
436	}	436	}

drivers/net/wireless/mediatek/mt76/mac80211.c+26−0

@@ -514,10 +514,36 @@ EXPORT_SYMBOL_GPL(mt76_free_device); · 513 unmodified lines
514	static void mt76_rx_release_amsdu(struct mt76_phy *phy, enum mt76_rxq_id q)	514	static void mt76_rx_release_amsdu(struct mt76_phy *phy, enum mt76_rxq_id q)
515	{	515	{
516	struct sk_buff *skb = phy->rx_amsdu[q].head;	516	struct sk_buff *skb = phy->rx_amsdu[q].head;
		517	struct mt76_rx_status status = (struct mt76_rx_status )skb->cb;
517	struct mt76_dev *dev = phy->dev;	518	struct mt76_dev *dev = phy->dev;
518		519
519	phy->rx_amsdu[q].head = NULL;	520	phy->rx_amsdu[q].head = NULL;
520	phy->rx_amsdu[q].tail = NULL;	521	phy->rx_amsdu[q].tail = NULL;
		522
		523	/*
		524	* Validate if the amsdu has a proper first subframe.
		525	* A single MSDU can be parsed as A-MSDU when the unauthenticated A-MSDU
		526	* flag of the QoS header gets flipped. In such cases, the first
		527	* subframe has a LLC/SNAP header in the location of the destination
		528	* address.
		529	*/
		530	if (skb_shinfo(skb)->frag_list) {
		531	int offset = 0;
		532
		533	if (!(status->flag & RX_FLAG_8023)) {
		534	offset = ieee80211_get_hdrlen_from_skb(skb);
		535
		536	if ((status->flag &
		537	(RX_FLAG_DECRYPTED \| RX_FLAG_IV_STRIPPED)) ==
		538	RX_FLAG_DECRYPTED)
		539	offset += 8;
		540	}
		541
		542	if (ether_addr_equal(skb->data + offset, rfc1042_header)) {
		543	dev_kfree_skb(skb);
		544	return;
		545	}
		546	}
521	__skb_queue_tail(&dev->rx_skb[q], skb);	547	__skb_queue_tail(&dev->rx_skb[q], skb);
522	}	548	}
523		549

drivers/net/wireless/mediatek/mt76/mt7615/init.c+0−1

@@ -510,7 +510,6 @@ void mt7615_init_device(struct mt7615_dev *dev) · 509 unmodified lines
510	mutex_init(&dev->pm.mutex);	510	mutex_init(&dev->pm.mutex);
511	init_waitqueue_head(&dev->pm.wait);	511	init_waitqueue_head(&dev->pm.wait);
512	spin_lock_init(&dev->pm.txq_lock);	512	spin_lock_init(&dev->pm.txq_lock);
513	set_bit(MT76_STATE_PM, &dev->mphy.state);
514	INIT_DELAYED_WORK(&dev->mphy.mac_work, mt7615_mac_work);	513	INIT_DELAYED_WORK(&dev->mphy.mac_work, mt7615_mac_work);
515	INIT_DELAYED_WORK(&dev->phy.scan_work, mt7615_scan_work);	514	INIT_DELAYED_WORK(&dev->phy.scan_work, mt7615_scan_work);
516	INIT_DELAYED_WORK(&dev->coredump.work, mt7615_coredump_work);	515	INIT_DELAYED_WORK(&dev->coredump.work, mt7615_coredump_work);

drivers/net/wireless/mediatek/mt76/mt7615/mac.c+3−2

 			napi_schedule(&dev->mt76.napi[i]);
 		mt76_connac_pm_dequeue_skbs(mphy, &dev->pm);
 		mt76_queue_tx_cleanup(dev, dev->mt76.q_mcu[MT_MCUQ_WM], false);
-		ieee80211_queue_delayed_work(mphy->hw, &mphy->mac_work,
+		if (test_bit(MT76_STATE_RUNNING, &mphy->state))
-					     MT7615_WATCHDOG_TIME);
+			ieee80211_queue_delayed_work(mphy->hw, &mphy->mac_work,
+						     MT7615_WATCHDOG_TIME);
 	}
 	ieee80211_wake_queues(mphy->hw);

drivers/net/wireless/mediatek/mt76/mt7615/sdio_mcu.c+12−7

 	return ret;
 }
-static int mt7663s_mcu_drv_pmctrl(struct mt7615_dev *dev)
+static int __mt7663s_mcu_drv_pmctrl(struct mt7615_dev *dev)
 {
 	struct sdio_func *func = dev->mt76.sdio.func;
 	struct mt76_phy *mphy = &dev->mt76.phy;
 	u32 status;
 	int ret;
-	if (!test_and_clear_bit(MT76_STATE_PM, &mphy->state))
-		goto out;
 	sdio_claim_host(func);
 	sdio_writel(func, WHLPCR_FW_OWN_REQ_CLR, MCR_WHLPCR, NULL);
 	}
 	sdio_release_host(func);
-out:
 	dev->pm.last_activity = jiffies;
 	return 0;
 }
+static int mt7663s_mcu_drv_pmctrl(struct mt7615_dev *dev)
+{
+	struct mt76_phy *mphy = &dev->mt76.phy;
+	if (test_and_clear_bit(MT76_STATE_PM, &mphy->state))
+		return __mt7663s_mcu_drv_pmctrl(dev);
+	return 0;
+}
 static int mt7663s_mcu_fw_pmctrl(struct mt7615_dev *dev)
 {
 	struct sdio_func *func = dev->mt76.sdio.func;
 	struct mt7615_mcu_ops *mcu_ops;
 	int ret;
-	ret = mt7663s_mcu_drv_pmctrl(dev);
+	ret = __mt7663s_mcu_drv_pmctrl(dev);
 	if (ret)
 		return ret;

drivers/net/wireless/mediatek/mt76/mt7615/usb_mcu.c+0−3

@@ -55,10 +55,7 @@ int mt7663u_mcu_init(struct mt7615_dev *dev) · 54 unmodified lines
55		55
56	dev->mt76.mcu_ops = &mt7663u_mcu_ops,	56	dev->mt76.mcu_ops = &mt7663u_mcu_ops,
57		57
58	/* usb does not support runtime-pm */
59	clear_bit(MT76_STATE_PM, &dev->mphy.state);
60	mt76_set(dev, MT_UDMA_TX_QSEL, MT_FW_DL_EN);	58	mt76_set(dev, MT_UDMA_TX_QSEL, MT_FW_DL_EN);
61
62	if (test_and_clear_bit(MT76_STATE_POWER_OFF, &dev->mphy.state)) {	59	if (test_and_clear_bit(MT76_STATE_POWER_OFF, &dev->mphy.state)) {
63	mt7615_mcu_restart(&dev->mt76);	60	mt7615_mcu_restart(&dev->mt76);
64	if (!mt76_poll_msec(dev, MT_CONN_ON_MISC,	61	if (!mt76_poll_msec(dev, MT_CONN_ON_MISC,

drivers/net/wireless/mediatek/mt76/mt76_connac_mcu.c+4−0

 	phy->phy_type = mt76_connac_get_phy_mode_v2(mphy, vif, band, sta);
 	phy->basic_rate = cpu_to_le16((u16)vif->bss_conf.basic_rates);
 	phy->rcpi = rcpi;
+	phy->ampdu = FIELD_PREP(IEEE80211_HT_AMPDU_PARM_FACTOR,
+				sta->ht_cap.ampdu_factor) |
+		     FIELD_PREP(IEEE80211_HT_AMPDU_PARM_DENSITY,
+				sta->ht_cap.ampdu_density);
 	tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_RA, sizeof(*ra_info));
 	ra_info = (struct sta_rec_ra_info *)tlv;

drivers/net/wireless/mediatek/mt76/mt76x0/pci.c+77−4

@@ -87,7 +87,7 @@ static const struct ieee80211_ops mt76x0e_ops = { · 86 unmodified lines
87	.reconfig_complete = mt76x02_reconfig_complete,	87	.reconfig_complete = mt76x02_reconfig_complete,
88	};	88	};
89		89
90	static int mt76x0e_register_device(struct mt76x02_dev *dev)	90	static int mt76x0e_init_hardware(struct mt76x02_dev *dev, bool resume)
91	{	91	{
92	int err;	92	int err;
93		93
@@ -100,9 +100,11 @@ static int mt76x0e_register_device(struct mt76x02_dev *dev) · 6 unmodified lines
100	if (err < 0)	100	if (err < 0)
101	return err;	101	return err;
102		102
103	err = mt76x02_dma_init(dev);	103	if (!resume) {
104	if (err < 0)	104	err = mt76x02_dma_init(dev);
105	return err;	105	if (err < 0)
		106	return err;
		107	}
106		108
107	err = mt76x0_init_hardware(dev);	109	err = mt76x0_init_hardware(dev);
108	if (err < 0)	110	if (err < 0)
@@ -123,6 +125,17 @@ static int mt76x0e_register_device(struct mt76x02_dev *dev) · 14 unmodified lines
123	mt76_clear(dev, 0x110, BIT(9));	125	mt76_clear(dev, 0x110, BIT(9));
124	mt76_set(dev, MT_MAX_LEN_CFG, BIT(13));	126	mt76_set(dev, MT_MAX_LEN_CFG, BIT(13));
125		127
		128	return 0;
		129	}
		130
		131	static int mt76x0e_register_device(struct mt76x02_dev *dev)
		132	{
		133	int err;
		134
		135	err = mt76x0e_init_hardware(dev, false);
		136	if (err < 0)
		137	return err;
		138
126	err = mt76x0_register_device(dev);	139	err = mt76x0_register_device(dev);
127	if (err < 0)	140	if (err < 0)
128	return err;	141	return err;
@@ -167,6 +180,8 @@ mt76x0e_probe(struct pci_dev pdev, const struct pci_device_id id) · 38 unmodified lines
167	if (ret)	180	if (ret)
168	return ret;	181	return ret;
169		182
		183	mt76_pci_disable_aspm(pdev);
		184
170	mdev = mt76_alloc_device(&pdev->dev, sizeof(*dev), &mt76x0e_ops,	185	mdev = mt76_alloc_device(&pdev->dev, sizeof(*dev), &mt76x0e_ops,
171	&drv_ops);	186	&drv_ops);
172	if (!mdev)	187	if (!mdev)
@@ -220,6 +235,60 @@ mt76x0e_remove(struct pci_dev *pdev) · 47 unmodified lines
220	mt76_free_device(mdev);	235	mt76_free_device(mdev);
221	}	236	}
222		237
		238	#ifdef CONFIG_PM
		239	static int mt76x0e_suspend(struct pci_dev *pdev, pm_message_t state)
		240	{
		241	struct mt76_dev *mdev = pci_get_drvdata(pdev);
		242	struct mt76x02_dev *dev = container_of(mdev, struct mt76x02_dev, mt76);
		243	int i;
		244
		245	mt76_worker_disable(&mdev->tx_worker);
		246	for (i = 0; i < ARRAY_SIZE(mdev->phy.q_tx); i++)
		247	mt76_queue_tx_cleanup(dev, mdev->phy.q_tx[i], true);
		248	for (i = 0; i < ARRAY_SIZE(mdev->q_mcu); i++)
		249	mt76_queue_tx_cleanup(dev, mdev->q_mcu[i], true);
		250	napi_disable(&mdev->tx_napi);
		251
		252	mt76_for_each_q_rx(mdev, i)
		253	napi_disable(&mdev->napi[i]);
		254
		255	mt76x02_dma_disable(dev);
		256	mt76x02_mcu_cleanup(dev);
		257	mt76x0_chip_onoff(dev, false, false);
		258
		259	pci_enable_wake(pdev, pci_choose_state(pdev, state), true);
		260	pci_save_state(pdev);
		261
		262	return pci_set_power_state(pdev, pci_choose_state(pdev, state));
		263	}
		264
		265	static int mt76x0e_resume(struct pci_dev *pdev)
		266	{
		267	struct mt76_dev *mdev = pci_get_drvdata(pdev);
		268	struct mt76x02_dev *dev = container_of(mdev, struct mt76x02_dev, mt76);
		269	int err, i;
		270
		271	err = pci_set_power_state(pdev, PCI_D0);
		272	if (err)
		273	return err;
		274
		275	pci_restore_state(pdev);
		276
		277	mt76_worker_enable(&mdev->tx_worker);
		278
		279	mt76_for_each_q_rx(mdev, i) {
		280	mt76_queue_rx_reset(dev, i);
		281	napi_enable(&mdev->napi[i]);
		282	napi_schedule(&mdev->napi[i]);
		283	}
		284
		285	napi_enable(&mdev->tx_napi);
		286	napi_schedule(&mdev->tx_napi);
		287
		288	return mt76x0e_init_hardware(dev, true);
		289	}
		290	#endif /* CONFIG_PM */
		291
223	static const struct pci_device_id mt76x0e_device_table[] = {	292	static const struct pci_device_id mt76x0e_device_table[] = {
224	{ PCI_DEVICE(PCI_VENDOR_ID_MEDIATEK, 0x7610) },	293	{ PCI_DEVICE(PCI_VENDOR_ID_MEDIATEK, 0x7610) },
225	{ PCI_DEVICE(PCI_VENDOR_ID_MEDIATEK, 0x7630) },	294	{ PCI_DEVICE(PCI_VENDOR_ID_MEDIATEK, 0x7630) },
@@ -237,6 +306,10 @@ static struct pci_driver mt76x0e_driver = { · 11 unmodified lines
237	.id_table = mt76x0e_device_table,	306	.id_table = mt76x0e_device_table,
238	.probe = mt76x0e_probe,	307	.probe = mt76x0e_probe,
239	.remove = mt76x0e_remove,	308	.remove = mt76x0e_remove,
		309	#ifdef CONFIG_PM
		310	.suspend = mt76x0e_suspend,
		311	.resume = mt76x0e_resume,
		312	#endif /* CONFIG_PM */
240	};	313	};
241		314
242	module_pci_driver(mt76x0e_driver);	315	module_pci_driver(mt76x0e_driver);

drivers/net/wireless/mediatek/mt76/mt7921/init.c+2−2

@@ -76,8 +76,8 @@ mt7921_init_wiphy(struct ieee80211_hw *hw) · 75 unmodified lines
76	struct wiphy *wiphy = hw->wiphy;	76	struct wiphy *wiphy = hw->wiphy;
77		77
78	hw->queues = 4;	78	hw->queues = 4;
79	hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF;	79	hw->max_rx_aggregation_subframes = 64;
80	hw->max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF;	80	hw->max_tx_aggregation_subframes = 128;
81		81
82	hw->radiotap_timestamp.units_pos =	82	hw->radiotap_timestamp.units_pos =
83	IEEE80211_RADIOTAP_TIMESTAMP_UNIT_US;	83	IEEE80211_RADIOTAP_TIMESTAMP_UNIT_US;

drivers/net/wireless/mediatek/mt76/mt7921/mac.c+3−2

 			napi_schedule(&dev->mt76.napi[i]);
 		mt76_connac_pm_dequeue_skbs(mphy, &dev->pm);
 		mt7921_tx_cleanup(dev);
-		ieee80211_queue_delayed_work(mphy->hw, &mphy->mac_work,
+		if (test_bit(MT76_STATE_RUNNING, &mphy->state))
-					     MT7921_WATCHDOG_TIME);
+			ieee80211_queue_delayed_work(mphy->hw, &mphy->mac_work,
+						     MT7921_WATCHDOG_TIME);
 	}
 	ieee80211_wake_queues(mphy->hw);

drivers/net/wireless/mediatek/mt76/mt7921/main.c+1−2

@@ -74,8 +74,7 @@ mt7921_init_he_caps(struct mt7921_phy *phy, enum nl80211_band band, · 73 unmodified lines
74	IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G;	74	IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G;
75	else if (band == NL80211_BAND_5GHZ)	75	else if (band == NL80211_BAND_5GHZ)
76	he_cap_elem->phy_cap_info[0] =	76	he_cap_elem->phy_cap_info[0] =
77	IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G \|	77	IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G;
78	IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G;
79		78
80	he_cap_elem->phy_cap_info[1] =	79	he_cap_elem->phy_cap_info[1] =
81	IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD;	80	IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD;

drivers/net/wireless/mediatek/mt76/mt7921/mcu.c+10−7

 mt7921_mcu_tx_rate_report(struct mt7921_dev *dev, struct sk_buff *skb,
 			  u16 wlan_idx)
 {
-	struct mt7921_mcu_wlan_info_event *wtbl_info =
+	struct mt7921_mcu_wlan_info_event *wtbl_info;
-		(struct mt7921_mcu_wlan_info_event *)(skb->data);
-	struct rate_info rate = {};
-	u8 curr_idx = wtbl_info->rate_info.rate_idx;
-	u16 curr = le16_to_cpu(wtbl_info->rate_info.rate[curr_idx]);
-	struct mt7921_mcu_peer_cap peer = wtbl_info->peer_cap;
 	struct mt76_phy *mphy = &dev->mphy;
 	struct mt7921_sta_stats *stats;
+	struct rate_info rate = {};
 	struct mt7921_sta *msta;
 	struct mt76_wcid *wcid;
+	u8 idx;
 	if (wlan_idx >= MT76_N_WCIDS)
 		return;
+	wtbl_info = (struct mt7921_mcu_wlan_info_event *)skb->data;
+	idx = wtbl_info->rate_info.rate_idx;
+	if (idx >= ARRAY_SIZE(wtbl_info->rate_info.rate))
+		return;
 	rcu_read_lock();
 	wcid = rcu_dereference(dev->mt76.wcid[wlan_idx]);
 	stats = &msta->stats;
 	/* current rate */
-	mt7921_mcu_tx_rate_parse(mphy, &peer, &rate, curr);
+	mt7921_mcu_tx_rate_parse(mphy, &wtbl_info->peer_cap, &rate,
+				 le16_to_cpu(wtbl_info->rate_info.rate[idx]));
 	stats->tx_rate = rate;
 out:
 	rcu_read_unlock();

drivers/net/xen-netback/interface.c+6−0

 {
 	if (queue->task) {
 		kthread_stop(queue->task);
+		put_task_struct(queue->task);
 		queue->task = NULL;
 	}
 	if (IS_ERR(task))
 		goto kthread_err;
 	queue->task = task;
+	/*
+	 * Take a reference to the task in order to prevent it from being freed
+	 * if the thread function returns before kthread_stop is called.
+	 */
+	get_task_struct(task);
 	task = kthread_run(xenvif_dealloc_kthread, queue,
 			   "%s-dealloc", queue->name);

drivers/nvme/host/rdma.c+3−2

 		int count)
 {
 	struct nvme_sgl_desc *sg = &c->common.dptr.sgl;
-	struct scatterlist *sgl = req->data_sgl.sg_table.sgl;
 	struct ib_sge *sge = &req->sge[1];
+	struct scatterlist *sgl;
 	u32 len = 0;
 	int i;
-	for (i = 0; i < count; i++, sgl++, sge++) {
+	for_each_sg(req->data_sgl.sg_table.sgl, sgl, count, i) {
 		sge->addr = sg_dma_address(sgl);
 		sge->length = sg_dma_len(sgl);
 		sge->lkey = queue->device->pd->local_dma_lkey;
 		len += sge->length;
+		sge++;
 	}
 	sg->addr = cpu_to_le64(queue->ctrl->ctrl.icdoff);

drivers/nvme/target/core.c+16−17

@@ -1005,19 +1005,23 @@ static unsigned int nvmet_data_transfer_len(struct nvmet_req *req) · 1004 unmodified lines
1005	return req->transfer_len - req->metadata_len;	1005	return req->transfer_len - req->metadata_len;
1006	}	1006	}
1007		1007
1008	static int nvmet_req_alloc_p2pmem_sgls(struct nvmet_req *req)	1008	static int nvmet_req_alloc_p2pmem_sgls(struct pci_dev *p2p_dev,
		1009	struct nvmet_req *req)
1009	{	1010	{
1010	req->sg = pci_p2pmem_alloc_sgl(req->p2p_dev, &req->sg_cnt,	1011	req->sg = pci_p2pmem_alloc_sgl(p2p_dev, &req->sg_cnt,
1011	nvmet_data_transfer_len(req));	1012	nvmet_data_transfer_len(req));
1012	if (!req->sg)	1013	if (!req->sg)
1013	goto out_err;	1014	goto out_err;
1014		1015
1015	if (req->metadata_len) {	1016	if (req->metadata_len) {
1016	req->metadata_sg = pci_p2pmem_alloc_sgl(req->p2p_dev,	1017	req->metadata_sg = pci_p2pmem_alloc_sgl(p2p_dev,
1017	&req->metadata_sg_cnt, req->metadata_len);	1018	&req->metadata_sg_cnt, req->metadata_len);
1018	if (!req->metadata_sg)	1019	if (!req->metadata_sg)
1019	goto out_free_sg;	1020	goto out_free_sg;
1020	}	1021	}
		1022
		1023	req->p2p_dev = p2p_dev;
		1024
1021	return 0;	1025	return 0;
1022	out_free_sg:	1026	out_free_sg:
1023	pci_p2pmem_free_sgl(req->p2p_dev, req->sg);	1027	pci_p2pmem_free_sgl(req->p2p_dev, req->sg);
@@ -1025,25 +1029,19 @@ out_err: · 1 unmodified line
1025	return -ENOMEM;	1029	return -ENOMEM;
1026	}	1030	}
1027		1031
1028	static bool nvmet_req_find_p2p_dev(struct nvmet_req *req)	1032	static struct pci_dev nvmet_req_find_p2p_dev(struct nvmet_req req)
1029	{	1033	{
1030	if (!IS_ENABLED(CONFIG_PCI_P2PDMA))	1034	if (!IS_ENABLED(CONFIG_PCI_P2PDMA) \|\|
1031	return false;	1035	!req->sq->ctrl \|\| !req->sq->qid \|\| !req->ns)
1032		1036	return NULL;
1033	if (req->sq->ctrl && req->sq->qid && req->ns) {	1037	return radix_tree_lookup(&req->sq->ctrl->p2p_ns_map, req->ns->nsid);
1034	req->p2p_dev = radix_tree_lookup(&req->sq->ctrl->p2p_ns_map,
1035	req->ns->nsid);
1036	if (req->p2p_dev)
1037	return true;
1038	}
1039
1040	req->p2p_dev = NULL;
1041	return false;
1042	}	1038	}
1043		1039
1044	int nvmet_req_alloc_sgls(struct nvmet_req *req)	1040	int nvmet_req_alloc_sgls(struct nvmet_req *req)
1045	{	1041	{
1046	if (nvmet_req_find_p2p_dev(req) && !nvmet_req_alloc_p2pmem_sgls(req))	1042	struct pci_dev *p2p_dev = nvmet_req_find_p2p_dev(req);
		1043
		1044	if (p2p_dev && !nvmet_req_alloc_p2pmem_sgls(p2p_dev, req))
1047	return 0;	1045	return 0;
1048		1046
1049	req->sg = sgl_alloc(nvmet_data_transfer_len(req), GFP_KERNEL,	1047	req->sg = sgl_alloc(nvmet_data_transfer_len(req), GFP_KERNEL,
@@ -1072,6 +1070,7 @@ void nvmet_req_free_sgls(struct nvmet_req *req) · 22 unmodified lines
1072	pci_p2pmem_free_sgl(req->p2p_dev, req->sg);	1070	pci_p2pmem_free_sgl(req->p2p_dev, req->sg);
1073	if (req->metadata_sg)	1071	if (req->metadata_sg)
1074	pci_p2pmem_free_sgl(req->p2p_dev, req->metadata_sg);	1072	pci_p2pmem_free_sgl(req->p2p_dev, req->metadata_sg);
		1073	req->p2p_dev = NULL;
1075	} else {	1074	} else {
1076	sgl_free(req->sg);	1075	sgl_free(req->sg);
1077	if (req->metadata_sg)	1076	if (req->metadata_sg)

drivers/nvme/target/loop.c+8−3

 static void nvme_loop_destroy_admin_queue(struct nvme_loop_ctrl *ctrl)
 {
-	clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[0].flags);
+	if (!test_and_clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[0].flags))
+		return;
 	nvmet_sq_destroy(&ctrl->queues[0].nvme_sq);
 	blk_cleanup_queue(ctrl->ctrl.admin_q);
 	blk_cleanup_queue(ctrl->ctrl.fabrics_q);
 		clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[i].flags);
 		nvmet_sq_destroy(&ctrl->queues[i].nvme_sq);
 	}
+	ctrl->ctrl.queue_count = 1;
 }
 static int nvme_loop_init_io_queues(struct nvme_loop_ctrl *ctrl)
 	return 0;
 out_cleanup_queue:
+	clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[0].flags);
 	blk_cleanup_queue(ctrl->ctrl.admin_q);
 out_cleanup_fabrics_q:
 	blk_cleanup_queue(ctrl->ctrl.fabrics_q);
 	nvme_loop_shutdown_ctrl(ctrl);
 	if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING)) {
-		/* state change failure should never happen */
+		if (ctrl->ctrl.state != NVME_CTRL_DELETING &&
-		WARN_ON_ONCE(1);
+		    ctrl->ctrl.state != NVME_CTRL_DELETING_NOIO)
+			/* state change failure for non-deleted ctrl? */
+			WARN_ON_ONCE(1);
 		return;
 	}

drivers/pci/of.c+7−0

@@ -103,6 +103,13 @@ struct irq_domain pci_host_bridge_of_msi_domain(struct pci_bus bus) · 102 unmodified lines
103	#endif	103	#endif
104	}	104	}
105		105
		106	bool pci_host_of_has_msi_map(struct device *dev)
		107	{
		108	if (dev && dev->of_node)
		109	return of_get_property(dev->of_node, "msi-map", NULL);
		110	return false;
		111	}
		112
106	static inline int __of_pci_pci_compare(struct device_node *node,	113	static inline int __of_pci_pci_compare(struct device_node *node,
107	unsigned int data)	114	unsigned int data)
108	{	115	{

drivers/pci/probe.c+2−1

@@ -925,7 +925,8 @@ static int pci_register_host_bridge(struct pci_host_bridge *bridge) · 924 unmodified lines
925	device_enable_async_suspend(bus->bridge);	925	device_enable_async_suspend(bus->bridge);
926	pci_set_bus_of_node(bus);	926	pci_set_bus_of_node(bus);
927	pci_set_bus_msi_domain(bus);	927	pci_set_bus_msi_domain(bus);
928	if (bridge->msi_domain && !dev_get_msi_domain(&bus->dev))	928	if (bridge->msi_domain && !dev_get_msi_domain(&bus->dev) &&
		929	!pci_host_of_has_msi_map(parent))
929	bus->bus_flags \|= PCI_BUS_FLAGS_NO_MSI;	930	bus->bus_flags \|= PCI_BUS_FLAGS_NO_MSI;
930		931
931	if (!parent)	932	if (!parent)

drivers/phy/broadcom/phy-brcm-usb-init.h+2−2

@@ -78,7 +78,7 @@ static inline u32 brcm_usb_readl(void __iomem *addr) · 77 unmodified lines
78	* Other architectures (e.g., ARM) either do not support big endian, or	78	* Other architectures (e.g., ARM) either do not support big endian, or
79	* else leave I/O in little endian mode.	79	* else leave I/O in little endian mode.
80	*/	80	*/
81	if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(__BIG_ENDIAN))	81	if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(CONFIG_CPU_BIG_ENDIAN))
82	return __raw_readl(addr);	82	return __raw_readl(addr);
83	else	83	else
84	return readl_relaxed(addr);	84	return readl_relaxed(addr);
@@ -87,7 +87,7 @@ static inline u32 brcm_usb_readl(void __iomem *addr) · 2 unmodified lines
87	static inline void brcm_usb_writel(u32 val, void __iomem *addr)	87	static inline void brcm_usb_writel(u32 val, void __iomem *addr)
88	{	88	{
89	/* See brcmnand_readl() comments */	89	/* See brcmnand_readl() comments */
90	if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(__BIG_ENDIAN))	90	if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(CONFIG_CPU_BIG_ENDIAN))
91	__raw_writel(val, addr);	91	__raw_writel(val, addr);
92	else	92	else
93	writel_relaxed(val, addr);	93	writel_relaxed(val, addr);

drivers/phy/cadence/phy-cadence-sierra.c+1−0

@@ -940,6 +940,7 @@ static int cdns_sierra_phy_probe(struct platform_device *pdev) · 939 unmodified lines
940	sp->nsubnodes = node;	940	sp->nsubnodes = node;
941		941
942	if (sp->num_lanes > SIERRA_MAX_LANES) {	942	if (sp->num_lanes > SIERRA_MAX_LANES) {
		943	ret = -EINVAL;
943	dev_err(dev, "Invalid lane configuration\n");	944	dev_err(dev, "Invalid lane configuration\n");
944	goto put_child2;	945	goto put_child2;
945	}	946	}

drivers/phy/mediatek/phy-mtk-tphy.c+2−0

@@ -949,6 +949,8 @@ static int mtk_phy_init(struct phy *phy) · 948 unmodified lines
949	break;	949	break;
950	default:	950	default:
951	dev_err(tphy->dev, "incompatible PHY type\n");	951	dev_err(tphy->dev, "incompatible PHY type\n");
		952	clk_disable_unprepare(instance->ref_clk);
		953	clk_disable_unprepare(instance->da_ref_clk);
952	return -EINVAL;	954	return -EINVAL;
953	}	955	}
954		956

drivers/phy/microchip/sparx5_serdes.c+4−0

 	priv->coreclock = clock;
 	iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (!iores) {
+		dev_err(priv->dev, "Invalid resource\n");
+		return -EINVAL;
+	}
 	iomem = devm_ioremap(priv->dev, iores->start, resource_size(iores));
 	if (IS_ERR(iomem)) {
 		dev_err(priv->dev, "Unable to get serdes registers: %s\n",

drivers/phy/ralink/phy-mt7621-pci.c+1−1

@@ -341,7 +341,7 @@ static struct platform_driver mt7621_pci_phy_driver = { · 340 unmodified lines
341	.probe = mt7621_pci_phy_probe,	341	.probe = mt7621_pci_phy_probe,
342	.driver = {	342	.driver = {
343	.name = "mt7621-pci-phy",	343	.name = "mt7621-pci-phy",
344	.of_match_table = of_match_ptr(mt7621_pci_phy_ids),	344	.of_match_table = mt7621_pci_phy_ids,
345	},	345	},
346	};	346	};
347		347

drivers/phy/ti/phy-j721e-wiz.c+1−0

@@ -1212,6 +1212,7 @@ static int wiz_probe(struct platform_device *pdev) · 1211 unmodified lines
1212		1212
1213	if (wiz->typec_dir_delay < WIZ_TYPEC_DIR_DEBOUNCE_MIN \|\|	1213	if (wiz->typec_dir_delay < WIZ_TYPEC_DIR_DEBOUNCE_MIN \|\|
1214	wiz->typec_dir_delay > WIZ_TYPEC_DIR_DEBOUNCE_MAX) {	1214	wiz->typec_dir_delay > WIZ_TYPEC_DIR_DEBOUNCE_MAX) {
		1215	ret = -EINVAL;
1215	dev_err(dev, "Invalid typec-dir-debounce property\n");	1216	dev_err(dev, "Invalid typec-dir-debounce property\n");
1216	goto err_addr_to_resource;	1217	goto err_addr_to_resource;
1217	}	1218	}

drivers/pinctrl/aspeed/pinctrl-aspeed-g5.c+2−2

@@ -2702,8 +2702,8 @@ static int aspeed_g5_sig_expr_eval(struct aspeed_pinmux_data *ctx, · 2701 unmodified lines
2702	}	2702	}
2703		2703
2704	/**	2704	/**
2705	* Configure a pin's signal by applying an expression's descriptor state for	2705	* aspeed_g5_sig_expr_set() - Configure a pin's signal by applying an
2706	* all descriptors in the expression.	2706	* expression's descriptor state for all descriptors in the expression.
2707	*	2707	*
2708	* @ctx: The pinmux context	2708	* @ctx: The pinmux context
2709	* @expr: The expression associated with the function whose signal is to be	2709	* @expr: The expression associated with the function whose signal is to be

drivers/pinctrl/aspeed/pinctrl-aspeed-g6.c+2−2

@@ -2611,8 +2611,8 @@ static struct aspeed_pin_config aspeed_g6_configs[] = { · 2610 unmodified lines
2611	};	2611	};
2612		2612
2613	/**	2613	/**
2614	* Configure a pin's signal by applying an expression's descriptor state for	2614	* aspeed_g6_sig_expr_set() - Configure a pin's signal by applying an
2615	* all descriptors in the expression.	2615	* expression's descriptor state for all descriptors in the expression.
2616	*	2616	*
2617	* @ctx: The pinmux context	2617	* @ctx: The pinmux context
2618	* @expr: The expression associated with the function whose signal is to be	2618	* @expr: The expression associated with the function whose signal is to be

drivers/pinctrl/aspeed/pinctrl-aspeed.c+2−1

@@ -108,7 +108,8 @@ static int aspeed_sig_expr_disable(struct aspeed_pinmux_data *ctx, · 107 unmodified lines
108	}	108	}
109		109
110	/**	110	/**
111	* Disable a signal on a pin by disabling all provided signal expressions.	111	* aspeed_disable_sig() - Disable a signal on a pin by disabling all provided
		112	* signal expressions.
112	*	113	*
113	* @ctx: The pinmux context	114	* @ctx: The pinmux context
114	* @exprs: The list of signal expressions (from a priority level on a pin)	115	* @exprs: The list of signal expressions (from a priority level on a pin)

drivers/pinctrl/aspeed/pinmux-aspeed.c+2−1

@@ -21,7 +21,8 @@ static inline void aspeed_sig_desc_print_val( · 20 unmodified lines
21	}	21	}
22		22
23	/**	23	/**
24	* Query the enabled or disabled state of a signal descriptor	24	* aspeed_sig_desc_eval() - Query the enabled or disabled state of a signal
		25	* descriptor.
25	*	26	*
26	* @desc: The signal descriptor of interest	27	* @desc: The signal descriptor of interest
27	* @enabled: True to query the enabled state, false to query disabled state	28	* @enabled: True to query the enabled state, false to query disabled state

drivers/pinctrl/qcom/Kconfig+1−1

@@ -223,7 +223,7 @@ config PINCTRL_SC7280 · 222 unmodified lines
223	config PINCTRL_SC8180X	223	config PINCTRL_SC8180X
224	tristate "Qualcomm Technologies Inc SC8180x pin controller driver"	224	tristate "Qualcomm Technologies Inc SC8180x pin controller driver"
225	depends on GPIOLIB && (OF \|\| ACPI)	225	depends on GPIOLIB && (OF \|\| ACPI)
226	select PINCTRL_MSM	226	depends on PINCTRL_MSM
227	help	227	help
228	This is the pinctrl, pinmux, pinconf and gpiolib driver for the	228	This is the pinctrl, pinmux, pinconf and gpiolib driver for the
229	Qualcomm Technologies Inc TLMM block found on the Qualcomm	229	Qualcomm Technologies Inc TLMM block found on the Qualcomm

drivers/pinctrl/qcom/pinctrl-sdx55.c+9−9

@@ -410,15 +410,15 @@ static const char * const gpio_groups[] = { · 409 unmodified lines
410	"gpio29", "gpio30", "gpio31", "gpio32", "gpio33", "gpio34", "gpio35",	410	"gpio29", "gpio30", "gpio31", "gpio32", "gpio33", "gpio34", "gpio35",
411	"gpio36", "gpio37", "gpio38", "gpio39", "gpio40", "gpio41", "gpio42",	411	"gpio36", "gpio37", "gpio38", "gpio39", "gpio40", "gpio41", "gpio42",
412	"gpio43", "gpio44", "gpio45", "gpio46", "gpio47", "gpio48", "gpio49",	412	"gpio43", "gpio44", "gpio45", "gpio46", "gpio47", "gpio48", "gpio49",
413	"gpio50", "gpio51", "gpio52", "gpio52", "gpio53", "gpio53", "gpio54",	413	"gpio50", "gpio51", "gpio52", "gpio53", "gpio54", "gpio55", "gpio56",
414	"gpio55", "gpio56", "gpio57", "gpio58", "gpio59", "gpio60", "gpio61",	414	"gpio57", "gpio58", "gpio59", "gpio60", "gpio61", "gpio62", "gpio63",
415	"gpio62", "gpio63", "gpio64", "gpio65", "gpio66", "gpio67", "gpio68",	415	"gpio64", "gpio65", "gpio66", "gpio67", "gpio68", "gpio69", "gpio70",
416	"gpio69", "gpio70", "gpio71", "gpio72", "gpio73", "gpio74", "gpio75",	416	"gpio71", "gpio72", "gpio73", "gpio74", "gpio75", "gpio76", "gpio77",
417	"gpio76", "gpio77", "gpio78", "gpio79", "gpio80", "gpio81", "gpio82",	417	"gpio78", "gpio79", "gpio80", "gpio81", "gpio82", "gpio83", "gpio84",
418	"gpio83", "gpio84", "gpio85", "gpio86", "gpio87", "gpio88", "gpio89",	418	"gpio85", "gpio86", "gpio87", "gpio88", "gpio89", "gpio90", "gpio91",
419	"gpio90", "gpio91", "gpio92", "gpio93", "gpio94", "gpio95", "gpio96",	419	"gpio92", "gpio93", "gpio94", "gpio95", "gpio96", "gpio97", "gpio98",
420	"gpio97", "gpio98", "gpio99", "gpio100", "gpio101", "gpio102",	420	"gpio99", "gpio100", "gpio101", "gpio102", "gpio103", "gpio104",
421	"gpio103", "gpio104", "gpio105", "gpio106", "gpio107",	421	"gpio105", "gpio106", "gpio107",
422	};	422	};
423		423
424	static const char * const qdss_stm_groups[] = {	424	static const char * const qdss_stm_groups[] = {

drivers/pinctrl/ralink/pinctrl-rt2880.c+1−1

@@ -127,7 +127,7 @@ static int rt2880_pmx_group_enable(struct pinctrl_dev *pctrldev, · 126 unmodified lines
127	if (p->groups[group].enabled) {	127	if (p->groups[group].enabled) {
128	dev_err(p->dev, "%s is already enabled\n",	128	dev_err(p->dev, "%s is already enabled\n",
129	p->groups[group].name);	129	p->groups[group].name);
130	return -EBUSY;	130	return 0;
131	}	131	}
132		132
133	p->groups[group].enabled = 1;	133	p->groups[group].enabled = 1;

drivers/platform/mellanox/mlxreg-hotplug.c+2−2

 	err = devm_request_irq(&pdev->dev, priv->irq,
 			       mlxreg_hotplug_irq_handler, IRQF_TRIGGER_FALLING
-			       | IRQF_SHARED | IRQF_NO_AUTOEN,
+			       | IRQF_SHARED, "mlxreg-hotplug", priv);
-			       "mlxreg-hotplug", priv);
 	if (err) {
 		dev_err(&pdev->dev, "Failed to request irq: %d\n", err);
 		return err;
 	}
+	disable_irq(priv->irq);
 	spin_lock_init(&priv->lock);
 	INIT_DELAYED_WORK(&priv->dwork_irq, mlxreg_hotplug_work_handler);
 	dev_set_drvdata(&pdev->dev, priv);

drivers/platform/surface/aggregator/controller.c+1−1

@@ -1907,7 +1907,7 @@ static int ssam_ssh_event_disable(struct ssam_controller *ctrl, · 1906 unmodified lines
1907	{	1907	{
1908	int status;	1908	int status;
1909		1909
1910	status = __ssam_ssh_event_request(ctrl, reg, reg.cid_enable, id, flags);	1910	status = __ssam_ssh_event_request(ctrl, reg, reg.cid_disable, id, flags);
1911		1911
1912	if (status < 0 && status != -EINVAL) {	1912	if (status < 0 && status != -EINVAL) {
1913	ssam_err(ctrl,	1913	ssam_err(ctrl,

drivers/platform/surface/surface_aggregator_registry.c+5−2

 	NULL,
 };
-/* Devices for Surface Laptop 3. */
+/* Devices for Surface Laptop 3 and 4. */
 static const struct software_node *ssam_node_group_sl3[] = {
 	&ssam_node_root,
 	&ssam_node_bat_ac,
 	/* Surface Laptop 3 (13", Intel) */
 	{ "MSHW0114", (unsigned long)ssam_node_group_sl3 },
-	/* Surface Laptop 3 (15", AMD) */
+	/* Surface Laptop 3 (15", AMD) and 4 (15", AMD) */
 	{ "MSHW0110", (unsigned long)ssam_node_group_sl3 },
+	/* Surface Laptop 4 (13", Intel) */
+	{ "MSHW0250", (unsigned long)ssam_node_group_sl3 },
 	/* Surface Laptop Go 1 */
 	{ "MSHW0118", (unsigned long)ssam_node_group_slg1 },

drivers/platform/surface/surface_dtx.c+1−0

@@ -427,6 +427,7 @@ static int surface_dtx_open(struct inode inode, struct file file) · 426 unmodified lines
427	*/	427	*/
428	if (test_bit(SDTX_DEVICE_SHUTDOWN_BIT, &ddev->flags)) {	428	if (test_bit(SDTX_DEVICE_SHUTDOWN_BIT, &ddev->flags)) {
429	up_write(&ddev->client_lock);	429	up_write(&ddev->client_lock);
		430	mutex_destroy(&client->read_lock);
430	sdtx_device_put(client->ddev);	431	sdtx_device_put(client->ddev);
431	kfree(client);	432	kfree(client);
432	return -ENODEV;	433	return -ENODEV;

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

@@ -8853,6 +8853,7 @@ static const struct tpacpi_quirk fan_quirk_table[] __initconst = { · 8852 unmodified lines
8853	TPACPI_Q_LNV3('N', '2', 'O', TPACPI_FAN_2CTL), /* P1 / X1 Extreme (2nd gen) */	8853	TPACPI_Q_LNV3('N', '2', 'O', TPACPI_FAN_2CTL), /* P1 / X1 Extreme (2nd gen) */
8854	TPACPI_Q_LNV3('N', '2', 'V', TPACPI_FAN_2CTL), /* P1 / X1 Extreme (3nd gen) */	8854	TPACPI_Q_LNV3('N', '2', 'V', TPACPI_FAN_2CTL), /* P1 / X1 Extreme (3nd gen) */
8855	TPACPI_Q_LNV3('N', '3', '0', TPACPI_FAN_2CTL), /* P15 (1st gen) / P15v (1st gen) */	8855	TPACPI_Q_LNV3('N', '3', '0', TPACPI_FAN_2CTL), /* P15 (1st gen) / P15v (1st gen) */
		8856	TPACPI_Q_LNV3('N', '3', '2', TPACPI_FAN_2CTL), /* X1 Carbon (9th gen) */
8856	};	8857	};
8857		8858
8858	static int __init fan_init(struct ibm_init_struct *iibm)	8859	static int __init fan_init(struct ibm_init_struct *iibm)

drivers/regulator/Kconfig+1−1

@@ -1031,7 +1031,7 @@ config REGULATOR_RT5033 · 1030 unmodified lines
1031	current source, LDO and Buck.	1031	current source, LDO and Buck.
1032		1032
1033	config REGULATOR_RTMV20	1033	config REGULATOR_RTMV20
1034	tristate "RTMV20 Laser Diode Regulator"	1034	tristate "Richtek RTMV20 Laser Diode Regulator"
1035	depends on I2C	1035	depends on I2C
1036	select REGMAP_I2C	1036	select REGMAP_I2C
1037	help	1037	help

drivers/regulator/atc260x-regulator.c+10−9

 static const struct linear_range atc2609a_ldo_voltage_ranges0[] = {
 	REGULATOR_LINEAR_RANGE(700000, 0, 15, 100000),
-	REGULATOR_LINEAR_RANGE(2100000, 16, 28, 100000),
+	REGULATOR_LINEAR_RANGE(2100000, 0, 12, 100000),
 };
 static const struct linear_range atc2609a_ldo_voltage_ranges1[] = {
 	REGULATOR_LINEAR_RANGE(850000, 0, 15, 100000),
-	REGULATOR_LINEAR_RANGE(2100000, 16, 27, 100000),
+	REGULATOR_LINEAR_RANGE(2100000, 0, 11, 100000),
 };
 static const unsigned int atc260x_ldo_voltage_range_sel[] = {
-	0x0, 0x1,
+	0x0, 0x20,
 };
 static int atc260x_dcdc_set_voltage_time_sel(struct regulator_dev *rdev,
 	.owner = THIS_MODULE, \
 }
-#define atc2609a_reg_desc_ldo_range_pick(num, n_range) { \
+#define atc2609a_reg_desc_ldo_range_pick(num, n_range, n_volt) { \
 	.name = "LDO"#num, \
 	.supply_name = "ldo"#num, \
 	.of_match = of_match_ptr("ldo"#num), \
 	.type = REGULATOR_VOLTAGE, \
 	.linear_ranges = atc2609a_ldo_voltage_ranges##n_range, \
 	.n_linear_ranges = ARRAY_SIZE(atc2609a_ldo_voltage_ranges##n_range), \
+	.n_voltages = n_volt, \
 	.vsel_reg = ATC2609A_PMU_LDO##num##_CTL0, \
 	.vsel_mask = GENMASK(4, 1), \
 	.vsel_range_reg = ATC2609A_PMU_LDO##num##_CTL0, \
 	atc2609a_reg_desc_ldo_bypass(0),
 	atc2609a_reg_desc_ldo_bypass(1),
 	atc2609a_reg_desc_ldo_bypass(2),
-	atc2609a_reg_desc_ldo_range_pick(3, 0),
+	atc2609a_reg_desc_ldo_range_pick(3, 0, 29),
-	atc2609a_reg_desc_ldo_range_pick(4, 0),
+	atc2609a_reg_desc_ldo_range_pick(4, 0, 29),
 	atc2609a_reg_desc_ldo(5),
-	atc2609a_reg_desc_ldo_range_pick(6, 1),
+	atc2609a_reg_desc_ldo_range_pick(6, 1, 28),
-	atc2609a_reg_desc_ldo_range_pick(7, 0),
+	atc2609a_reg_desc_ldo_range_pick(7, 0, 29),
-	atc2609a_reg_desc_ldo_range_pick(8, 0),
+	atc2609a_reg_desc_ldo_range_pick(8, 0, 29),
 	atc2609a_reg_desc_ldo_fixed(9),
 };

drivers/regulator/bd718x7-regulator.c+1−1

@@ -334,7 +334,7 @@ BD718XX_OPS(bd71837_buck_regulator_ops, regulator_list_voltage_linear_range, · 333 unmodified lines
334	NULL);	334	NULL);
335		335
336	BD718XX_OPS(bd71837_buck_regulator_nolinear_ops, regulator_list_voltage_table,	336	BD718XX_OPS(bd71837_buck_regulator_nolinear_ops, regulator_list_voltage_table,
337	regulator_map_voltage_ascend, bd718xx_set_voltage_sel_restricted,	337	regulator_map_voltage_ascend, bd71837_set_voltage_sel_restricted,
338	regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,	338	regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
339	NULL);	339	NULL);
340	/*	340	/*

drivers/regulator/core.c+6−0

 	 * and we have control then make sure it is enabled.
 	 */
 	if (rdev->constraints->always_on || rdev->constraints->boot_on) {
+		/* If we want to enable this regulator, make sure that we know
+		 * the supplying regulator.
+		 */
+		if (rdev->supply_name && !rdev->supply)
+			return -EPROBE_DEFER;
 		if (rdev->supply) {
 			ret = regulator_enable(rdev->supply);
 			if (ret < 0) {

drivers/regulator/cros-ec-regulator.c+2−1

@@ -225,8 +225,9 @@ static int cros_ec_regulator_probe(struct platform_device *pdev) · 224 unmodified lines
225		225
226	drvdata->dev = devm_regulator_register(dev, &drvdata->desc, &cfg);	226	drvdata->dev = devm_regulator_register(dev, &drvdata->desc, &cfg);
227	if (IS_ERR(drvdata->dev)) {	227	if (IS_ERR(drvdata->dev)) {
		228	ret = PTR_ERR(drvdata->dev);
228	dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);	229	dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);
229	return PTR_ERR(drvdata->dev);	230	return ret;
230	}	231	}
231		232
232	platform_set_drvdata(pdev, drvdata);	233	platform_set_drvdata(pdev, drvdata);

drivers/regulator/da9121-regulator.c+7−3

 	case DA9121_BUCK_MODE_FORCE_PFM:
 		return REGULATOR_MODE_STANDBY;
 	default:
-		return -EINVAL;
+		return REGULATOR_MODE_INVALID;
 	}
 }
 {
 	struct da9121 *chip = rdev_get_drvdata(rdev);
 	int id = rdev_get_id(rdev);
-	unsigned int val;
+	unsigned int val, mode;
 	int ret = 0;
 	ret = regmap_read(chip->regmap, da9121_mode_field[id].reg, &val);
 		return -EINVAL;
 	}
-	return da9121_map_mode(val & da9121_mode_field[id].msk);
+	mode = da9121_map_mode(val & da9121_mode_field[id].msk);
+	if (mode == REGULATOR_MODE_INVALID)
+		return -EINVAL;
+	return mode;
 }
 static const struct regulator_ops da9121_buck_ops = {

drivers/regulator/fan53555.c+1−2

 #define FAN53555_NVOLTAGES	64	/* Numbers of voltages */
 #define FAN53526_NVOLTAGES	128
-#define TCS4525_NVOLTAGES	127	/* Numbers of voltages */
 #define TCS_VSEL_NSEL_MASK	0x7f
 #define TCS_VSEL0_MODE		(1 << 7)
 	/* Init voltage range and step */
 	di->vsel_min = 600000;
 	di->vsel_step = 6250;
-	di->vsel_count = TCS4525_NVOLTAGES;
+	di->vsel_count = FAN53526_NVOLTAGES;
 	return 0;
 }

drivers/regulator/fan53880.c+3−0

 		      REGULATOR_LINEAR_RANGE(800000, 0xf, 0x73, 25000),	\
 		},							\
 		.n_linear_ranges = 2,					\
+		.n_voltages =	   0x74,				\
 		.vsel_reg =	   FAN53880_LDO ## _num ## VOUT,	\
 		.vsel_mask =	   0x7f,				\
 		.enable_reg =	   FAN53880_ENABLE,			\
 		      REGULATOR_LINEAR_RANGE(600000, 0x1f, 0xf7, 12500),
 		},
 		.n_linear_ranges = 2,
+		.n_voltages =	   0xf8,
 		.vsel_reg =	   FAN53880_BUCKVOUT,
 		.vsel_mask =	   0x7f,
 		.enable_reg =	   FAN53880_ENABLE,
 		      REGULATOR_LINEAR_RANGE(3000000, 0x4, 0x70, 25000),
 		},
 		.n_linear_ranges = 2,
+		.n_voltages =	   0x71,
 		.vsel_reg =	   FAN53880_BOOSTVOUT,
 		.vsel_mask =	   0x7f,
 		.enable_reg =	   FAN53880_ENABLE_BOOST,

drivers/regulator/fixed.c+6−1

 {
 	struct fixed_voltage_data *priv = rdev_get_drvdata(rdev);
 	struct device *dev = rdev->dev.parent;
+	int ret;
+	ret = dev_pm_genpd_set_performance_state(dev, 0);
+	if (ret)
+		return ret;
 	priv->enable_counter--;
-	return dev_pm_genpd_set_performance_state(dev, 0);
+	return 0;
 }
 static int reg_is_enabled(struct regulator_dev *rdev)

drivers/regulator/helpers.c+1−1

@@ -948,7 +948,7 @@ int regulator_set_ramp_delay_regmap(struct regulator_dev *rdev, int ramp_delay) · 947 unmodified lines
948	int ret;	948	int ret;
949	unsigned int sel;	949	unsigned int sel;
950		950
951	if (!rdev->desc->n_ramp_values)	951	if (WARN_ON(!rdev->desc->n_ramp_values \|\| !rdev->desc->ramp_delay_table))
952	return -EINVAL;	952	return -EINVAL;
953		953
954	ret = find_closest_bigger(ramp_delay, rdev->desc->ramp_delay_table,	954	ret = find_closest_bigger(ramp_delay, rdev->desc->ramp_delay_table,

drivers/regulator/hi6421v600-regulator.c+2−2

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	// Device driver for regulators in Hisi IC	3	// Device driver for regulators in Hisi IC
4	//	4	//
5	// Copyright (c) 2013 Linaro Ltd.	5	// Copyright (c) 2013 Linaro Ltd.
6	// Copyright (c) 2011 Hisilicon.	6	// Copyright (c) 2011 HiSilicon Ltd.
7	// Copyright (c) 2020-2021 Huawei Technologies Co., Ltd	7	// Copyright (c) 2020-2021 Huawei Technologies Co., Ltd
8	//	8	//
9	// Guodong Xu <guodong.xu@linaro.org>	9	// Guodong Xu <guodong.xu@linaro.org>
@@ -83,7 +83,7 @@ static const unsigned int ldo34_voltages[] = { · 73 unmodified lines
83	.owner = THIS_MODULE, \	83	.owner = THIS_MODULE, \
84	.volt_table = vtable, \	84	.volt_table = vtable, \
85	.n_voltages = ARRAY_SIZE(vtable), \	85	.n_voltages = ARRAY_SIZE(vtable), \
86	.vsel_mask = (1 << (ARRAY_SIZE(vtable) - 1)) - 1, \	86	.vsel_mask = ARRAY_SIZE(vtable) - 1, \
87	.vsel_reg = vreg, \	87	.vsel_reg = vreg, \
88	.enable_reg = ereg, \	88	.enable_reg = ereg, \
89	.enable_mask = emask, \	89	.enable_mask = emask, \

drivers/regulator/hi655x-regulator.c+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	//	2	//
3	// Device driver for regulators in Hi655x IC	3	// Device driver for regulators in Hi655x IC
4	//	4	//
5	// Copyright (c) 2016 Hisilicon.	5	// Copyright (c) 2016 HiSilicon Ltd.
6	//	6	//
7	// Authors:	7	// Authors:
8	// Chen Feng <puck.chen@hisilicon.com>	8	// Chen Feng <puck.chen@hisilicon.com>

drivers/regulator/max77620-regulator.c+11−6

 	config.dev = dev;
 	config.driver_data = pmic;
+	/*
+	 * Set of_node_reuse flag to prevent driver core from attempting to
+	 * claim any pinmux resources already claimed by the parent device.
+	 * Otherwise PMIC driver will fail to re-probe.
+	 */
+	device_set_of_node_from_dev(&pdev->dev, pdev->dev.parent);
 	for (id = 0; id < MAX77620_NUM_REGS; id++) {
 		struct regulator_dev *rdev;
 		struct regulator_desc *rdesc;
 			return ret;
 		rdev = devm_regulator_register(dev, rdesc, &config);
-		if (IS_ERR(rdev)) {
+		if (IS_ERR(rdev))
-			ret = PTR_ERR(rdev);
+			return dev_err_probe(dev, PTR_ERR(rdev),
-			dev_err(dev, "Regulator registration %s failed: %d\n",
+					     "Regulator registration %s failed\n",
-				rdesc->name, ret);
+					     rdesc->name);
-			return ret;
-		}
 	}
 	return 0;

drivers/regulator/mt6315-regulator.c+1−1

@@ -59,7 +59,7 @@ static const struct linear_range mt_volt_range1[] = { · 58 unmodified lines
59	REGULATOR_LINEAR_RANGE(0, 0, 0xbf, 6250),	59	REGULATOR_LINEAR_RANGE(0, 0, 0xbf, 6250),
60	};	60	};
61		61
62	static unsigned int mt6315_map_mode(u32 mode)	62	static unsigned int mt6315_map_mode(unsigned int mode)
63	{	63	{
64	switch (mode) {	64	switch (mode) {
65	case MT6315_BUCK_MODE_AUTO:	65	case MT6315_BUCK_MODE_AUTO:

drivers/regulator/rt4801-regulator.c+2−2

@@ -66,7 +66,7 @@ static int rt4801_enable(struct regulator_dev *rdev) · 65 unmodified lines
66	struct gpio_descs *gpios = priv->enable_gpios;	66	struct gpio_descs *gpios = priv->enable_gpios;
67	int id = rdev_get_id(rdev), ret;	67	int id = rdev_get_id(rdev), ret;
68		68
69	if (gpios->ndescs <= id) {	69	if (!gpios \|\| gpios->ndescs <= id) {
70	dev_warn(&rdev->dev, "no dedicated gpio can control\n");	70	dev_warn(&rdev->dev, "no dedicated gpio can control\n");
71	goto bypass_gpio;	71	goto bypass_gpio;
72	}	72	}
@@ -88,7 +88,7 @@ static int rt4801_disable(struct regulator_dev *rdev) · 15 unmodified lines
88	struct gpio_descs *gpios = priv->enable_gpios;	88	struct gpio_descs *gpios = priv->enable_gpios;
89	int id = rdev_get_id(rdev);	89	int id = rdev_get_id(rdev);
90		90
91	if (gpios->ndescs <= id) {	91	if (!gpios \|\| gpios->ndescs <= id) {
92	dev_warn(&rdev->dev, "no dedicated gpio can control\n");	92	dev_warn(&rdev->dev, "no dedicated gpio can control\n");
93	goto bypass_gpio;	93	goto bypass_gpio;
94	}	94	}

drivers/regulator/rtmv20-regulator.c+42−2

@@ -27,6 +27,7 @@ · 26 unmodified lines
27	#define RTMV20_REG_LDIRQ 0x30	27	#define RTMV20_REG_LDIRQ 0x30
28	#define RTMV20_REG_LDSTAT 0x40	28	#define RTMV20_REG_LDSTAT 0x40
29	#define RTMV20_REG_LDMASK 0x50	29	#define RTMV20_REG_LDMASK 0x50
		30	#define RTMV20_MAX_REGS (RTMV20_REG_LDMASK + 1)
30		31
31	#define RTMV20_VID_MASK GENMASK(7, 4)	32	#define RTMV20_VID_MASK GENMASK(7, 4)
32	#define RICHTEK_VID 0x80	33	#define RICHTEK_VID 0x80
@@ -103,9 +104,47 @@ static int rtmv20_lsw_disable(struct regulator_dev *rdev) · 70 unmodified lines
103	return 0;	104	return 0;
104	}	105	}
105		106
		107	static int rtmv20_lsw_set_current_limit(struct regulator_dev *rdev, int min_uA,
		108	int max_uA)
		109	{
		110	int sel;
		111
		112	if (min_uA > RTMV20_LSW_MAXUA \|\| max_uA < RTMV20_LSW_MINUA)
		113	return -EINVAL;
		114
		115	if (max_uA > RTMV20_LSW_MAXUA)
		116	max_uA = RTMV20_LSW_MAXUA;
		117
		118	sel = (max_uA - RTMV20_LSW_MINUA) / RTMV20_LSW_STEPUA;
		119
		120	/* Ensure the selected setting is still in range */
		121	if ((sel * RTMV20_LSW_STEPUA + RTMV20_LSW_MINUA) < min_uA)
		122	return -EINVAL;
		123
		124	sel <<= ffs(rdev->desc->csel_mask) - 1;
		125
		126	return regmap_update_bits(rdev->regmap, rdev->desc->csel_reg,
		127	rdev->desc->csel_mask, sel);
		128	}
		129
		130	static int rtmv20_lsw_get_current_limit(struct regulator_dev *rdev)
		131	{
		132	unsigned int val;
		133	int ret;
		134
		135	ret = regmap_read(rdev->regmap, rdev->desc->csel_reg, &val);
		136	if (ret)
		137	return ret;
		138
		139	val &= rdev->desc->csel_mask;
		140	val >>= ffs(rdev->desc->csel_mask) - 1;
		141
		142	return val * RTMV20_LSW_STEPUA + RTMV20_LSW_MINUA;
		143	}
		144
106	static const struct regulator_ops rtmv20_regulator_ops = {	145	static const struct regulator_ops rtmv20_regulator_ops = {
107	.set_current_limit = regulator_set_current_limit_regmap,	146	.set_current_limit = rtmv20_lsw_set_current_limit,
108	.get_current_limit = regulator_get_current_limit_regmap,	147	.get_current_limit = rtmv20_lsw_get_current_limit,
109	.enable = rtmv20_lsw_enable,	148	.enable = rtmv20_lsw_enable,
110	.disable = rtmv20_lsw_disable,	149	.disable = rtmv20_lsw_disable,
111	.is_enabled = regulator_is_enabled_regmap,	150	.is_enabled = regulator_is_enabled_regmap,
@@ -275,6 +314,7 @@ static const struct regmap_config rtmv20_regmap_config = { · 163 unmodified lines
275	.val_bits = 8,	314	.val_bits = 8,
276	.cache_type = REGCACHE_RBTREE,	315	.cache_type = REGCACHE_RBTREE,
277	.max_register = RTMV20_REG_LDMASK,	316	.max_register = RTMV20_REG_LDMASK,
		317	.num_reg_defaults_raw = RTMV20_MAX_REGS,
278		318
279	.writeable_reg = rtmv20_is_accessible_reg,	319	.writeable_reg = rtmv20_is_accessible_reg,
280	.readable_reg = rtmv20_is_accessible_reg,	320	.readable_reg = rtmv20_is_accessible_reg,

drivers/regulator/scmi-regulator.c+1−1

@@ -173,7 +173,7 @@ scmi_config_linear_regulator_mappings(struct scmi_regulator *sreg, · 172 unmodified lines
173	sreg->desc.uV_step =	173	sreg->desc.uV_step =
174	vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_STEP];	174	vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_STEP];
175	sreg->desc.linear_min_sel = 0;	175	sreg->desc.linear_min_sel = 0;
176	sreg->desc.n_voltages = delta_uV / sreg->desc.uV_step;	176	sreg->desc.n_voltages = (delta_uV / sreg->desc.uV_step) + 1;
177	sreg->desc.ops = &scmi_reg_linear_ops;	177	sreg->desc.ops = &scmi_reg_linear_ops;
178	}	178	}
179		179

drivers/scsi/hosts.c+26−21

 	device_enable_async_suspend(&shost->shost_dev);
+	get_device(&shost->shost_gendev);
 	error = device_add(&shost->shost_dev);
 	if (error)
 		goto out_del_gendev;
-	get_device(&shost->shost_gendev);
 	if (shost->transportt->host_size) {
 		shost->shost_data = kzalloc(shost->transportt->host_size,
 					 GFP_KERNEL);
 		if (!shost->work_q) {
 			error = -EINVAL;
-			goto out_free_shost_data;
+			goto out_del_dev;
 		}
 	}
 	error = scsi_sysfs_add_host(shost);
 	if (error)
-		goto out_destroy_host;
+		goto out_del_dev;
 	scsi_proc_host_add(shost);
 	scsi_autopm_put_host(shost);
 	return error;
- out_destroy_host:
+	/*
-	if (shost->work_q)
+	 * Any host allocation in this function will be freed in
-		destroy_workqueue(shost->work_q);
+	 * scsi_host_dev_release().
- out_free_shost_data:
+	 */
-	kfree(shost->shost_data);
  out_del_dev:
 	device_del(&shost->shost_dev);
  out_del_gendev:
+	/*
+	 * Host state is SHOST_RUNNING so we have to explicitly release
+	 * ->shost_dev.
+	 */
+	put_device(&shost->shost_dev);
 	device_del(&shost->shost_gendev);
  out_disable_runtime_pm:
 	device_disable_async_suspend(&shost->shost_gendev);
 	pm_runtime_disable(&shost->shost_gendev);
 	pm_runtime_set_suspended(&shost->shost_gendev);
 	pm_runtime_put_noidle(&shost->shost_gendev);
-	scsi_mq_destroy_tags(shost);
  fail:
 	return error;
 }
 	ida_simple_remove(&host_index_ida, shost->host_no);
-	if (parent)
+	if (shost->shost_state != SHOST_CREATED)
 		put_device(parent);
 	kfree(shost);
 }
 	mutex_init(&shost->scan_mutex);
 	index = ida_simple_get(&host_index_ida, 0, 0, GFP_KERNEL);
-	if (index < 0)
+	if (index < 0) {
-		goto fail_kfree;
+		kfree(shost);
+		return NULL;
+	}
 	shost->host_no = index;
 	shost->dma_channel = 0xff;
 		shost_printk(KERN_WARNING, shost,
 			"error handler thread failed to spawn, error = %ld\n",
 			PTR_ERR(shost->ehandler));
-		goto fail_index_remove;
+		goto fail;
 	}
 	shost->tmf_work_q = alloc_workqueue("scsi_tmf_%d",
 	if (!shost->tmf_work_q) {
 		shost_printk(KERN_WARNING, shost,
 			     "failed to create tmf workq\n");
-		goto fail_kthread;
+		goto fail;
 	}
 	scsi_proc_hostdir_add(shost->hostt);
 	return shost;
+ fail:
+	/*
+	 * Host state is still SHOST_CREATED and that is enough to release
+	 * ->shost_gendev. scsi_host_dev_release() will free
+	 * dev_name(&shost->shost_dev).
+	 */
+	put_device(&shost->shost_gendev);
- fail_kthread:
-	kthread_stop(shost->ehandler);
- fail_index_remove:
-	ida_simple_remove(&host_index_ida, shost->host_no);
- fail_kfree:
-	kfree(shost);
 	return NULL;
 }
 EXPORT_SYMBOL(scsi_host_alloc);

drivers/scsi/lpfc/lpfc_sli.c+1−3

 	abtswqe = &abtsiocb->wqe;
 	memset(abtswqe, 0, sizeof(*abtswqe));
-	if (lpfc_is_link_up(phba))
+	if (!lpfc_is_link_up(phba))
 		bf_set(abort_cmd_ia, &abtswqe->abort_cmd, 1);
-	else
-		bf_set(abort_cmd_ia, &abtswqe->abort_cmd, 0);
 	bf_set(abort_cmd_criteria, &abtswqe->abort_cmd, T_XRI_TAG);
 	abtswqe->abort_cmd.rsrvd5 = 0;
 	abtswqe->abort_cmd.wqe_com.abort_tag = xritag;

drivers/scsi/qedf/qedf_main.c+9−11

 		fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
 		QEDF_WARN(&(base_qedf->dbg_ctx), "Failed to create vport, "
 			   "WWPN (0x%s) already exists.\n", buf);
-		goto err1;
+		return rc;
 	}
 	if (atomic_read(&base_qedf->link_state) != QEDF_LINK_UP) {
 		QEDF_WARN(&(base_qedf->dbg_ctx), "Cannot create vport "
 			   "because link is not up.\n");
-		rc = -EIO;
+		return -EIO;
-		goto err1;
 	}
 	vn_port = libfc_vport_create(vport, sizeof(struct qedf_ctx));
 	if (!vn_port) {
 		QEDF_WARN(&(base_qedf->dbg_ctx), "Could not create lport "
 			   "for vport.\n");
-		rc = -ENOMEM;
+		return -ENOMEM;
-		goto err1;
 	}
 	fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
 	if (rc) {
 		QEDF_ERR(&(base_qedf->dbg_ctx), "Could not allocate memory "
 		    "for lport stats.\n");
-		goto err2;
+		goto err;
 	}
 	fc_set_wwnn(vn_port, vport->node_name);
 	if (rc) {
 		QEDF_WARN(&base_qedf->dbg_ctx,
 			  "Error adding Scsi_Host rc=0x%x.\n", rc);
-		goto err2;
+		goto err;
 	}
 	/* Set default dev_loss_tmo based on module parameter */
 	vport_qedf->dbg_ctx.host_no = vn_port->host->host_no;
 	vport_qedf->dbg_ctx.pdev = base_qedf->pdev;
-err2:
+	return 0;
+err:
 	scsi_host_put(vn_port->host);
-err1:
 	return rc;
 }
 	fc_lport_free_stats(vn_port);
 	/* Release Scsi_Host */
-	if (vn_port->host)
+	scsi_host_put(vn_port->host);
-		scsi_host_put(vn_port->host);
 out:
 	return 0;

drivers/scsi/scsi_devinfo.c+1−0

@@ -184,6 +184,7 @@ static struct { · 183 unmodified lines
184	{"HP", "C3323-300", "4269", BLIST_NOTQ},	184	{"HP", "C3323-300", "4269", BLIST_NOTQ},
185	{"HP", "C5713A", NULL, BLIST_NOREPORTLUN},	185	{"HP", "C5713A", NULL, BLIST_NOREPORTLUN},
186	{"HP", "DISK-SUBSYSTEM", "*", BLIST_REPORTLUN2},	186	{"HP", "DISK-SUBSYSTEM", "*", BLIST_REPORTLUN2},
		187	{"HPE", "OPEN-", "*", BLIST_REPORTLUN2 \| BLIST_TRY_VPD_PAGES},
187	{"IBM", "AuSaV1S2", NULL, BLIST_FORCELUN},	188	{"IBM", "AuSaV1S2", NULL, BLIST_FORCELUN},
188	{"IBM", "ProFibre 4000R", "*", BLIST_SPARSELUN \| BLIST_LARGELUN},	189	{"IBM", "ProFibre 4000R", "*", BLIST_SPARSELUN \| BLIST_LARGELUN},
189	{"IBM", "2105", NULL, BLIST_RETRY_HWERROR},	190	{"IBM", "2105", NULL, BLIST_RETRY_HWERROR},

drivers/scsi/ufs/ufs-mediatek.c+14−1

 	ret = ufshcd_dme_get(hba, UIC_ARG_MIB(PA_LOCALVERINFO), &ver);
 	if (!ret) {
-		if (ver >= UFS_UNIPRO_VER_1_8)
+		if (ver >= UFS_UNIPRO_VER_1_8) {
 			host->hw_ver.major = 3;
+			/*
+			 * Fix HCI version for some platforms with
+			 * incorrect version
+			 */
+			if (hba->ufs_version < ufshci_version(3, 0))
+				hba->ufs_version = ufshci_version(3, 0);
+		}
 	}
 }
+static u32 ufs_mtk_get_ufs_hci_version(struct ufs_hba *hba)
+{
+	return hba->ufs_version;
+}
 /**
  * ufs_mtk_init - find other essential mmio bases
  * @hba: host controller instance
 static const struct ufs_hba_variant_ops ufs_hba_mtk_vops = {
 	.name                = "mediatek.ufshci",
 	.init                = ufs_mtk_init,
+	.get_ufs_hci_version = ufs_mtk_get_ufs_hci_version,
 	.setup_clocks        = ufs_mtk_setup_clocks,
 	.hce_enable_notify   = ufs_mtk_hce_enable_notify,
 	.link_startup_notify = ufs_mtk_link_startup_notify,

drivers/soc/amlogic/meson-clk-measure.c+1−3

 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	base = devm_ioremap_resource(&pdev->dev, res);
-	if (IS_ERR(base)) {
+	if (IS_ERR(base))
-		dev_err(&pdev->dev, "io resource mapping failed\n");
 		return PTR_ERR(base);
-	}
 	priv->regmap = devm_regmap_init_mmio(&pdev->dev, base,
 					     &meson_clk_msr_regmap_config);

drivers/spi/spi-bcm2835.c+8−2

 #define BCM2835_SPI_FIFO_SIZE		64
 #define BCM2835_SPI_FIFO_SIZE_3_4	48
 #define BCM2835_SPI_DMA_MIN_LENGTH	96
-#define BCM2835_SPI_NUM_CS		4   /* raise as necessary */
+#define BCM2835_SPI_NUM_CS		24  /* raise as necessary */
 #define BCM2835_SPI_MODE_BITS	(SPI_CPOL | SPI_CPHA | SPI_CS_HIGH \
 				| SPI_NO_CS | SPI_3WIRE)
 	struct gpio_chip *chip;
 	u32 cs;
+	if (spi->chip_select >= BCM2835_SPI_NUM_CS) {
+		dev_err(&spi->dev, "only %d chip-selects supported\n",
+			BCM2835_SPI_NUM_CS - 1);
+		return -EINVAL;
+	}
 	/*
 	 * Precalculate SPI slave's CS register value for ->prepare_message():
 	 * The driver always uses software-controlled GPIO chip select, hence
 	ctlr->use_gpio_descriptors = true;
 	ctlr->mode_bits = BCM2835_SPI_MODE_BITS;
 	ctlr->bits_per_word_mask = SPI_BPW_MASK(8);
-	ctlr->num_chipselect = BCM2835_SPI_NUM_CS;
+	ctlr->num_chipselect = 3;
 	ctlr->setup = bcm2835_spi_setup;
 	ctlr->transfer_one = bcm2835_spi_transfer_one;
 	ctlr->handle_err = bcm2835_spi_handle_err;

drivers/spi/spi-bitbang.c+14−4

 {
 	struct spi_bitbang_cs	*cs = spi->controller_state;
 	struct spi_bitbang	*bitbang;
+	bool			initial_setup = false;
+	int			retval;
 	bitbang = spi_master_get_devdata(spi->master);
 		if (!cs)
 			return -ENOMEM;
 		spi->controller_state = cs;
+		initial_setup = true;
 	}
 	/* per-word shift register access, in hardware or bitbanging */
 	cs->txrx_word = bitbang->txrx_word[spi->mode & (SPI_CPOL|SPI_CPHA)];
-	if (!cs->txrx_word)
+	if (!cs->txrx_word) {
-		return -EINVAL;
+		retval = -EINVAL;
+		goto err_free;
+	}
 	if (bitbang->setup_transfer) {
-		int retval = bitbang->setup_transfer(spi, NULL);
+		retval = bitbang->setup_transfer(spi, NULL);
 		if (retval < 0)
-			return retval;
+			goto err_free;
 	}
 	dev_dbg(&spi->dev, "%s, %u nsec/bit\n", __func__, 2 * cs->nsecs);
 	return 0;
+err_free:
+	if (initial_setup)
+		kfree(cs);
+	return retval;
 }
 EXPORT_SYMBOL_GPL(spi_bitbang_setup);

drivers/spi/spi-fsl-spi.c+4−0

 {
 	struct mpc8xxx_spi *mpc8xxx_spi;
 	struct fsl_spi_reg __iomem *reg_base;
+	bool initial_setup = false;
 	int retval;
 	u32 hw_mode;
 	struct spi_mpc8xxx_cs *cs = spi_get_ctldata(spi);
 		if (!cs)
 			return -ENOMEM;
 		spi_set_ctldata(spi, cs);
+		initial_setup = true;
 	}
 	mpc8xxx_spi = spi_master_get_devdata(spi->master);
 	retval = fsl_spi_setup_transfer(spi, NULL);
 	if (retval < 0) {
 		cs->hw_mode = hw_mode; /* Restore settings */
+		if (initial_setup)
+			kfree(cs);
 		return retval;
 	}

drivers/spi/spi-omap-uwire.c+8−1

 static int uwire_setup(struct spi_device *spi)
 {
 	struct uwire_state *ust = spi->controller_state;
+	bool initial_setup = false;
+	int status;
 	if (ust == NULL) {
 		ust = kzalloc(sizeof(*ust), GFP_KERNEL);
 		if (ust == NULL)
 			return -ENOMEM;
 		spi->controller_state = ust;
+		initial_setup = true;
 	}
-	return uwire_setup_transfer(spi, NULL);
+	status = uwire_setup_transfer(spi, NULL);
+	if (status && initial_setup)
+		kfree(ust);
+	return status;
 }
 static void uwire_cleanup(struct spi_device *spi)

drivers/spi/spi-omap2-mcspi.c+20−13

 	}
 }
+static void omap2_mcspi_cleanup(struct spi_device *spi)
+{
+	struct omap2_mcspi_cs	*cs;
+	if (spi->controller_state) {
+		/* Unlink controller state from context save list */
+		cs = spi->controller_state;
+		list_del(&cs->node);
+		kfree(cs);
+	}
+}
 static int omap2_mcspi_setup(struct spi_device *spi)
 {
+	bool			initial_setup = false;
 	int			ret;
 	struct omap2_mcspi	*mcspi = spi_master_get_devdata(spi->master);
 	struct omap2_mcspi_regs	*ctx = &mcspi->ctx;
 		spi->controller_state = cs;
 		/* Link this to context save list */
 		list_add_tail(&cs->node, &ctx->cs);
+		initial_setup = true;
 	}
 	ret = pm_runtime_get_sync(mcspi->dev);
 	if (ret < 0) {
 		pm_runtime_put_noidle(mcspi->dev);
+		if (initial_setup)
+			omap2_mcspi_cleanup(spi);
 		return ret;
 	}
 	ret = omap2_mcspi_setup_transfer(spi, NULL);
+	if (ret && initial_setup)
+		omap2_mcspi_cleanup(spi);
 	pm_runtime_mark_last_busy(mcspi->dev);
 	pm_runtime_put_autosuspend(mcspi->dev);
 	return ret;
 }
-static void omap2_mcspi_cleanup(struct spi_device *spi)
-{
-	struct omap2_mcspi_cs	*cs;
-	if (spi->controller_state) {
-		/* Unlink controller state from context save list */
-		cs = spi->controller_state;
-		list_del(&cs->node);
-		kfree(cs);
-	}
-}
 static irqreturn_t omap2_mcspi_irq_handler(int irq, void *data)
 {
 	struct omap2_mcspi *mcspi = data;

drivers/spi/spi-pxa2xx.c+8−1

 		chip->gpio_cs_inverted = spi->mode & SPI_CS_HIGH;
 		err = gpiod_direction_output(gpiod, !chip->gpio_cs_inverted);
+		if (err)
+			gpiod_put(chip->gpiod_cs);
 	}
 	return err;
 	struct driver_data *drv_data =
 		spi_controller_get_devdata(spi->controller);
 	uint tx_thres, tx_hi_thres, rx_thres;
+	int err;
 	switch (drv_data->ssp_type) {
 	case QUARK_X1000_SSP:
 	if (drv_data->ssp_type == CE4100_SSP)
 		return 0;
-	return setup_cs(spi, chip, chip_info);
+	err = setup_cs(spi, chip, chip_info);
+	if (err)
+		kfree(chip);
+	return err;
 }
 static void cleanup(struct spi_device *spi)

drivers/spi/spi-stm32-qspi.c+4−1

 	int err = 0;
 	if (!op->data.nbytes)
-		return stm32_qspi_wait_nobusy(qspi);
+		goto wait_nobusy;
 	if (readl_relaxed(qspi->io_base + QSPI_SR) & SR_TCF)
 		goto out;
 out:
 	/* clear flags */
 	writel_relaxed(FCR_CTCF | FCR_CTEF, qspi->io_base + QSPI_FCR);
+wait_nobusy:
+	if (!err)
+		err = stm32_qspi_wait_nobusy(qspi);
 	return err;
 }

drivers/spi/spi-zynq-qspi.c+4−3

 	xqspi->irq = platform_get_irq(pdev, 0);
 	if (xqspi->irq <= 0) {
 		ret = -ENXIO;
-		goto remove_master;
+		goto clk_dis_all;
 	}
 	ret = devm_request_irq(&pdev->dev, xqspi->irq, zynq_qspi_irq,
 			       0, pdev->name, xqspi);
 	if (ret != 0) {
 		ret = -ENXIO;
 		dev_err(&pdev->dev, "request_irq failed\n");
-		goto remove_master;
+		goto clk_dis_all;
 	}
 	ret = of_property_read_u32(np, "num-cs",
 	if (ret < 0) {
 		ctlr->num_chipselect = 1;
 	} else if (num_cs > ZYNQ_QSPI_MAX_NUM_CS) {
+		ret = -EINVAL;
 		dev_err(&pdev->dev, "only 2 chip selects are available\n");
-		goto remove_master;
+		goto clk_dis_all;
 	} else {
 		ctlr->num_chipselect = num_cs;
 	}

drivers/staging/ralink-gdma/ralink-gdma.c+0−2

 // SPDX-License-Identifier: GPL-2.0+
 /*
- *  Copyright (C) 2013, Lars-Peter Clausen <lars@metafoo.de>
  *  GDMA4740 DMAC support
  */
 };
 module_platform_driver(gdma_dma_driver);
-MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
 MODULE_DESCRIPTION("Ralink/MTK DMA driver");
 MODULE_LICENSE("GPL v2");

drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c+1−1

@@ -2091,7 +2091,7 @@ void rtw_cfg80211_indicate_sta_assoc(struct adapter padapter, u8 pmgmt_frame, · 2090 unmodified lines
2091	struct net_device *ndev = padapter->pnetdev;	2091	struct net_device *ndev = padapter->pnetdev;
2092		2092
2093	{	2093	{
2094	struct station_info sinfo;	2094	struct station_info sinfo = {};
2095	u8 ie_offset;	2095	u8 ie_offset;
2096	if (GetFrameSubType(pmgmt_frame) == WIFI_ASSOCREQ)	2096	if (GetFrameSubType(pmgmt_frame) == WIFI_ASSOCREQ)
2097	ie_offset = _ASOCREQ_IE_OFFSET_;	2097	ie_offset = _ASOCREQ_IE_OFFSET_;

drivers/target/target_core_transport.c+1−3

@@ -3121,9 +3121,7 @@ __transport_wait_for_tasks(struct se_cmd *cmd, bool fabric_stop, · 3120 unmodified lines
3121	__releases(&cmd->t_state_lock)	3121	__releases(&cmd->t_state_lock)
3122	__acquires(&cmd->t_state_lock)	3122	__acquires(&cmd->t_state_lock)
3123	{	3123	{
3124		3124	lockdep_assert_held(&cmd->t_state_lock);
3125	assert_spin_locked(&cmd->t_state_lock);
3126	WARN_ON_ONCE(!irqs_disabled());
3127		3125
3128	if (fabric_stop)	3126	if (fabric_stop)
3129	cmd->transport_state \|= CMD_T_FABRIC_STOP;	3127	cmd->transport_state \|= CMD_T_FABRIC_STOP;

drivers/tee/optee/call.c+4−2

 	struct optee_msg_arg *msg_arg;
 	phys_addr_t msg_parg;
 	struct optee_session *sess = NULL;
+	uuid_t client_uuid;
 	/* +2 for the meta parameters added below */
 	shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg, &msg_parg);
 	memcpy(&msg_arg->params[0].u.value, arg->uuid, sizeof(arg->uuid));
 	msg_arg->params[1].u.value.c = arg->clnt_login;
-	rc = tee_session_calc_client_uuid((uuid_t *)&msg_arg->params[1].u.value,
+	rc = tee_session_calc_client_uuid(&client_uuid, arg->clnt_login,
-					  arg->clnt_login, arg->clnt_uuid);
+					  arg->clnt_uuid);
 	if (rc)
 		goto out;
+	export_uuid(msg_arg->params[1].u.octets, &client_uuid);
 	rc = optee_to_msg_param(msg_arg->params + 2, arg->num_params, param);
 	if (rc)

drivers/tee/optee/optee_msg.h+4−2

 #include <linux/types.h>
 /*
- * This file defines the OP-TEE message protocol used to communicate
+ * This file defines the OP-TEE message protocol (ABI) used to communicate
  * with an instance of OP-TEE running in secure world.
  *
  * This file is divided into two sections.
  * @tmem:	parameter by temporary memory reference
  * @rmem:	parameter by registered memory reference
  * @value:	parameter by opaque value
+ * @octets:	parameter by octet string
  *
  * @attr & OPTEE_MSG_ATTR_TYPE_MASK indicates if tmem, rmem or value is used in
- * the union. OPTEE_MSG_ATTR_TYPE_VALUE_* indicates value,
+ * the union. OPTEE_MSG_ATTR_TYPE_VALUE_* indicates value or octets,
  * OPTEE_MSG_ATTR_TYPE_TMEM_* indicates @tmem and
  * OPTEE_MSG_ATTR_TYPE_RMEM_* indicates @rmem,
  * OPTEE_MSG_ATTR_TYPE_NONE indicates that none of the members are used.
 		struct optee_msg_param_tmem tmem;
 		struct optee_msg_param_rmem rmem;
 		struct optee_msg_param_value value;
+		u8 octets[24];
 	} u;
 };

drivers/thermal/intel/therm_throt.c+11−4

 	return atomic_read(&therm_throt_en);
 }
+void __init therm_lvt_init(void)
+{
+	/*
+	 * This function is only called on boot CPU. Save the init thermal
+	 * LVT value on BSP and use that value to restore APs' thermal LVT
+	 * entry BIOS programmed later
+	 */
+	if (intel_thermal_supported(&boot_cpu_data))
+		lvtthmr_init = apic_read(APIC_LVTTHMR);
+}
 void intel_init_thermal(struct cpuinfo_x86 *c)
 {
 	unsigned int cpu = smp_processor_id();
 	if (!intel_thermal_supported(c))
 		return;
-	/* On the BSP? */
-	if (c == &boot_cpu_data)
-		lvtthmr_init = apic_read(APIC_LVTTHMR);
 	/*
 	 * First check if its enabled already, in which case there might
 	 * be some SMM goo which handles it, so we can't even put a handler

drivers/tty/serial/8250/8250_exar.c+5−1

 {
 	struct exar8250 *priv = pci_get_drvdata(pcidev);
 	struct uart_8250_port *port = serial8250_get_port(priv->line[0]);
-	struct platform_device *pdev = port->port.private_data;
+	struct platform_device *pdev;
+	pdev = port->port.private_data;
+	if (!pdev)
+		return;
 	device_remove_software_node(&pdev->dev);
 	platform_device_unregister(pdev);

drivers/usb/cdns3/cdns3-gadget.c+3−5

 		else
 			mask = BIT(priv_ep->num);
-		if (priv_ep->type != USB_ENDPOINT_XFER_ISOC) {
+		if (priv_ep->type != USB_ENDPOINT_XFER_ISOC  && !priv_ep->dir) {
 			cdns3_set_register_bit(&regs->tdl_from_trb, mask);
 			cdns3_set_register_bit(&regs->tdl_beh, mask);
 			cdns3_set_register_bit(&regs->tdl_beh2, mask);
 	case USB_ENDPOINT_XFER_INT:
 		ep_cfg = EP_CFG_EPTYPE(USB_ENDPOINT_XFER_INT);
-		if ((priv_dev->dev_ver == DEV_VER_V2 && !priv_ep->dir) ||
+		if (priv_dev->dev_ver >= DEV_VER_V2 && !priv_ep->dir)
-		    priv_dev->dev_ver > DEV_VER_V2)
 			ep_cfg |= EP_CFG_TDL_CHK;
 		break;
 	case USB_ENDPOINT_XFER_BULK:
 		ep_cfg = EP_CFG_EPTYPE(USB_ENDPOINT_XFER_BULK);
-		if ((priv_dev->dev_ver == DEV_VER_V2  && !priv_ep->dir) ||
+		if (priv_dev->dev_ver >= DEV_VER_V2 && !priv_ep->dir)
-		    priv_dev->dev_ver > DEV_VER_V2)
 			ep_cfg |= EP_CFG_TDL_CHK;
 		break;
 	default:

drivers/usb/cdns3/cdnsp-ring.c+4−3

 {
 	struct cdnsp_device *pdev = (struct cdnsp_device *)data;
 	union cdnsp_trb *event_ring_deq;
+	unsigned long flags;
 	int counter = 0;
-	spin_lock(&pdev->lock);
+	spin_lock_irqsave(&pdev->lock, flags);
 	if (pdev->cdnsp_state & (CDNSP_STATE_HALTED | CDNSP_STATE_DYING)) {
 		cdnsp_died(pdev);
-		spin_unlock(&pdev->lock);
+		spin_unlock_irqrestore(&pdev->lock, flags);
 		return IRQ_HANDLED;
 	}
 	cdnsp_update_erst_dequeue(pdev, event_ring_deq, 1);
-	spin_unlock(&pdev->lock);
+	spin_unlock_irqrestore(&pdev->lock, flags);
 	return IRQ_HANDLED;
 }

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

 	return 0;
 }
-static void dwc3_shutdown(struct platform_device *pdev)
-{
-	dwc3_remove(pdev);
-}
 #ifdef CONFIG_PM
 static int dwc3_core_init_for_resume(struct dwc3 *dwc)
 {
 static struct platform_driver dwc3_driver = {
 	.probe		= dwc3_probe,
 	.remove		= dwc3_remove,
-	.shutdown   = dwc3_shutdown,
 	.driver		= {
 		.name	= "dwc3",
 		.of_match_table	= of_match_ptr(of_dwc3_match),

drivers/usb/dwc3/debug.h+3−0

 #ifdef CONFIG_DEBUG_FS
+extern void dwc3_debugfs_create_endpoint_dir(struct dwc3_ep *dep);
 extern void dwc3_debugfs_init(struct dwc3 *d);
 extern void dwc3_debugfs_exit(struct dwc3 *d);
 #else
+static inline void dwc3_debugfs_create_endpoint_dir(struct dwc3_ep *dep)
+{  }
 static inline void dwc3_debugfs_init(struct dwc3 *d)
 {  }
 static inline void dwc3_debugfs_exit(struct dwc3 *d)

drivers/usb/dwc3/debugfs.c+2−19

 	}
 }
-static void dwc3_debugfs_create_endpoint_dir(struct dwc3_ep *dep,
+void dwc3_debugfs_create_endpoint_dir(struct dwc3_ep *dep)
-		struct dentry *parent)
 {
 	struct dentry		*dir;
-	dir = debugfs_create_dir(dep->name, parent);
+	dir = debugfs_create_dir(dep->name, dep->dwc->root);
 	dwc3_debugfs_create_endpoint_files(dep, dir);
 }
-static void dwc3_debugfs_create_endpoint_dirs(struct dwc3 *dwc,
-		struct dentry *parent)
-{
-	int			i;
-	for (i = 0; i < dwc->num_eps; i++) {
-		struct dwc3_ep	*dep = dwc->eps[i];
-		if (!dep)
-			continue;
-		dwc3_debugfs_create_endpoint_dir(dep, parent);
-	}
-}
 void dwc3_debugfs_init(struct dwc3 *dwc)
 {
 	struct dentry		*root;
 				&dwc3_testmode_fops);
 		debugfs_create_file("link_state", 0644, root, dwc,
 				    &dwc3_link_state_fops);
-		dwc3_debugfs_create_endpoint_dirs(dwc, root);
 	}
 }

drivers/usb/dwc3/dwc3-meson-g12a.c+10−3

 		return PTR_ERR(priv->usb_glue_regmap);
 	/* Create a regmap for each USB2 PHY control register set */
-	for (i = 0; i < priv->usb2_ports; i++) {
+	for (i = 0; i < priv->drvdata->num_phys; i++) {
 		struct regmap_config u2p_regmap_config = {
 			.reg_bits = 8,
 			.val_bits = 32,
 			.max_register = U2P_R1,
 		};
+		if (!strstr(priv->drvdata->phy_names[i], "usb2"))
+			continue;
 		u2p_regmap_config.name = devm_kasprintf(priv->dev, GFP_KERNEL,
 							"u2p-%d", i);
 		if (!u2p_regmap_config.name)
 	ret = priv->drvdata->usb_init(priv);
 	if (ret)
-		goto err_disable_clks;
+		goto err_disable_regulator;
 	/* Init PHYs */
 	for (i = 0 ; i < PHY_COUNT ; ++i) {
 		ret = phy_init(priv->phys[i]);
 		if (ret)
-			goto err_disable_clks;
+			goto err_disable_regulator;
 	}
 	/* Set PHY Power */
 	for (i = 0 ; i < PHY_COUNT ; ++i)
 		phy_exit(priv->phys[i]);
+err_disable_regulator:
+	if (priv->vbus)
+		regulator_disable(priv->vbus);
 err_disable_clks:
 	clk_bulk_disable_unprepare(priv->drvdata->num_clks,
 				   priv->drvdata->clks);

drivers/usb/dwc3/ep0.c+3−0

@@ -292,6 +292,9 @@ static struct dwc3_ep dwc3_wIndex_to_dep(struct dwc3 dwc, __le16 wIndex_le) · 291 unmodified lines
292	epnum \|= 1;	292	epnum \|= 1;
293		293
294	dep = dwc->eps[epnum];	294	dep = dwc->eps[epnum];
		295	if (dep == NULL)
		296	return NULL;
		297
295	if (dep->flags & DWC3_EP_ENABLED)	298	if (dep->flags & DWC3_EP_ENABLED)
296	return dep;	299	return dep;
297		300

drivers/usb/dwc3/gadget.c+12−6

 	}
 	/*
-	 * Synchronize any pending event handling before executing the controller
+	 * Synchronize and disable any further event handling while controller
-	 * halt routine.
+	 * is being enabled/disabled.
 	 */
-	if (!is_on) {
+	disable_irq(dwc->irq_gadget);
-		dwc3_gadget_disable_irq(dwc);
-		synchronize_irq(dwc->irq_gadget);
-	}
 	spin_lock_irqsave(&dwc->lock, flags);
 	ret = dwc3_gadget_run_stop(dwc, is_on, false);
 	spin_unlock_irqrestore(&dwc->lock, flags);
+	enable_irq(dwc->irq_gadget);
 	pm_runtime_put(dwc->dev);
 	return ret;
 	INIT_LIST_HEAD(&dep->started_list);
 	INIT_LIST_HEAD(&dep->cancelled_list);
+	dwc3_debugfs_create_endpoint_dir(dep);
 	return 0;
 }
 			list_del(&dep->endpoint.ep_list);
 		}
+		debugfs_remove_recursive(debugfs_lookup(dep->name, dwc->root));
 		kfree(dep);
 	}
 }
 	dwc3_gadget_free_endpoints(dwc);
 err4:
 	usb_put_gadget(dwc->gadget);
+	dwc->gadget = NULL;
 err3:
 	dma_free_coherent(dwc->sysdev, DWC3_BOUNCE_SIZE, dwc->bounce,
 			dwc->bounce_addr);
 void dwc3_gadget_exit(struct dwc3 *dwc)
 {
+	if (!dwc->gadget)
+		return;
 	usb_del_gadget(dwc->gadget);
 	dwc3_gadget_free_endpoints(dwc);
 	usb_put_gadget(dwc->gadget);

drivers/usb/gadget/config.c+8−0

@@ -164,6 +164,14 @@ int usb_assign_descriptors(struct usb_function *f, · 163 unmodified lines
164	{	164	{
165	struct usb_gadget *g = f->config->cdev->gadget;	165	struct usb_gadget *g = f->config->cdev->gadget;
166		166
		167	/* super-speed-plus descriptor falls back to super-speed one,
		168	* if such a descriptor was provided, thus avoiding a NULL
		169	* pointer dereference if a 5gbps capable gadget is used with
		170	* a 10gbps capable config (device port + cable + host port)
		171	*/
		172	if (!ssp)
		173	ssp = ss;
		174
167	if (fs) {	175	if (fs) {
168	f->fs_descriptors = usb_copy_descriptors(fs);	176	f->fs_descriptors = usb_copy_descriptors(fs);
169	if (!f->fs_descriptors)	177	if (!f->fs_descriptors)

drivers/usb/gadget/function/f_ecm.c+1−1

@@ -791,7 +791,7 @@ ecm_bind(struct usb_configuration c, struct usb_function f) · 790 unmodified lines
791	fs_ecm_notify_desc.bEndpointAddress;	791	fs_ecm_notify_desc.bEndpointAddress;
792		792
793	status = usb_assign_descriptors(f, ecm_fs_function, ecm_hs_function,	793	status = usb_assign_descriptors(f, ecm_fs_function, ecm_hs_function,
794	ecm_ss_function, NULL);	794	ecm_ss_function, ecm_ss_function);
795	if (status)	795	if (status)
796	goto fail;	796	goto fail;
797		797

drivers/usb/gadget/function/f_eem.c+3−3

@@ -302,7 +302,7 @@ static int eem_bind(struct usb_configuration c, struct usb_function f) · 301 unmodified lines
302	eem_ss_out_desc.bEndpointAddress = eem_fs_out_desc.bEndpointAddress;	302	eem_ss_out_desc.bEndpointAddress = eem_fs_out_desc.bEndpointAddress;
303		303
304	status = usb_assign_descriptors(f, eem_fs_function, eem_hs_function,	304	status = usb_assign_descriptors(f, eem_fs_function, eem_hs_function,
305	eem_ss_function, NULL);	305	eem_ss_function, eem_ss_function);
306	if (status)	306	if (status)
307	goto fail;	307	goto fail;
308		308
@@ -495,7 +495,7 @@ static int eem_unwrap(struct gether *port, · 186 unmodified lines
495	skb2 = skb_clone(skb, GFP_ATOMIC);	495	skb2 = skb_clone(skb, GFP_ATOMIC);
496	if (unlikely(!skb2)) {	496	if (unlikely(!skb2)) {
497	DBG(cdev, "unable to unframe EEM packet\n");	497	DBG(cdev, "unable to unframe EEM packet\n");
498	continue;	498	goto next;
499	}	499	}
500	skb_trim(skb2, len - ETH_FCS_LEN);	500	skb_trim(skb2, len - ETH_FCS_LEN);
501		501
@@ -505,7 +505,7 @@ static int eem_unwrap(struct gether *port, · 3 unmodified lines
505	GFP_ATOMIC);	505	GFP_ATOMIC);
506	if (unlikely(!skb3)) {	506	if (unlikely(!skb3)) {
507	dev_kfree_skb_any(skb2);	507	dev_kfree_skb_any(skb2);
508	continue;	508	goto next;
509	}	509	}
510	dev_kfree_skb_any(skb2);	510	dev_kfree_skb_any(skb2);
511	skb_queue_tail(list, skb3);	511	skb_queue_tail(list, skb3);

drivers/usb/gadget/function/f_fs.c+3−0

@@ -3567,6 +3567,9 @@ static void ffs_func_unbind(struct usb_configuration *c, · 3566 unmodified lines
3567	ffs->func = NULL;	3567	ffs->func = NULL;
3568	}	3568	}
3569		3569
		3570	/* Drain any pending AIO completions */
		3571	drain_workqueue(ffs->io_completion_wq);
		3572
3570	if (!--opts->refcnt)	3573	if (!--opts->refcnt)
3571	functionfs_unbind(ffs);	3574	functionfs_unbind(ffs);
3572		3575

drivers/usb/gadget/function/f_hid.c+2−1

@@ -802,7 +802,8 @@ static int hidg_bind(struct usb_configuration c, struct usb_function f) · 801 unmodified lines
802	hidg_fs_out_ep_desc.bEndpointAddress;	802	hidg_fs_out_ep_desc.bEndpointAddress;
803		803
804	status = usb_assign_descriptors(f, hidg_fs_descriptors,	804	status = usb_assign_descriptors(f, hidg_fs_descriptors,
805	hidg_hs_descriptors, hidg_ss_descriptors, NULL);	805	hidg_hs_descriptors, hidg_ss_descriptors,
		806	hidg_ss_descriptors);
806	if (status)	807	if (status)
807	goto fail;	808	goto fail;
808		809

drivers/usb/gadget/function/f_loopback.c+1−1

@@ -207,7 +207,7 @@ autoconf_fail: · 206 unmodified lines
207	ss_loop_sink_desc.bEndpointAddress = fs_loop_sink_desc.bEndpointAddress;	207	ss_loop_sink_desc.bEndpointAddress = fs_loop_sink_desc.bEndpointAddress;
208		208
209	ret = usb_assign_descriptors(f, fs_loopback_descs, hs_loopback_descs,	209	ret = usb_assign_descriptors(f, fs_loopback_descs, hs_loopback_descs,
210	ss_loopback_descs, NULL);	210	ss_loopback_descs, ss_loopback_descs);
211	if (ret)	211	if (ret)
212	return ret;	212	return ret;
213		213

drivers/usb/gadget/function/f_ncm.c+5−5

 		data[0] = cpu_to_le32(ncm_bitrate(cdev->gadget));
 		data[1] = data[0];
-		DBG(cdev, "notify speed %d\n", ncm_bitrate(cdev->gadget));
+		DBG(cdev, "notify speed %u\n", ncm_bitrate(cdev->gadget));
 		ncm->notify_state = NCM_NOTIFY_CONNECT;
 		break;
 	}
 			ncm->ndp_dgram_count = 1;
 			/* Note: we skip opts->next_ndp_index */
-		}
-		/* Delay the timer. */
+			/* Start the timer. */
-		hrtimer_start(&ncm->task_timer, TX_TIMEOUT_NSECS,
+			hrtimer_start(&ncm->task_timer, TX_TIMEOUT_NSECS,
-			      HRTIMER_MODE_REL_SOFT);
+				      HRTIMER_MODE_REL_SOFT);
+		}
 		/* Add the datagram position entries */
 		ntb_ndp = skb_put_zero(ncm->skb_tx_ndp, dgram_idx_len);

drivers/usb/gadget/function/f_printer.c+2−1

@@ -1101,7 +1101,8 @@ autoconf_fail: · 1100 unmodified lines
1101	ss_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;	1101	ss_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
1102		1102
1103	ret = usb_assign_descriptors(f, fs_printer_function,	1103	ret = usb_assign_descriptors(f, fs_printer_function,
1104	hs_printer_function, ss_printer_function, NULL);	1104	hs_printer_function, ss_printer_function,
		1105	ss_printer_function);
1105	if (ret)	1106	if (ret)
1106	return ret;	1107	return ret;
1107		1108

drivers/usb/gadget/function/f_rndis.c+1−1

@@ -789,7 +789,7 @@ rndis_bind(struct usb_configuration c, struct usb_function f) · 788 unmodified lines
789	ss_notify_desc.bEndpointAddress = fs_notify_desc.bEndpointAddress;	789	ss_notify_desc.bEndpointAddress = fs_notify_desc.bEndpointAddress;
790		790
791	status = usb_assign_descriptors(f, eth_fs_function, eth_hs_function,	791	status = usb_assign_descriptors(f, eth_fs_function, eth_hs_function,
792	eth_ss_function, NULL);	792	eth_ss_function, eth_ss_function);
793	if (status)	793	if (status)
794	goto fail;	794	goto fail;
795		795

drivers/usb/gadget/function/f_serial.c+1−1

@@ -233,7 +233,7 @@ static int gser_bind(struct usb_configuration c, struct usb_function f) · 232 unmodified lines
233	gser_ss_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress;	233	gser_ss_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress;
234		234
235	status = usb_assign_descriptors(f, gser_fs_function, gser_hs_function,	235	status = usb_assign_descriptors(f, gser_fs_function, gser_hs_function,
236	gser_ss_function, NULL);	236	gser_ss_function, gser_ss_function);
237	if (status)	237	if (status)
238	goto fail;	238	goto fail;
239	dev_dbg(&cdev->gadget->dev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",	239	dev_dbg(&cdev->gadget->dev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",

drivers/usb/gadget/function/f_sourcesink.c+2−1

@@ -431,7 +431,8 @@ no_iso: · 430 unmodified lines
431	ss_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;	431	ss_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
432		432
433	ret = usb_assign_descriptors(f, fs_source_sink_descs,	433	ret = usb_assign_descriptors(f, fs_source_sink_descs,
434	hs_source_sink_descs, ss_source_sink_descs, NULL);	434	hs_source_sink_descs, ss_source_sink_descs,
		435	ss_source_sink_descs);
435	if (ret)	436	if (ret)
436	return ret;	437	return ret;
437		438

drivers/usb/gadget/function/f_subset.c+1−1

@@ -358,7 +358,7 @@ geth_bind(struct usb_configuration c, struct usb_function f) · 357 unmodified lines
358	fs_subset_out_desc.bEndpointAddress;	358	fs_subset_out_desc.bEndpointAddress;
359		359
360	status = usb_assign_descriptors(f, fs_eth_function, hs_eth_function,	360	status = usb_assign_descriptors(f, fs_eth_function, hs_eth_function,
361	ss_eth_function, NULL);	361	ss_eth_function, ss_eth_function);
362	if (status)	362	if (status)
363	goto fail;	363	goto fail;
364		364

drivers/usb/gadget/function/f_tcm.c+2−1

@@ -2057,7 +2057,8 @@ static int tcm_bind(struct usb_configuration c, struct usb_function f) · 2056 unmodified lines
2057	uasp_fs_cmd_desc.bEndpointAddress = uasp_ss_cmd_desc.bEndpointAddress;	2057	uasp_fs_cmd_desc.bEndpointAddress = uasp_ss_cmd_desc.bEndpointAddress;
2058		2058
2059	ret = usb_assign_descriptors(f, uasp_fs_function_desc,	2059	ret = usb_assign_descriptors(f, uasp_fs_function_desc,
2060	uasp_hs_function_desc, uasp_ss_function_desc, NULL);	2060	uasp_hs_function_desc, uasp_ss_function_desc,
		2061	uasp_ss_function_desc);
2061	if (ret)	2062	if (ret)
2062	goto ep_fail;	2063	goto ep_fail;
2063		2064

drivers/usb/host/xhci-pci.c+6−1

 #define PCI_DEVICE_ID_INTEL_MAPLE_RIDGE_XHCI		0x1138
 #define PCI_DEVICE_ID_INTEL_ALDER_LAKE_XHCI		0x461e
+#define PCI_DEVICE_ID_AMD_RENOIR_XHCI			0x1639
 #define PCI_DEVICE_ID_AMD_PROMONTORYA_4			0x43b9
 #define PCI_DEVICE_ID_AMD_PROMONTORYA_3			0x43ba
 #define PCI_DEVICE_ID_AMD_PROMONTORYA_2			0x43bb
 		(pdev->device == PCI_DEVICE_ID_AMD_PROMONTORYA_1)))
 		xhci->quirks |= XHCI_U2_DISABLE_WAKE;
+	if (pdev->vendor == PCI_VENDOR_ID_AMD &&
+		pdev->device == PCI_DEVICE_ID_AMD_RENOIR_XHCI)
+		xhci->quirks |= XHCI_BROKEN_D3COLD;
 	if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
 		xhci->quirks |= XHCI_LPM_SUPPORT;
 		xhci->quirks |= XHCI_INTEL_HOST;
 	 * Systems with the TI redriver that loses port status change events
 	 * need to have the registers polled during D3, so avoid D3cold.
 	 */
-	if (xhci->quirks & XHCI_COMP_MODE_QUIRK)
+	if (xhci->quirks & (XHCI_COMP_MODE_QUIRK | XHCI_BROKEN_D3COLD))
 		pci_d3cold_disable(pdev);
 	if (xhci->quirks & XHCI_PME_STUCK_QUIRK)

drivers/usb/host/xhci.h+1−0

@@ -1892,6 +1892,7 @@ struct xhci_hcd { · 1891 unmodified lines
1892	#define XHCI_DISABLE_SPARSE BIT_ULL(38)	1892	#define XHCI_DISABLE_SPARSE BIT_ULL(38)
1893	#define XHCI_SG_TRB_CACHE_SIZE_QUIRK BIT_ULL(39)	1893	#define XHCI_SG_TRB_CACHE_SIZE_QUIRK BIT_ULL(39)
1894	#define XHCI_NO_SOFT_RETRY BIT_ULL(40)	1894	#define XHCI_NO_SOFT_RETRY BIT_ULL(40)
		1895	#define XHCI_BROKEN_D3COLD BIT_ULL(41)
1895		1896
1896	unsigned int num_active_eps;	1897	unsigned int num_active_eps;
1897	unsigned int limit_active_eps;	1898	unsigned int limit_active_eps;

drivers/usb/misc/brcmstb-usb-pinmap.c+2−0

@@ -263,6 +263,8 @@ static int __init brcmstb_usb_pinmap_probe(struct platform_device *pdev) · 262 unmodified lines
263	return -EINVAL;	263	return -EINVAL;
264		264
265	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);	265	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
		266	if (!r)
		267	return -EINVAL;
266		268
267	pdata = devm_kzalloc(&pdev->dev,	269	pdata = devm_kzalloc(&pdev->dev,
268	sizeof(*pdata) +	270	sizeof(*pdata) +

drivers/usb/musb/musb_core.c+1−2

 			schedule_delayed_work(&musb->irq_work,
 					      msecs_to_jiffies(1000));
 			musb->quirk_retries--;
-			break;
 		}
-		fallthrough;
+		break;
 	case MUSB_QUIRK_B_INVALID_VBUS_91:
 		if (musb->quirk_retries && !musb->flush_irq_work) {
 			musb_dbg(musb,

drivers/usb/serial/cp210x.c+78−6

@@ -252,9 +252,11 @@ struct cp210x_serial_private { · 251 unmodified lines
252	u8 gpio_input;	252	u8 gpio_input;
253	#endif	253	#endif
254	u8 partnum;	254	u8 partnum;
		255	u32 fw_version;
255	speed_t min_speed;	256	speed_t min_speed;
256	speed_t max_speed;	257	speed_t max_speed;
257	bool use_actual_rate;	258	bool use_actual_rate;
		259	bool no_flow_control;
258	};	260	};
259		261
260	enum cp210x_event_state {	262	enum cp210x_event_state {
@@ -398,6 +400,7 @@ struct cp210x_special_chars { · 137 unmodified lines
398		400
399	/* CP210X_VENDOR_SPECIFIC values */	401	/* CP210X_VENDOR_SPECIFIC values */
400	#define CP210X_READ_2NCONFIG 0x000E	402	#define CP210X_READ_2NCONFIG 0x000E
		403	#define CP210X_GET_FW_VER_2N 0x0010
401	#define CP210X_READ_LATCH 0x00C2	404	#define CP210X_READ_LATCH 0x00C2
402	#define CP210X_GET_PARTNUM 0x370B	405	#define CP210X_GET_PARTNUM 0x370B
403	#define CP210X_GET_PORTCONFIG 0x370C	406	#define CP210X_GET_PORTCONFIG 0x370C
@@ -537,6 +540,12 @@ struct cp210x_single_port_config { · 133 unmodified lines
537	#define CP210X_2NCONFIG_GPIO_RSTLATCH_IDX 587	540	#define CP210X_2NCONFIG_GPIO_RSTLATCH_IDX 587
538	#define CP210X_2NCONFIG_GPIO_CONTROL_IDX 600	541	#define CP210X_2NCONFIG_GPIO_CONTROL_IDX 600
539		542
		543	/* CP2102N QFN20 port configuration values */
		544	#define CP2102N_QFN20_GPIO2_TXLED_MODE BIT(2)
		545	#define CP2102N_QFN20_GPIO3_RXLED_MODE BIT(3)
		546	#define CP2102N_QFN20_GPIO1_RS485_MODE BIT(4)
		547	#define CP2102N_QFN20_GPIO0_CLK_MODE BIT(6)
		548
540	/* CP210X_VENDOR_SPECIFIC, CP210X_WRITE_LATCH call writes these 0x2 bytes. */	549	/* CP210X_VENDOR_SPECIFIC, CP210X_WRITE_LATCH call writes these 0x2 bytes. */
541	struct cp210x_gpio_write {	550	struct cp210x_gpio_write {
542	u8 mask;	551	u8 mask;
@@ -1122,6 +1131,7 @@ static bool cp210x_termios_change(const struct ktermios *a, const struct ktermio · 579 unmodified lines
1122	static void cp210x_set_flow_control(struct tty_struct *tty,	1131	static void cp210x_set_flow_control(struct tty_struct *tty,
1123	struct usb_serial_port port, struct ktermios old_termios)	1132	struct usb_serial_port port, struct ktermios old_termios)
1124	{	1133	{
		1134	struct cp210x_serial_private *priv = usb_get_serial_data(port->serial);
1125	struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);	1135	struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
1126	struct cp210x_special_chars chars;	1136	struct cp210x_special_chars chars;
1127	struct cp210x_flow_ctl flow_ctl;	1137	struct cp210x_flow_ctl flow_ctl;
@@ -1129,6 +1139,15 @@ static void cp210x_set_flow_control(struct tty_struct *tty, · 1 unmodified line
1129	u32 ctl_hs;	1139	u32 ctl_hs;
1130	int ret;	1140	int ret;
1131		1141
		1142	/*
		1143	* Some CP2102N interpret ulXonLimit as ulFlowReplace (erratum
		1144	* CP2102N_E104). Report back that flow control is not supported.
		1145	*/
		1146	if (priv->no_flow_control) {
		1147	tty->termios.c_cflag &= ~CRTSCTS;
		1148	tty->termios.c_iflag &= ~(IXON \| IXOFF);
		1149	}
		1150
1132	if (old_termios &&	1151	if (old_termios &&
1133	C_CRTSCTS(tty) == (old_termios->c_cflag & CRTSCTS) &&	1152	C_CRTSCTS(tty) == (old_termios->c_cflag & CRTSCTS) &&
1134	I_IXON(tty) == (old_termios->c_iflag & IXON) &&	1153	I_IXON(tty) == (old_termios->c_iflag & IXON) &&
@@ -1185,19 +1204,20 @@ static void cp210x_set_flow_control(struct tty_struct *tty, · 50 unmodified lines
1185	port_priv->crtscts = false;	1204	port_priv->crtscts = false;
1186	}	1205	}
1187		1206
1188	if (I_IXOFF(tty))	1207	if (I_IXOFF(tty)) {
1189	flow_repl \|= CP210X_SERIAL_AUTO_RECEIVE;	1208	flow_repl \|= CP210X_SERIAL_AUTO_RECEIVE;
1190	else	1209
		1210	flow_ctl.ulXonLimit = cpu_to_le32(128);
		1211	flow_ctl.ulXoffLimit = cpu_to_le32(128);
		1212	} else {
1191	flow_repl &= ~CP210X_SERIAL_AUTO_RECEIVE;	1213	flow_repl &= ~CP210X_SERIAL_AUTO_RECEIVE;
		1214	}
1192		1215
1193	if (I_IXON(tty))	1216	if (I_IXON(tty))
1194	flow_repl \|= CP210X_SERIAL_AUTO_TRANSMIT;	1217	flow_repl \|= CP210X_SERIAL_AUTO_TRANSMIT;
1195	else	1218	else
1196	flow_repl &= ~CP210X_SERIAL_AUTO_TRANSMIT;	1219	flow_repl &= ~CP210X_SERIAL_AUTO_TRANSMIT;
1197		1220
1198	flow_ctl.ulXonLimit = cpu_to_le32(128);
1199	flow_ctl.ulXoffLimit = cpu_to_le32(128);
1200
1201	dev_dbg(&port->dev, "%s - ctrl = 0x%02x, flow = 0x%02x\n", __func__,	1221	dev_dbg(&port->dev, "%s - ctrl = 0x%02x, flow = 0x%02x\n", __func__,
1202	ctl_hs, flow_repl);	1222	ctl_hs, flow_repl);
1203		1223
@@ -1733,7 +1753,19 @@ static int cp2102n_gpioconf_init(struct usb_serial *serial) · 529 unmodified lines
1733	priv->gpio_pushpull = (gpio_pushpull >> 3) & 0x0f;	1753	priv->gpio_pushpull = (gpio_pushpull >> 3) & 0x0f;
1734		1754
1735	/* 0 indicates GPIO mode, 1 is alternate function */	1755	/* 0 indicates GPIO mode, 1 is alternate function */
1736	priv->gpio_altfunc = (gpio_ctrl >> 2) & 0x0f;	1756	if (priv->partnum == CP210X_PARTNUM_CP2102N_QFN20) {
		1757	/* QFN20 is special... */
		1758	if (gpio_ctrl & CP2102N_QFN20_GPIO0_CLK_MODE) /* GPIO 0 */
		1759	priv->gpio_altfunc \|= BIT(0);
		1760	if (gpio_ctrl & CP2102N_QFN20_GPIO1_RS485_MODE) /* GPIO 1 */
		1761	priv->gpio_altfunc \|= BIT(1);
		1762	if (gpio_ctrl & CP2102N_QFN20_GPIO2_TXLED_MODE) /* GPIO 2 */
		1763	priv->gpio_altfunc \|= BIT(2);
		1764	if (gpio_ctrl & CP2102N_QFN20_GPIO3_RXLED_MODE) /* GPIO 3 */
		1765	priv->gpio_altfunc \|= BIT(3);
		1766	} else {
		1767	priv->gpio_altfunc = (gpio_ctrl >> 2) & 0x0f;
		1768	}
1737		1769
1738	if (priv->partnum == CP210X_PARTNUM_CP2102N_QFN28) {	1770	if (priv->partnum == CP210X_PARTNUM_CP2102N_QFN28) {
1739	/*	1771	/*
@@ -1908,6 +1940,45 @@ static void cp210x_init_max_speed(struct usb_serial *serial) · 168 unmodified lines
1908	priv->use_actual_rate = use_actual_rate;	1940	priv->use_actual_rate = use_actual_rate;
1909	}	1941	}
1910		1942
		1943	static int cp210x_get_fw_version(struct usb_serial *serial, u16 value)
		1944	{
		1945	struct cp210x_serial_private *priv = usb_get_serial_data(serial);
		1946	u8 ver[3];
		1947	int ret;
		1948
		1949	ret = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST, value,
		1950	ver, sizeof(ver));
		1951	if (ret)
		1952	return ret;
		1953
		1954	dev_dbg(&serial->interface->dev, "%s - %d.%d.%d\n", __func__,
		1955	ver[0], ver[1], ver[2]);
		1956
		1957	priv->fw_version = ver[0] << 16 \| ver[1] << 8 \| ver[2];
		1958
		1959	return 0;
		1960	}
		1961
		1962	static void cp210x_determine_quirks(struct usb_serial *serial)
		1963	{
		1964	struct cp210x_serial_private *priv = usb_get_serial_data(serial);
		1965	int ret;
		1966
		1967	switch (priv->partnum) {
		1968	case CP210X_PARTNUM_CP2102N_QFN28:
		1969	case CP210X_PARTNUM_CP2102N_QFN24:
		1970	case CP210X_PARTNUM_CP2102N_QFN20:
		1971	ret = cp210x_get_fw_version(serial, CP210X_GET_FW_VER_2N);
		1972	if (ret)
		1973	break;
		1974	if (priv->fw_version <= 0x10004)
		1975	priv->no_flow_control = true;
		1976	break;
		1977	default:
		1978	break;
		1979	}
		1980	}
		1981
1911	static int cp210x_attach(struct usb_serial *serial)	1982	static int cp210x_attach(struct usb_serial *serial)
1912	{	1983	{
1913	int result;	1984	int result;
@@ -1928,6 +1999,7 @@ static int cp210x_attach(struct usb_serial *serial) · 14 unmodified lines
1928		1999
1929	usb_set_serial_data(serial, priv);	2000	usb_set_serial_data(serial, priv);
1930		2001
		2002	cp210x_determine_quirks(serial);
1931	cp210x_init_max_speed(serial);	2003	cp210x_init_max_speed(serial);
1932		2004
1933	result = cp210x_gpio_init(serial);	2005	result = cp210x_gpio_init(serial);

drivers/usb/serial/ftdi_sio.c+1−0

@@ -611,6 +611,7 @@ static const struct usb_device_id id_table_combined[] = { · 610 unmodified lines
611	.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },	611	.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
612	{ USB_DEVICE(FTDI_VID, FTDI_NT_ORIONLX_PLUS_PID) },	612	{ USB_DEVICE(FTDI_VID, FTDI_NT_ORIONLX_PLUS_PID) },
613	{ USB_DEVICE(FTDI_VID, FTDI_NT_ORION_IO_PID) },	613	{ USB_DEVICE(FTDI_VID, FTDI_NT_ORION_IO_PID) },
		614	{ USB_DEVICE(FTDI_VID, FTDI_NT_ORIONMX_PID) },
614	{ USB_DEVICE(FTDI_VID, FTDI_SYNAPSE_SS200_PID) },	615	{ USB_DEVICE(FTDI_VID, FTDI_SYNAPSE_SS200_PID) },
615	{ USB_DEVICE(FTDI_VID, FTDI_CUSTOMWARE_MINIPLEX_PID) },	616	{ USB_DEVICE(FTDI_VID, FTDI_CUSTOMWARE_MINIPLEX_PID) },
616	{ USB_DEVICE(FTDI_VID, FTDI_CUSTOMWARE_MINIPLEX2_PID) },	617	{ USB_DEVICE(FTDI_VID, FTDI_CUSTOMWARE_MINIPLEX2_PID) },

drivers/usb/serial/ftdi_sio_ids.h+1−0

@@ -581,6 +581,7 @@ · 580 unmodified lines
581	#define FTDI_NT_ORIONLXM_PID 0x7c90 /* OrionLXm Substation Automation Platform */	581	#define FTDI_NT_ORIONLXM_PID 0x7c90 /* OrionLXm Substation Automation Platform */
582	#define FTDI_NT_ORIONLX_PLUS_PID 0x7c91 /* OrionLX+ Substation Automation Platform */	582	#define FTDI_NT_ORIONLX_PLUS_PID 0x7c91 /* OrionLX+ Substation Automation Platform */
583	#define FTDI_NT_ORION_IO_PID 0x7c92 /* Orion I/O */	583	#define FTDI_NT_ORION_IO_PID 0x7c92 /* Orion I/O */
		584	#define FTDI_NT_ORIONMX_PID 0x7c93 /* OrionMX */
584		585
585	/*	586	/*
586	* Synapse Wireless product ids (FTDI_VID)	587	* Synapse Wireless product ids (FTDI_VID)

drivers/usb/serial/omninet.c+5−3

 // SPDX-License-Identifier: GPL-2.0
 /*
- * USB ZyXEL omni.net LCD PLUS driver
+ * USB ZyXEL omni.net driver
  *
  * Copyright (C) 2013,2017 Johan Hovold <johan@kernel.org>
  *
 #include <linux/usb/serial.h>
 #define DRIVER_AUTHOR "Alessandro Zummo"
-#define DRIVER_DESC "USB ZyXEL omni.net LCD PLUS Driver"
+#define DRIVER_DESC "USB ZyXEL omni.net Driver"
 #define ZYXEL_VENDOR_ID		0x0586
 #define ZYXEL_OMNINET_ID	0x1000
+#define ZYXEL_OMNI_56K_PLUS_ID	0x1500
 /* This one seems to be a re-branded ZyXEL device */
 #define BT_IGNITIONPRO_ID	0x2000
 static const struct usb_device_id id_table[] = {
 	{ USB_DEVICE(ZYXEL_VENDOR_ID, ZYXEL_OMNINET_ID) },
+	{ USB_DEVICE(ZYXEL_VENDOR_ID, ZYXEL_OMNI_56K_PLUS_ID) },
 	{ USB_DEVICE(ZYXEL_VENDOR_ID, BT_IGNITIONPRO_ID) },
 	{ }						/* Terminating entry */
 };
 		.owner =	THIS_MODULE,
 		.name =		"omninet",
 	},
-	.description =		"ZyXEL - omni.net lcd plus usb",
+	.description =		"ZyXEL - omni.net usb",
 	.id_table =		id_table,
 	.num_bulk_out =		2,
 	.calc_num_ports =	omninet_calc_num_ports,

drivers/usb/serial/quatech2.c+3−3

@@ -416,7 +416,7 @@ static void qt2_close(struct usb_serial_port *port) · 415 unmodified lines
416		416
417	/* flush the port transmit buffer */	417	/* flush the port transmit buffer */
418	i = usb_control_msg(serial->dev,	418	i = usb_control_msg(serial->dev,
419	usb_rcvctrlpipe(serial->dev, 0),	419	usb_sndctrlpipe(serial->dev, 0),
420	QT2_FLUSH_DEVICE, 0x40, 1,	420	QT2_FLUSH_DEVICE, 0x40, 1,
421	port_priv->device_port, NULL, 0, QT2_USB_TIMEOUT);	421	port_priv->device_port, NULL, 0, QT2_USB_TIMEOUT);
422		422
@@ -426,7 +426,7 @@ static void qt2_close(struct usb_serial_port *port) · 3 unmodified lines
426		426
427	/* flush the port receive buffer */	427	/* flush the port receive buffer */
428	i = usb_control_msg(serial->dev,	428	i = usb_control_msg(serial->dev,
429	usb_rcvctrlpipe(serial->dev, 0),	429	usb_sndctrlpipe(serial->dev, 0),
430	QT2_FLUSH_DEVICE, 0x40, 0,	430	QT2_FLUSH_DEVICE, 0x40, 0,
431	port_priv->device_port, NULL, 0, QT2_USB_TIMEOUT);	431	port_priv->device_port, NULL, 0, QT2_USB_TIMEOUT);
432		432
@@ -639,7 +639,7 @@ static int qt2_attach(struct usb_serial *serial) · 206 unmodified lines
639	int status;	639	int status;
640		640
641	/* power on unit */	641	/* power on unit */
642	status = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),	642	status = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
643	0xc2, 0x40, 0x8000, 0, NULL, 0,	643	0xc2, 0x40, 0x8000, 0, NULL, 0,
644	QT2_USB_TIMEOUT);	644	QT2_USB_TIMEOUT);
645	if (status < 0) {	645	if (status < 0) {

drivers/usb/typec/mux.c+1−1

@@ -239,7 +239,7 @@ find_mux: · 238 unmodified lines
239	dev = class_find_device(&typec_mux_class, NULL, fwnode,	239	dev = class_find_device(&typec_mux_class, NULL, fwnode,
240	mux_fwnode_match);	240	mux_fwnode_match);
241		241
242	return dev ? to_typec_switch(dev) : ERR_PTR(-EPROBE_DEFER);	242	return dev ? to_typec_mux(dev) : ERR_PTR(-EPROBE_DEFER);
243	}	243	}
244		244
245	/**	245	/**

drivers/usb/typec/mux/intel_pmc_mux.c+11−4

 	acpi_dev_free_resource_list(&resource_list);
 	if (!pmc->iom_base) {
-		put_device(&adev->dev);
+		acpi_dev_put(adev);
 		return -ENOMEM;
 	}
+	if (IS_ERR(pmc->iom_base)) {
+		acpi_dev_put(adev);
+		return PTR_ERR(pmc->iom_base);
+	}
 	pmc->iom_adev = adev;
 	return 0;
 			break;
 		ret = pmc_usb_register_port(pmc, i, fwnode);
-		if (ret)
+		if (ret) {
+			fwnode_handle_put(fwnode);
 			goto err_remove_ports;
+		}
 	}
 	platform_set_drvdata(pdev, pmc);
 		usb_role_switch_unregister(pmc->port[i].usb_sw);
 	}
-	put_device(&pmc->iom_adev->dev);
+	acpi_dev_put(pmc->iom_adev);
 	return ret;
 }
 		usb_role_switch_unregister(pmc->port[i].usb_sw);
 	}
-	put_device(&pmc->iom_adev->dev);
+	acpi_dev_put(pmc->iom_adev);
 	return 0;
 }

drivers/usb/typec/tcpm/tcpm.c+77−46

@@ -401,6 +401,8 @@ struct tcpm_port { · 400 unmodified lines
401	unsigned int nr_src_pdo;	401	unsigned int nr_src_pdo;
402	u32 snk_pdo[PDO_MAX_OBJECTS];	402	u32 snk_pdo[PDO_MAX_OBJECTS];
403	unsigned int nr_snk_pdo;	403	unsigned int nr_snk_pdo;
		404	u32 snk_vdo_v1[VDO_MAX_OBJECTS];
		405	unsigned int nr_snk_vdo_v1;
404	u32 snk_vdo[VDO_MAX_OBJECTS];	406	u32 snk_vdo[VDO_MAX_OBJECTS];
405	unsigned int nr_snk_vdo;	407	unsigned int nr_snk_vdo;
406		408
@@ -1547,42 +1549,45 @@ static int tcpm_pd_svdm(struct tcpm_port port, struct typec_altmode adev, · 1140 unmodified lines
1547	if (PD_VDO_VID(p[0]) != USB_SID_PD)	1549	if (PD_VDO_VID(p[0]) != USB_SID_PD)
1548	break;	1550	break;
1549		1551
1550	if (PD_VDO_SVDM_VER(p[0]) < svdm_version)	1552	if (PD_VDO_SVDM_VER(p[0]) < svdm_version) {
1551	typec_partner_set_svdm_version(port->partner,	1553	typec_partner_set_svdm_version(port->partner,
1552	PD_VDO_SVDM_VER(p[0]));	1554	PD_VDO_SVDM_VER(p[0]));
		1555	svdm_version = PD_VDO_SVDM_VER(p[0]);
		1556	}
1553		1557
1554	tcpm_ams_start(port, DISCOVER_IDENTITY);	1558	port->ams = DISCOVER_IDENTITY;
1555	/* 6.4.4.3.1: Only respond as UFP (device) */	1559	/*
1556	if (port->data_role == TYPEC_DEVICE &&	1560	* PD2.0 Spec 6.10.3: respond with NAK as DFP (data host)
		1561	* PD3.1 Spec 6.4.4.2.5.1: respond with NAK if "invalid field" or
		1562	* "wrong configuation" or "Unrecognized"
		1563	*/
		1564	if ((port->data_role == TYPEC_DEVICE \|\| svdm_version >= SVDM_VER_2_0) &&
1557	port->nr_snk_vdo) {	1565	port->nr_snk_vdo) {
1558	/*	1566	if (svdm_version < SVDM_VER_2_0) {
1559	* Product Type DFP and Connector Type are not defined in SVDM	1567	for (i = 0; i < port->nr_snk_vdo_v1; i++)
1560	* version 1.0 and shall be set to zero.	1568	response[i + 1] = port->snk_vdo_v1[i];
1561	*/	1569	rlen = port->nr_snk_vdo_v1 + 1;
1562	if (typec_get_negotiated_svdm_version(typec) < SVDM_VER_2_0)	1570
1563	response[1] = port->snk_vdo[0] & ~IDH_DFP_MASK	1571	} else {
1564	& ~IDH_CONN_MASK;	1572	for (i = 0; i < port->nr_snk_vdo; i++)
1565	else	1573	response[i + 1] = port->snk_vdo[i];
1566	response[1] = port->snk_vdo[0];	1574	rlen = port->nr_snk_vdo + 1;
1567	for (i = 1; i < port->nr_snk_vdo; i++)	1575	}
1568	response[i + 1] = port->snk_vdo[i];
1569	rlen = port->nr_snk_vdo + 1;
1570	}	1576	}
1571	break;	1577	break;
1572	case CMD_DISCOVER_SVID:	1578	case CMD_DISCOVER_SVID:
1573	tcpm_ams_start(port, DISCOVER_SVIDS);	1579	port->ams = DISCOVER_SVIDS;
1574	break;	1580	break;
1575	case CMD_DISCOVER_MODES:	1581	case CMD_DISCOVER_MODES:
1576	tcpm_ams_start(port, DISCOVER_MODES);	1582	port->ams = DISCOVER_MODES;
1577	break;	1583	break;
1578	case CMD_ENTER_MODE:	1584	case CMD_ENTER_MODE:
1579	tcpm_ams_start(port, DFP_TO_UFP_ENTER_MODE);	1585	port->ams = DFP_TO_UFP_ENTER_MODE;
1580	break;	1586	break;
1581	case CMD_EXIT_MODE:	1587	case CMD_EXIT_MODE:
1582	tcpm_ams_start(port, DFP_TO_UFP_EXIT_MODE);	1588	port->ams = DFP_TO_UFP_EXIT_MODE;
1583	break;	1589	break;
1584	case CMD_ATTENTION:	1590	case CMD_ATTENTION:
1585	tcpm_ams_start(port, ATTENTION);
1586	/* Attention command does not have response */	1591	/* Attention command does not have response */
1587	*adev_action = ADEV_ATTENTION;	1592	*adev_action = ADEV_ATTENTION;
1588	return 0;	1593	return 0;
@@ -1937,6 +1942,9 @@ static void vdm_run_state_machine(struct tcpm_port *port) · 348 unmodified lines
1937	tcpm_log(port, "VDM Tx error, retry");	1942	tcpm_log(port, "VDM Tx error, retry");
1938	port->vdm_retries++;	1943	port->vdm_retries++;
1939	port->vdm_state = VDM_STATE_READY;	1944	port->vdm_state = VDM_STATE_READY;
		1945	if (PD_VDO_SVDM(vdo_hdr) && PD_VDO_CMDT(vdo_hdr) == CMDT_INIT)
		1946	tcpm_ams_finish(port);
		1947	} else {
1940	tcpm_ams_finish(port);	1948	tcpm_ams_finish(port);
1941	}	1949	}
1942	break;	1950	break;
@@ -2183,20 +2191,25 @@ static void tcpm_handle_alert(struct tcpm_port port, const __le32 payload, · 240 unmodified lines
2183		2191
2184	if (!type) {	2192	if (!type) {
2185	tcpm_log(port, "Alert message received with no type");	2193	tcpm_log(port, "Alert message received with no type");
		2194	tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP);
2186	return;	2195	return;
2187	}	2196	}
2188		2197
2189	/* Just handling non-battery alerts for now */	2198	/* Just handling non-battery alerts for now */
2190	if (!(type & USB_PD_ADO_TYPE_BATT_STATUS_CHANGE)) {	2199	if (!(type & USB_PD_ADO_TYPE_BATT_STATUS_CHANGE)) {
2191	switch (port->state) {	2200	if (port->pwr_role == TYPEC_SOURCE) {
2192	case SRC_READY:	2201	port->upcoming_state = GET_STATUS_SEND;
2193	case SNK_READY:	2202	tcpm_ams_start(port, GETTING_SOURCE_SINK_STATUS);
		2203	} else {
		2204	/*
		2205	* Do not check SinkTxOk here in case the Source doesn't set its Rp to
		2206	* SinkTxOk in time.
		2207	*/
		2208	port->ams = GETTING_SOURCE_SINK_STATUS;
2194	tcpm_set_state(port, GET_STATUS_SEND, 0);	2209	tcpm_set_state(port, GET_STATUS_SEND, 0);
2195	break;
2196	default:
2197	tcpm_queue_message(port, PD_MSG_CTRL_WAIT);
2198	break;
2199	}	2210	}
		2211	} else {
		2212	tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP);
2200	}	2213	}
2201	}	2214	}
2202		2215
@@ -2440,7 +2453,12 @@ static void tcpm_pd_data_request(struct tcpm_port *port, · 237 unmodified lines
2440	tcpm_pd_handle_state(port, BIST_RX, BIST, 0);	2453	tcpm_pd_handle_state(port, BIST_RX, BIST, 0);
2441	break;	2454	break;
2442	case PD_DATA_ALERT:	2455	case PD_DATA_ALERT:
2443	tcpm_handle_alert(port, msg->payload, cnt);	2456	if (port->state != SRC_READY && port->state != SNK_READY)
		2457	tcpm_pd_handle_state(port, port->pwr_role == TYPEC_SOURCE ?
		2458	SRC_SOFT_RESET_WAIT_SNK_TX : SNK_SOFT_RESET,
		2459	NONE_AMS, 0);
		2460	else
		2461	tcpm_handle_alert(port, msg->payload, cnt);
2444	break;	2462	break;
2445	case PD_DATA_BATT_STATUS:	2463	case PD_DATA_BATT_STATUS:
2446	case PD_DATA_GET_COUNTRY_INFO:	2464	case PD_DATA_GET_COUNTRY_INFO:
@@ -2764,24 +2782,16 @@ static void tcpm_pd_ext_msg_request(struct tcpm_port *port, · 317 unmodified lines
2764		2782
2765	switch (type) {	2783	switch (type) {
2766	case PD_EXT_STATUS:	2784	case PD_EXT_STATUS:
2767	/*
2768	* If PPS related events raised then get PPS status to clear
2769	* (see USB PD 3.0 Spec, 6.5.2.4)
2770	*/
2771	if (msg->ext_msg.data[USB_PD_EXT_SDB_EVENT_FLAGS] &
2772	USB_PD_EXT_SDB_PPS_EVENTS)
2773	tcpm_pd_handle_state(port, GET_PPS_STATUS_SEND,
2774	GETTING_SOURCE_SINK_STATUS, 0);
2775
2776	else
2777	tcpm_pd_handle_state(port, ready_state(port), NONE_AMS, 0);
2778	break;
2779	case PD_EXT_PPS_STATUS:	2785	case PD_EXT_PPS_STATUS:
2780	/*	2786	if (port->ams == GETTING_SOURCE_SINK_STATUS) {
2781	* For now the PPS status message is used to clear events	2787	tcpm_ams_finish(port);
2782	* and nothing more.	2788	tcpm_set_state(port, ready_state(port), 0);
2783	*/	2789	} else {
2784	tcpm_pd_handle_state(port, ready_state(port), NONE_AMS, 0);	2790	/* unexpected Status or PPS_Status Message */
		2791	tcpm_pd_handle_state(port, port->pwr_role == TYPEC_SOURCE ?
		2792	SRC_SOFT_RESET_WAIT_SNK_TX : SNK_SOFT_RESET,
		2793	NONE_AMS, 0);
		2794	}
2785	break;	2795	break;
2786	case PD_EXT_SOURCE_CAP_EXT:	2796	case PD_EXT_SOURCE_CAP_EXT:
2787	case PD_EXT_GET_BATT_CAP:	2797	case PD_EXT_GET_BATT_CAP:
@@ -5947,6 +5957,22 @@ sink: · 3159 unmodified lines
5947	return ret;	5957	return ret;
5948	}	5958	}
5949		5959
		5960	/* If sink-vdos is found, sink-vdos-v1 is expected for backward compatibility. */
		5961	if (port->nr_snk_vdo) {
		5962	ret = fwnode_property_count_u32(fwnode, "sink-vdos-v1");
		5963	if (ret < 0)
		5964	return ret;
		5965	else if (ret == 0)
		5966	return -ENODATA;
		5967
		5968	port->nr_snk_vdo_v1 = min(ret, VDO_MAX_OBJECTS);
		5969	ret = fwnode_property_read_u32_array(fwnode, "sink-vdos-v1",
		5970	port->snk_vdo_v1,
		5971	port->nr_snk_vdo_v1);
		5972	if (ret < 0)
		5973	return ret;
		5974	}
		5975
5950	return 0;	5976	return 0;
5951	}	5977	}
5952		5978
@@ -6312,6 +6338,11 @@ void tcpm_unregister_port(struct tcpm_port *port) · 359 unmodified lines
6312	{	6338	{
6313	int i;	6339	int i;
6314		6340
		6341	hrtimer_cancel(&port->send_discover_timer);
		6342	hrtimer_cancel(&port->enable_frs_timer);
		6343	hrtimer_cancel(&port->vdm_state_machine_timer);
		6344	hrtimer_cancel(&port->state_machine_timer);
		6345
6315	tcpm_reset_port(port);	6346	tcpm_reset_port(port);
6316	for (i = 0; i < ARRAY_SIZE(port->port_altmode); i++)	6347	for (i = 0; i < ARRAY_SIZE(port->port_altmode); i++)
6317	typec_unregister_altmode(port->port_altmode[i]);	6348	typec_unregister_altmode(port->port_altmode[i]);

drivers/usb/typec/tcpm/wcove.c+1−1

@@ -378,7 +378,7 @@ static int wcove_pd_transmit(struct tcpc_dev *tcpc, · 377 unmodified lines
378	const u8 data = (void )msg;	378	const u8 data = (void )msg;
379	int i;	379	int i;
380		380
381	for (i = 0; i < pd_header_cnt(msg->header) * 4 + 2; i++) {	381	for (i = 0; i < pd_header_cnt_le(msg->header) * 4 + 2; i++) {
382	ret = regmap_write(wcove->regmap, USBC_TX_DATA + i,	382	ret = regmap_write(wcove->regmap, USBC_TX_DATA + i,
383	data[i]);	383	data[i]);
384	if (ret)	384	if (ret)

drivers/usb/typec/ucsi/ucsi.c+1−0

@@ -1253,6 +1253,7 @@ err_unregister: · 1252 unmodified lines
1253	}	1253	}
1254		1254
1255	err_reset:	1255	err_reset:
		1256	memset(&ucsi->cap, 0, sizeof(ucsi->cap));
1256	ucsi_reset_ppm(ucsi);	1257	ucsi_reset_ppm(ucsi);
1257	err:	1258	err:
1258	return ret;	1259	return ret;

drivers/vfio/pci/Kconfig+1−0

@@ -2,6 +2,7 @@ · 1 unmodified line
2	config VFIO_PCI	2	config VFIO_PCI
3	tristate "VFIO support for PCI devices"	3	tristate "VFIO support for PCI devices"
4	depends on VFIO && PCI && EVENTFD	4	depends on VFIO && PCI && EVENTFD
		5	depends on MMU
5	select VFIO_VIRQFD	6	select VFIO_VIRQFD
6	select IRQ_BYPASS_MANAGER	7	select IRQ_BYPASS_MANAGER
7	help	8	help

drivers/vfio/pci/vfio_pci_config.c+1−1

@@ -1581,7 +1581,7 @@ static int vfio_ecap_init(struct vfio_pci_device *vdev) · 1580 unmodified lines
1581	if (len == 0xFF) {	1581	if (len == 0xFF) {
1582	len = vfio_ext_cap_len(vdev, ecap, epos);	1582	len = vfio_ext_cap_len(vdev, ecap, epos);
1583	if (len < 0)	1583	if (len < 0)
1584	return ret;	1584	return len;
1585	}	1585	}
1586	}	1586	}
1587		1587

drivers/vfio/platform/vfio_platform_common.c+1−1

@@ -291,7 +291,7 @@ err_irq: · 290 unmodified lines
291	vfio_platform_regions_cleanup(vdev);	291	vfio_platform_regions_cleanup(vdev);
292	err_reg:	292	err_reg:
293	mutex_unlock(&driver_lock);	293	mutex_unlock(&driver_lock);
294	module_put(THIS_MODULE);	294	module_put(vdev->parent_module);
295	return ret;	295	return ret;
296	}	296	}
297		297

drivers/vfio/vfio_iommu_type1.c+1−1

@@ -2795,7 +2795,7 @@ static int vfio_iommu_iova_build_caps(struct vfio_iommu *iommu, · 2794 unmodified lines
2795	return 0;	2795	return 0;
2796	}	2796	}
2797		2797
2798	size = sizeof(cap_iovas) + (iovas sizeof(*cap_iovas->iova_ranges));	2798	size = struct_size(cap_iovas, iova_ranges, iovas);
2799		2799
2800	cap_iovas = kzalloc(size, GFP_KERNEL);	2800	cap_iovas = kzalloc(size, GFP_KERNEL);
2801	if (!cap_iovas)	2801	if (!cap_iovas)

drivers/video/fbdev/core/fb_defio.c+35−0

@@ -52,6 +52,13 @@ static vm_fault_t fb_deferred_io_fault(struct vm_fault *vmf) · 51 unmodified lines
52	return VM_FAULT_SIGBUS;	52	return VM_FAULT_SIGBUS;
53		53
54	get_page(page);	54	get_page(page);
		55
		56	if (vmf->vma->vm_file)
		57	page->mapping = vmf->vma->vm_file->f_mapping;
		58	else
		59	printk(KERN_ERR "no mapping available\n");
		60
		61	BUG_ON(!page->mapping);
55	page->index = vmf->pgoff;	62	page->index = vmf->pgoff;
56		63
57	vmf->page = page;	64	vmf->page = page;
@@ -144,6 +151,17 @@ static const struct vm_operations_struct fb_deferred_io_vm_ops = { · 86 unmodified lines
144	.page_mkwrite = fb_deferred_io_mkwrite,	151	.page_mkwrite = fb_deferred_io_mkwrite,
145	};	152	};
146		153
		154	static int fb_deferred_io_set_page_dirty(struct page *page)
		155	{
		156	if (!PageDirty(page))
		157	SetPageDirty(page);
		158	return 0;
		159	}
		160
		161	static const struct address_space_operations fb_deferred_io_aops = {
		162	.set_page_dirty = fb_deferred_io_set_page_dirty,
		163	};
		164
147	int fb_deferred_io_mmap(struct fb_info info, struct vm_area_struct vma)	165	int fb_deferred_io_mmap(struct fb_info info, struct vm_area_struct vma)
148	{	166	{
149	vma->vm_ops = &fb_deferred_io_vm_ops;	167	vma->vm_ops = &fb_deferred_io_vm_ops;
@@ -194,12 +212,29 @@ void fb_deferred_io_init(struct fb_info *info) · 44 unmodified lines
194	}	212	}
195	EXPORT_SYMBOL_GPL(fb_deferred_io_init);	213	EXPORT_SYMBOL_GPL(fb_deferred_io_init);
196		214
		215	void fb_deferred_io_open(struct fb_info *info,
		216	struct inode *inode,
		217	struct file *file)
		218	{
		219	file->f_mapping->a_ops = &fb_deferred_io_aops;
		220	}
		221	EXPORT_SYMBOL_GPL(fb_deferred_io_open);
		222
197	void fb_deferred_io_cleanup(struct fb_info *info)	223	void fb_deferred_io_cleanup(struct fb_info *info)
198	{	224	{
199	struct fb_deferred_io *fbdefio = info->fbdefio;	225	struct fb_deferred_io *fbdefio = info->fbdefio;
		226	struct page *page;
		227	int i;
200		228
201	BUG_ON(!fbdefio);	229	BUG_ON(!fbdefio);
202	cancel_delayed_work_sync(&info->deferred_work);	230	cancel_delayed_work_sync(&info->deferred_work);
		231
		232	/* clear out the mapping that we setup */
		233	for (i = 0 ; i < info->fix.smem_len; i += PAGE_SIZE) {
		234	page = fb_deferred_io_page(info, i);
		235	page->mapping = NULL;
		236	}
		237
203	mutex_destroy(&fbdefio->lock);	238	mutex_destroy(&fbdefio->lock);
204	}	239	}
205	EXPORT_SYMBOL_GPL(fb_deferred_io_cleanup);	240	EXPORT_SYMBOL_GPL(fb_deferred_io_cleanup);

drivers/video/fbdev/core/fbmem.c+4−0

 		if (res)
 			module_put(info->fbops->owner);
 	}
+#ifdef CONFIG_FB_DEFERRED_IO
+	if (info->fbdefio)
+		fb_deferred_io_open(info, inode, file);
+#endif
 out:
 	unlock_fb_info(info);
 	if (res)

fs/afs/write.c+1−1

@@ -730,7 +730,7 @@ static int afs_writepages_region(struct address_space *mapping, · 729 unmodified lines
730	return ret;	730	return ret;
731	}	731	}
732		732
733	start += ret * PAGE_SIZE;	733	start += ret;
734		734
735	cond_resched();	735	cond_resched();
736	} while (wbc->nr_to_write > 0);	736	} while (wbc->nr_to_write > 0);

fs/btrfs/compression.c+12−5

 	bytes_left = compressed_len;
 	for (pg_index = 0; pg_index < cb->nr_pages; pg_index++) {
 		int submit = 0;
-		int len;
+		int len = 0;
 		page = compressed_pages[pg_index];
 		page->mapping = inode->vfs_inode.i_mapping;
 			submit = btrfs_bio_fits_in_stripe(page, PAGE_SIZE, bio,
 							  0);
-		if (pg_index == 0 && use_append)
+		/*
-			len = bio_add_zone_append_page(bio, page, PAGE_SIZE, 0);
+		 * Page can only be added to bio if the current bio fits in
-		else
+		 * stripe.
-			len = bio_add_page(bio, page, PAGE_SIZE, 0);
+		 */
+		if (!submit) {
+			if (pg_index == 0 && use_append)
+				len = bio_add_zone_append_page(bio, page,
+							       PAGE_SIZE, 0);
+			else
+				len = bio_add_page(bio, page, PAGE_SIZE, 0);
+		}
 		page->mapping = NULL;
 		if (submit || len < PAGE_SIZE) {

fs/btrfs/disk-io.c+18−8

 		ret = -EINVAL;
 	}
+	if (memcmp(fs_info->fs_devices->fsid, fs_info->super_copy->fsid,
+		   BTRFS_FSID_SIZE)) {
+		btrfs_err(fs_info,
+		"superblock fsid doesn't match fsid of fs_devices: %pU != %pU",
+			fs_info->super_copy->fsid, fs_info->fs_devices->fsid);
+		ret = -EINVAL;
+	}
+	if (btrfs_fs_incompat(fs_info, METADATA_UUID) &&
+	    memcmp(fs_info->fs_devices->metadata_uuid,
+		   fs_info->super_copy->metadata_uuid, BTRFS_FSID_SIZE)) {
+		btrfs_err(fs_info,
+"superblock metadata_uuid doesn't match metadata uuid of fs_devices: %pU != %pU",
+			fs_info->super_copy->metadata_uuid,
+			fs_info->fs_devices->metadata_uuid);
+		ret = -EINVAL;
+	}
 	if (memcmp(fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid,
 		   BTRFS_FSID_SIZE) != 0) {
 		btrfs_err(fs_info,
 	disk_super = fs_info->super_copy;
-	ASSERT(!memcmp(fs_info->fs_devices->fsid, fs_info->super_copy->fsid,
-		       BTRFS_FSID_SIZE));
-	if (btrfs_fs_incompat(fs_info, METADATA_UUID)) {
-		ASSERT(!memcmp(fs_info->fs_devices->metadata_uuid,
-				fs_info->super_copy->metadata_uuid,
-				BTRFS_FSID_SIZE));
-	}
 	features = btrfs_super_flags(disk_super);
 	if (features & BTRFS_SUPER_FLAG_CHANGING_FSID_V2) {

fs/btrfs/extent-tree.c+1−1

@@ -1868,7 +1868,7 @@ static int cleanup_ref_head(struct btrfs_trans_handle *trans, · 1867 unmodified lines
1868	trace_run_delayed_ref_head(fs_info, head, 0);	1868	trace_run_delayed_ref_head(fs_info, head, 0);
1869	btrfs_delayed_ref_unlock(head);	1869	btrfs_delayed_ref_unlock(head);
1870	btrfs_put_delayed_ref_head(head);	1870	btrfs_put_delayed_ref_head(head);
1871	return 0;	1871	return ret;
1872	}	1872	}
1873		1873
1874	static struct btrfs_delayed_ref_head *btrfs_obtain_ref_head(	1874	static struct btrfs_delayed_ref_head *btrfs_obtain_ref_head(

fs/btrfs/file-item.c+81−27

 	u64 end_byte = bytenr + len;
 	u64 csum_end;
 	struct extent_buffer *leaf;
-	int ret;
+	int ret = 0;
 	const u32 csum_size = fs_info->csum_size;
 	u32 blocksize_bits = fs_info->sectorsize_bits;
 		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 		if (ret > 0) {
+			ret = 0;
 			if (path->slots[0] == 0)
 				break;
 			path->slots[0]--;
 			ret = btrfs_del_items(trans, root, path,
 					      path->slots[0], del_nr);
 			if (ret)
-				goto out;
+				break;
 			if (key.offset == bytenr)
 				break;
 		} else if (key.offset < bytenr && csum_end > end_byte) {
 			ret = btrfs_split_item(trans, root, path, &key, offset);
 			if (ret && ret != -EAGAIN) {
 				btrfs_abort_transaction(trans, ret);
-				goto out;
+				break;
 			}
+			ret = 0;
 			key.offset = end_byte - 1;
 		} else {
 		}
 		btrfs_release_path(path);
 	}
-	ret = 0;
-out:
 	btrfs_free_path(path);
 	return ret;
 }
+static int find_next_csum_offset(struct btrfs_root *root,
+				 struct btrfs_path *path,
+				 u64 *next_offset)
+{
+	const u32 nritems = btrfs_header_nritems(path->nodes[0]);
+	struct btrfs_key found_key;
+	int slot = path->slots[0] + 1;
+	int ret;
+	if (nritems == 0 || slot >= nritems) {
+		ret = btrfs_next_leaf(root, path);
+		if (ret < 0) {
+			return ret;
+		} else if (ret > 0) {
+			*next_offset = (u64)-1;
+			return 0;
+		}
+		slot = path->slots[0];
+	}
+	btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
+	if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
+	    found_key.type != BTRFS_EXTENT_CSUM_KEY)
+		*next_offset = (u64)-1;
+	else
+		*next_offset = found_key.offset;
+	return 0;
+}
 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
 			   struct btrfs_root *root,
 			   struct btrfs_ordered_sum *sums)
 	u64 total_bytes = 0;
 	u64 csum_offset;
 	u64 bytenr;
-	u32 nritems;
 	u32 ins_size;
 	int index = 0;
 	int found_next;
 			goto insert;
 		}
 	} else {
-		int slot = path->slots[0] + 1;
+		/* We didn't find a csum item, insert one. */
-		/* we didn't find a csum item, insert one */
+		ret = find_next_csum_offset(root, path, &next_offset);
-		nritems = btrfs_header_nritems(path->nodes[0]);
+		if (ret < 0)
-		if (!nritems || (path->slots[0] >= nritems - 1)) {
+			goto out;
-			ret = btrfs_next_leaf(root, path);
-			if (ret < 0) {
-				goto out;
-			} else if (ret > 0) {
-				found_next = 1;
-				goto insert;
-			}
-			slot = path->slots[0];
-		}
-		btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
-		if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
-		    found_key.type != BTRFS_EXTENT_CSUM_KEY) {
-			found_next = 1;
-			goto insert;
-		}
-		next_offset = found_key.offset;
 		found_next = 1;
 		goto insert;
 	}
 		tmp = sums->len - total_bytes;
 		tmp >>= fs_info->sectorsize_bits;
 		WARN_ON(tmp < 1);
+		extend_nr = max_t(int, 1, tmp);
+		/*
+		 * A log tree can already have checksum items with a subset of
+		 * the checksums we are trying to log. This can happen after
+		 * doing a sequence of partial writes into prealloc extents and
+		 * fsyncs in between, with a full fsync logging a larger subrange
+		 * of an extent for which a previous fast fsync logged a smaller
+		 * subrange. And this happens in particular due to merging file
+		 * extent items when we complete an ordered extent for a range
+		 * covered by a prealloc extent - this is done at
+		 * btrfs_mark_extent_written().
+		 *
+		 * So if we try to extend the previous checksum item, which has
+		 * a range that ends at the start of the range we want to insert,
+		 * make sure we don't extend beyond the start offset of the next
+		 * checksum item. If we are at the last item in the leaf, then
+		 * forget the optimization of extending and add a new checksum
+		 * item - it is not worth the complexity of releasing the path,
+		 * getting the first key for the next leaf, repeat the btree
+		 * search, etc, because log trees are temporary anyway and it
+		 * would only save a few bytes of leaf space.
+		 */
+		if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
+			if (path->slots[0] + 1 >=
+			    btrfs_header_nritems(path->nodes[0])) {
+				ret = find_next_csum_offset(root, path, &next_offset);
+				if (ret < 0)
+					goto out;
+				found_next = 1;
+				goto insert;
+			}
+			ret = find_next_csum_offset(root, path, &next_offset);
+			if (ret < 0)
+				goto out;
+			tmp = (next_offset - bytenr) >> fs_info->sectorsize_bits;
+			if (tmp <= INT_MAX)
+				extend_nr = min_t(int, extend_nr, tmp);
+		}
-		extend_nr = max_t(int, 1, (int)tmp);
 		diff = (csum_offset + extend_nr) * csum_size;
 		diff = min(diff,
 			   MAX_CSUM_ITEMS(fs_info, csum_size) * csum_size);

fs/btrfs/file.c+2−2

@@ -1094,7 +1094,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, · 1093 unmodified lines
1094	int del_nr = 0;	1094	int del_nr = 0;
1095	int del_slot = 0;	1095	int del_slot = 0;
1096	int recow;	1096	int recow;
1097	int ret;	1097	int ret = 0;
1098	u64 ino = btrfs_ino(inode);	1098	u64 ino = btrfs_ino(inode);
1099		1099
1100	path = btrfs_alloc_path();	1100	path = btrfs_alloc_path();
@@ -1315,7 +1315,7 @@ again: · 214 unmodified lines
1315	}	1315	}
1316	out:	1316	out:
1317	btrfs_free_path(path);	1317	btrfs_free_path(path);
1318	return 0;	1318	return ret;
1319	}	1319	}
1320		1320
1321	/*	1321	/*

fs/btrfs/inode.c+18−1

 	if (ret || truncated) {
 		u64 unwritten_start = start;
+		/*
+		 * If we failed to finish this ordered extent for any reason we
+		 * need to make sure BTRFS_ORDERED_IOERR is set on the ordered
+		 * extent, and mark the inode with the error if it wasn't
+		 * already set.  Any error during writeback would have already
+		 * set the mapping error, so we need to set it if we're the ones
+		 * marking this ordered extent as failed.
+		 */
+		if (ret && !test_and_set_bit(BTRFS_ORDERED_IOERR,
+					     &ordered_extent->flags))
+			mapping_set_error(ordered_extent->inode->i_mapping, -EIO);
 		if (truncated)
 			unwritten_start += logical_len;
 		clear_extent_uptodate(io_tree, unwritten_start, end, NULL);
 	int ret2;
 	bool root_log_pinned = false;
 	bool dest_log_pinned = false;
+	bool need_abort = false;
 	/* we only allow rename subvolume link between subvolumes */
 	if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
 					     old_idx);
 		if (ret)
 			goto out_fail;
+		need_abort = true;
 	}
 	/* And now for the dest. */
 					     new_ino,
 					     btrfs_ino(BTRFS_I(old_dir)),
 					     new_idx);
-		if (ret)
+		if (ret) {
+			if (need_abort)
+				btrfs_abort_transaction(trans, ret);
 			goto out_fail;
+		}
 	}
 	/* Update inode version and ctime/mtime. */

fs/btrfs/reflink.c+22−16

 			 * inline extent's data to the page.
 			 */
 			ASSERT(key.offset > 0);
-			ret = copy_inline_to_page(BTRFS_I(dst), new_key->offset,
+			goto copy_to_page;
-						  inline_data, size, datal,
-						  comp_type);
-			goto out;
 		}
 	} else if (i_size_read(dst) <= datal) {
 		struct btrfs_file_extent_item *ei;
 		    BTRFS_FILE_EXTENT_INLINE)
 			goto copy_inline_extent;
-		ret = copy_inline_to_page(BTRFS_I(dst), new_key->offset,
+		goto copy_to_page;
-					  inline_data, size, datal, comp_type);
-		goto out;
 	}
 copy_inline_extent:
-	ret = 0;
 	/*
 	 * We have no extent items, or we have an extent at offset 0 which may
 	 * or may not be inlined. All these cases are dealt the same way.
 		 * clone. Deal with all these cases by copying the inline extent
 		 * data into the respective page at the destination inode.
 		 */
-		ret = copy_inline_to_page(BTRFS_I(dst), new_key->offset,
+		goto copy_to_page;
-					  inline_data, size, datal, comp_type);
-		goto out;
 	}
+	/*
+	 * Release path before starting a new transaction so we don't hold locks
+	 * that would confuse lockdep.
+	 */
 	btrfs_release_path(path);
 	/*
 	 * If we end up here it means were copy the inline extent into a leaf
 	ret = btrfs_inode_set_file_extent_range(BTRFS_I(dst), 0, aligned_end);
 out:
 	if (!ret && !trans) {
-		/*
-		 * Release path before starting a new transaction so we don't
-		 * hold locks that would confuse lockdep.
-		 */
-		btrfs_release_path(path);
 		/*
 		 * No transaction here means we copied the inline extent into a
 		 * page of the destination inode.
 		*trans_out = trans;
 	return ret;
+copy_to_page:
+	/*
+	 * Release our path because we don't need it anymore and also because
+	 * copy_inline_to_page() needs to reserve data and metadata, which may
+	 * need to flush delalloc when we are low on available space and
+	 * therefore cause a deadlock if writeback of an inline extent needs to
+	 * write to the same leaf or an ordered extent completion needs to write
+	 * to the same leaf.
+	 */
+	btrfs_release_path(path);
+	ret = copy_inline_to_page(BTRFS_I(dst), new_key->offset,
+				  inline_data, size, datal, comp_type);
+	goto out;
 }
 /**

fs/btrfs/tree-log.c+29−8

 			if (ret)
 				goto out;
-			btrfs_update_inode(trans, root, BTRFS_I(inode));
+			ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
+			if (ret)
+				goto out;
 		}
 		ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen;
 	if (nlink != inode->i_nlink) {
 		set_nlink(inode, nlink);
-		btrfs_update_inode(trans, root, BTRFS_I(inode));
+		ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
+		if (ret)
+			goto out;
 	}
 	BTRFS_I(inode)->index_cnt = (u64)-1;
 			break;
 		if (ret == 1) {
+			ret = 0;
 			if (path->slots[0] == 0)
 				break;
 			path->slots[0]--;
 		ret = btrfs_del_item(trans, root, path);
 		if (ret)
-			goto out;
+			break;
 		btrfs_release_path(path);
 		inode = read_one_inode(root, key.offset);
-		if (!inode)
+		if (!inode) {
-			return -EIO;
+			ret = -EIO;
+			break;
+		}
 		ret = fixup_inode_link_count(trans, root, inode);
 		iput(inode);
 		if (ret)
-			goto out;
+			break;
 		/*
 		 * fixup on a directory may create new entries,
 		 */
 		key.offset = (u64)-1;
 	}
-	ret = 0;
-out:
 	btrfs_release_path(path);
 	return ret;
 }
 	 *    begins and releases it only after writing its superblock.
 	 */
 	mutex_lock(&fs_info->tree_log_mutex);
+	/*
+	 * The previous transaction writeout phase could have failed, and thus
+	 * marked the fs in an error state.  We must not commit here, as we
+	 * could have updated our generation in the super_for_commit and
+	 * writing the super here would result in transid mismatches.  If there
+	 * is an error here just bail.
+	 */
+	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
+		ret = -EIO;
+		btrfs_set_log_full_commit(trans);
+		btrfs_abort_transaction(trans, ret);
+		mutex_unlock(&fs_info->tree_log_mutex);
+		goto out_wake_log_root;
+	}
 	btrfs_set_super_log_root(fs_info->super_for_commit, log_root_start);
 	btrfs_set_super_log_root_level(fs_info->super_for_commit, log_root_level);
 	ret = write_all_supers(fs_info, 1);

fs/btrfs/zoned.c+18−5

 	return (u32)zone;
 }
+static inline sector_t zone_start_sector(u32 zone_number,
+					 struct block_device *bdev)
+{
+	return (sector_t)zone_number << ilog2(bdev_zone_sectors(bdev));
+}
+static inline u64 zone_start_physical(u32 zone_number,
+				      struct btrfs_zoned_device_info *zone_info)
+{
+	return (u64)zone_number << zone_info->zone_size_shift;
+}
 /*
  * Emulate blkdev_report_zones() for a non-zoned device. It slices up the block
  * device into static sized chunks and fake a conventional zone on each of
 		if (sb_zone + 1 >= zone_info->nr_zones)
 			continue;
-		sector = sb_zone << (zone_info->zone_size_shift - SECTOR_SHIFT);
+		ret = btrfs_get_dev_zones(device,
-		ret = btrfs_get_dev_zones(device, sector << SECTOR_SHIFT,
+					  zone_start_physical(sb_zone, zone_info),
 					  &zone_info->sb_zones[sb_pos],
 					  &nr_zones);
 		if (ret)
 	if (sb_zone + 1 >= nr_zones)
 		return -ENOENT;
-	ret = blkdev_report_zones(bdev, sb_zone << zone_sectors_shift,
+	ret = blkdev_report_zones(bdev, zone_start_sector(sb_zone, bdev),
 				  BTRFS_NR_SB_LOG_ZONES, copy_zone_info_cb,
 				  zones);
 	if (ret < 0)
 		return -ENOENT;
 	return blkdev_zone_mgmt(bdev, REQ_OP_ZONE_RESET,
-				sb_zone << zone_sectors_shift,
+				zone_start_sector(sb_zone, bdev),
 				zone_sectors * BTRFS_NR_SB_LOG_ZONES, GFP_NOFS);
 }
 			if (!(end <= sb_zone ||
 			      sb_zone + BTRFS_NR_SB_LOG_ZONES <= begin)) {
 				have_sb = true;
-				pos = ((u64)sb_zone + BTRFS_NR_SB_LOG_ZONES) << shift;
+				pos = zone_start_physical(
+					sb_zone + BTRFS_NR_SB_LOG_ZONES, zinfo);
 				break;
 			}

fs/coredump.c+1−1

@@ -519,7 +519,7 @@ static bool dump_interrupted(void) · 518 unmodified lines
519	* but then we need to teach dump_write() to restart and clear	519	* but then we need to teach dump_write() to restart and clear
520	* TIF_SIGPENDING.	520	* TIF_SIGPENDING.
521	*/	521	*/
522	return signal_pending(current);	522	return fatal_signal_pending(current) \|\| freezing(current);
523	}	523	}
524		524
525	static void wait_for_dump_helpers(struct file *file)	525	static void wait_for_dump_helpers(struct file *file)

fs/debugfs/file.c+1−1

@@ -893,7 +893,7 @@ ssize_t debugfs_read_file_str(struct file file, char __user user_buf, · 892 unmodified lines
893		893
894	copy[copy_len] = '\n';	894	copy[copy_len] = '\n';
895		895
896	ret = simple_read_from_buffer(user_buf, count, ppos, copy, copy_len);	896	ret = simple_read_from_buffer(user_buf, count, ppos, copy, len);
897	kfree(copy);	897	kfree(copy);
898		898
899	return ret;	899	return ret;

fs/ext4/extents.c+23−20

@@ -3206,7 +3206,10 @@ static int ext4_split_extent_at(handle_t *handle, · 3205 unmodified lines
3206	ext4_ext_mark_unwritten(ex2);	3206	ext4_ext_mark_unwritten(ex2);
3207		3207
3208	err = ext4_ext_insert_extent(handle, inode, ppath, &newex, flags);	3208	err = ext4_ext_insert_extent(handle, inode, ppath, &newex, flags);
3209	if (err == -ENOSPC && (EXT4_EXT_MAY_ZEROOUT & split_flag)) {	3209	if (err != -ENOSPC && err != -EDQUOT)
		3210	goto out;
		3211
		3212	if (EXT4_EXT_MAY_ZEROOUT & split_flag) {
3210	if (split_flag & (EXT4_EXT_DATA_VALID1\|EXT4_EXT_DATA_VALID2)) {	3213	if (split_flag & (EXT4_EXT_DATA_VALID1\|EXT4_EXT_DATA_VALID2)) {
3211	if (split_flag & EXT4_EXT_DATA_VALID1) {	3214	if (split_flag & EXT4_EXT_DATA_VALID1) {
3212	err = ext4_ext_zeroout(inode, ex2);	3215	err = ext4_ext_zeroout(inode, ex2);
@@ -3232,25 +3235,22 @@ static int ext4_split_extent_at(handle_t *handle, · 19 unmodified lines
3232	ext4_ext_pblock(&orig_ex));	3235	ext4_ext_pblock(&orig_ex));
3233	}	3236	}
3234		3237
3235	if (err)	3238	if (!err) {
3236	goto fix_extent_len;	3239	/* update the extent length and mark as initialized */
3237	/* update the extent length and mark as initialized */	3240	ex->ee_len = cpu_to_le16(ee_len);
3238	ex->ee_len = cpu_to_le16(ee_len);	3241	ext4_ext_try_to_merge(handle, inode, path, ex);
3239	ext4_ext_try_to_merge(handle, inode, path, ex);	3242	err = ext4_ext_dirty(handle, inode, path + path->p_depth);
3240	err = ext4_ext_dirty(handle, inode, path + path->p_depth);	3243	if (!err)
3241	if (err)	3244	/* update extent status tree */
3242	goto fix_extent_len;	3245	err = ext4_zeroout_es(inode, &zero_ex);
3243		3246	/* If we failed at this point, we don't know in which
3244	/* update extent status tree */	3247	* state the extent tree exactly is so don't try to fix
3245	err = ext4_zeroout_es(inode, &zero_ex);	3248	* length of the original extent as it may do even more
3246		3249	* damage.
3247	goto out;	3250	*/
3248	} else if (err)	3251	goto out;
3249	goto fix_extent_len;	3252	}
3250		3253	}
3251	out:
3252	ext4_ext_show_leaf(inode, path);
3253	return err;
3254		3254
3255	fix_extent_len:	3255	fix_extent_len:
3256	ex->ee_len = orig_ex.ee_len;	3256	ex->ee_len = orig_ex.ee_len;
@@ -3260,6 +3260,9 @@ fix_extent_len: · 3 unmodified lines
3260	*/	3260	*/
3261	ext4_ext_dirty(handle, inode, path + path->p_depth);	3261	ext4_ext_dirty(handle, inode, path + path->p_depth);
3262	return err;	3262	return err;
		3263	out:
		3264	ext4_ext_show_leaf(inode, path);
		3265	return err;
3263	}	3266	}
3264		3267
3265	/*	3268	/*

fs/ext4/fast_commit.c+90−80

 };
 static inline void tl_to_darg(struct dentry_info_args *darg,
-				struct  ext4_fc_tl *tl)
+			      struct  ext4_fc_tl *tl, u8 *val)
 {
-	struct ext4_fc_dentry_info *fcd;
+	struct ext4_fc_dentry_info fcd;
-	fcd = (struct ext4_fc_dentry_info *)ext4_fc_tag_val(tl);
+	memcpy(&fcd, val, sizeof(fcd));
-	darg->parent_ino = le32_to_cpu(fcd->fc_parent_ino);
+	darg->parent_ino = le32_to_cpu(fcd.fc_parent_ino);
-	darg->ino = le32_to_cpu(fcd->fc_ino);
+	darg->ino = le32_to_cpu(fcd.fc_ino);
-	darg->dname = fcd->fc_dname;
+	darg->dname = val + offsetof(struct ext4_fc_dentry_info, fc_dname);
-	darg->dname_len = ext4_fc_tag_len(tl) -
+	darg->dname_len = le16_to_cpu(tl->fc_len) -
-			sizeof(struct ext4_fc_dentry_info);
+		sizeof(struct ext4_fc_dentry_info);
 }
 /* Unlink replay function */
-static int ext4_fc_replay_unlink(struct super_block *sb, struct ext4_fc_tl *tl)
+static int ext4_fc_replay_unlink(struct super_block *sb, struct ext4_fc_tl *tl,
+				 u8 *val)
 {
 	struct inode *inode, *old_parent;
 	struct qstr entry;
 	struct dentry_info_args darg;
 	int ret = 0;
-	tl_to_darg(&darg, tl);
+	tl_to_darg(&darg, tl, val);
 	trace_ext4_fc_replay(sb, EXT4_FC_TAG_UNLINK, darg.ino,
 			darg.parent_ino, darg.dname_len);
 }
 /* Link replay function */
-static int ext4_fc_replay_link(struct super_block *sb, struct ext4_fc_tl *tl)
+static int ext4_fc_replay_link(struct super_block *sb, struct ext4_fc_tl *tl,
+			       u8 *val)
 {
 	struct inode *inode;
 	struct dentry_info_args darg;
 	int ret = 0;
-	tl_to_darg(&darg, tl);
+	tl_to_darg(&darg, tl, val);
 	trace_ext4_fc_replay(sb, EXT4_FC_TAG_LINK, darg.ino,
 			darg.parent_ino, darg.dname_len);
 /*
  * Inode replay function
  */
-static int ext4_fc_replay_inode(struct super_block *sb, struct ext4_fc_tl *tl)
+static int ext4_fc_replay_inode(struct super_block *sb, struct ext4_fc_tl *tl,
+				u8 *val)
 {
-	struct ext4_fc_inode *fc_inode;
+	struct ext4_fc_inode fc_inode;
 	struct ext4_inode *raw_inode;
 	struct ext4_inode *raw_fc_inode;
 	struct inode *inode = NULL;
 	int inode_len, ino, ret, tag = le16_to_cpu(tl->fc_tag);
 	struct ext4_extent_header *eh;
-	fc_inode = (struct ext4_fc_inode *)ext4_fc_tag_val(tl);
+	memcpy(&fc_inode, val, sizeof(fc_inode));
-	ino = le32_to_cpu(fc_inode->fc_ino);
+	ino = le32_to_cpu(fc_inode.fc_ino);
 	trace_ext4_fc_replay(sb, tag, ino, 0, 0);
 	inode = ext4_iget(sb, ino, EXT4_IGET_NORMAL);
 	ext4_fc_record_modified_inode(sb, ino);
-	raw_fc_inode = (struct ext4_inode *)fc_inode->fc_raw_inode;
+	raw_fc_inode = (struct ext4_inode *)
+		(val + offsetof(struct ext4_fc_inode, fc_raw_inode));
 	ret = ext4_get_fc_inode_loc(sb, ino, &iloc);
 	if (ret)
 		goto out;
-	inode_len = ext4_fc_tag_len(tl) - sizeof(struct ext4_fc_inode);
+	inode_len = le16_to_cpu(tl->fc_len) - sizeof(struct ext4_fc_inode);
 	raw_inode = ext4_raw_inode(&iloc);
 	memcpy(raw_inode, raw_fc_inode, offsetof(struct ext4_inode, i_block));
  * inode for which we are trying to create a dentry here, should already have
  * been replayed before we start here.
  */
-static int ext4_fc_replay_create(struct super_block *sb, struct ext4_fc_tl *tl)
+static int ext4_fc_replay_create(struct super_block *sb, struct ext4_fc_tl *tl,
+				 u8 *val)
 {
 	int ret = 0;
 	struct inode *inode = NULL;
 	struct inode *dir = NULL;
 	struct dentry_info_args darg;
-	tl_to_darg(&darg, tl);
+	tl_to_darg(&darg, tl, val);
 	trace_ext4_fc_replay(sb, EXT4_FC_TAG_CREAT, darg.ino,
 			darg.parent_ino, darg.dname_len);
 /* Replay add range tag */
 static int ext4_fc_replay_add_range(struct super_block *sb,
-				struct ext4_fc_tl *tl)
+				    struct ext4_fc_tl *tl, u8 *val)
 {
-	struct ext4_fc_add_range *fc_add_ex;
+	struct ext4_fc_add_range fc_add_ex;
 	struct ext4_extent newex, *ex;
 	struct inode *inode;
 	ext4_lblk_t start, cur;
 	struct ext4_ext_path *path = NULL;
 	int ret;
-	fc_add_ex = (struct ext4_fc_add_range *)ext4_fc_tag_val(tl);
+	memcpy(&fc_add_ex, val, sizeof(fc_add_ex));
-	ex = (struct ext4_extent *)&fc_add_ex->fc_ex;
+	ex = (struct ext4_extent *)&fc_add_ex.fc_ex;
 	trace_ext4_fc_replay(sb, EXT4_FC_TAG_ADD_RANGE,
-		le32_to_cpu(fc_add_ex->fc_ino), le32_to_cpu(ex->ee_block),
+		le32_to_cpu(fc_add_ex.fc_ino), le32_to_cpu(ex->ee_block),
 		ext4_ext_get_actual_len(ex));
-	inode = ext4_iget(sb, le32_to_cpu(fc_add_ex->fc_ino),
+	inode = ext4_iget(sb, le32_to_cpu(fc_add_ex.fc_ino), EXT4_IGET_NORMAL);
-				EXT4_IGET_NORMAL);
 	if (IS_ERR(inode)) {
 		jbd_debug(1, "Inode not found.");
 		return 0;
 /* Replay DEL_RANGE tag */
 static int
-ext4_fc_replay_del_range(struct super_block *sb, struct ext4_fc_tl *tl)
+ext4_fc_replay_del_range(struct super_block *sb, struct ext4_fc_tl *tl,
+			 u8 *val)
 {
 	struct inode *inode;
-	struct ext4_fc_del_range *lrange;
+	struct ext4_fc_del_range lrange;
 	struct ext4_map_blocks map;
 	ext4_lblk_t cur, remaining;
 	int ret;
-	lrange = (struct ext4_fc_del_range *)ext4_fc_tag_val(tl);
+	memcpy(&lrange, val, sizeof(lrange));
-	cur = le32_to_cpu(lrange->fc_lblk);
+	cur = le32_to_cpu(lrange.fc_lblk);
-	remaining = le32_to_cpu(lrange->fc_len);
+	remaining = le32_to_cpu(lrange.fc_len);
 	trace_ext4_fc_replay(sb, EXT4_FC_TAG_DEL_RANGE,
-		le32_to_cpu(lrange->fc_ino), cur, remaining);
+		le32_to_cpu(lrange.fc_ino), cur, remaining);
-	inode = ext4_iget(sb, le32_to_cpu(lrange->fc_ino), EXT4_IGET_NORMAL);
+	inode = ext4_iget(sb, le32_to_cpu(lrange.fc_ino), EXT4_IGET_NORMAL);
 	if (IS_ERR(inode)) {
-		jbd_debug(1, "Inode %d not found", le32_to_cpu(lrange->fc_ino));
+		jbd_debug(1, "Inode %d not found", le32_to_cpu(lrange.fc_ino));
 		return 0;
 	}
 	ret = ext4_fc_record_modified_inode(sb, inode->i_ino);
 	jbd_debug(1, "DEL_RANGE, inode %ld, lblk %d, len %d\n",
-			inode->i_ino, le32_to_cpu(lrange->fc_lblk),
+			inode->i_ino, le32_to_cpu(lrange.fc_lblk),
-			le32_to_cpu(lrange->fc_len));
+			le32_to_cpu(lrange.fc_len));
 	while (remaining > 0) {
 		map.m_lblk = cur;
 		map.m_len = remaining;
 	}
 	ret = ext4_punch_hole(inode,
-		le32_to_cpu(lrange->fc_lblk) << sb->s_blocksize_bits,
+		le32_to_cpu(lrange.fc_lblk) << sb->s_blocksize_bits,
-		le32_to_cpu(lrange->fc_len) <<  sb->s_blocksize_bits);
+		le32_to_cpu(lrange.fc_len) <<  sb->s_blocksize_bits);
 	if (ret)
 		jbd_debug(1, "ext4_punch_hole returned %d", ret);
 	ext4_ext_replay_shrink_inode(inode,
 	struct ext4_sb_info *sbi = EXT4_SB(sb);
 	struct ext4_fc_replay_state *state;
 	int ret = JBD2_FC_REPLAY_CONTINUE;
-	struct ext4_fc_add_range *ext;
+	struct ext4_fc_add_range ext;
-	struct ext4_fc_tl *tl;
+	struct ext4_fc_tl tl;
-	struct ext4_fc_tail *tail;
+	struct ext4_fc_tail tail;
-	__u8 *start, *end;
+	__u8 *start, *end, *cur, *val;
-	struct ext4_fc_head *head;
+	struct ext4_fc_head head;
 	struct ext4_extent *ex;
 	state = &sbi->s_fc_replay_state;
 	}
 	state->fc_replay_expected_off++;
-	fc_for_each_tl(start, end, tl) {
+	for (cur = start; cur < end; cur = cur + sizeof(tl) + le16_to_cpu(tl.fc_len)) {
+		memcpy(&tl, cur, sizeof(tl));
+		val = cur + sizeof(tl);
 		jbd_debug(3, "Scan phase, tag:%s, blk %lld\n",
-			  tag2str(le16_to_cpu(tl->fc_tag)), bh->b_blocknr);
+			  tag2str(le16_to_cpu(tl.fc_tag)), bh->b_blocknr);
-		switch (le16_to_cpu(tl->fc_tag)) {
+		switch (le16_to_cpu(tl.fc_tag)) {
 		case EXT4_FC_TAG_ADD_RANGE:
-			ext = (struct ext4_fc_add_range *)ext4_fc_tag_val(tl);
+			memcpy(&ext, val, sizeof(ext));
-			ex = (struct ext4_extent *)&ext->fc_ex;
+			ex = (struct ext4_extent *)&ext.fc_ex;
 			ret = ext4_fc_record_regions(sb,
-				le32_to_cpu(ext->fc_ino),
+				le32_to_cpu(ext.fc_ino),
 				le32_to_cpu(ex->ee_block), ext4_ext_pblock(ex),
 				ext4_ext_get_actual_len(ex));
 			if (ret < 0)
 		case EXT4_FC_TAG_INODE:
 		case EXT4_FC_TAG_PAD:
 			state->fc_cur_tag++;
-			state->fc_crc = ext4_chksum(sbi, state->fc_crc, tl,
+			state->fc_crc = ext4_chksum(sbi, state->fc_crc, cur,
-					sizeof(*tl) + ext4_fc_tag_len(tl));
+					sizeof(tl) + le16_to_cpu(tl.fc_len));
 			break;
 		case EXT4_FC_TAG_TAIL:
 			state->fc_cur_tag++;
-			tail = (struct ext4_fc_tail *)ext4_fc_tag_val(tl);
+			memcpy(&tail, val, sizeof(tail));
-			state->fc_crc = ext4_chksum(sbi, state->fc_crc, tl,
+			state->fc_crc = ext4_chksum(sbi, state->fc_crc, cur,
-						sizeof(*tl) +
+						sizeof(tl) +
 						offsetof(struct ext4_fc_tail,
 						fc_crc));
-			if (le32_to_cpu(tail->fc_tid) == expected_tid &&
+			if (le32_to_cpu(tail.fc_tid) == expected_tid &&
-				le32_to_cpu(tail->fc_crc) == state->fc_crc) {
+				le32_to_cpu(tail.fc_crc) == state->fc_crc) {
 				state->fc_replay_num_tags = state->fc_cur_tag;
 				state->fc_regions_valid =
 					state->fc_regions_used;
 			state->fc_crc = 0;
 			break;
 		case EXT4_FC_TAG_HEAD:
-			head = (struct ext4_fc_head *)ext4_fc_tag_val(tl);
+			memcpy(&head, val, sizeof(head));
-			if (le32_to_cpu(head->fc_features) &
+			if (le32_to_cpu(head.fc_features) &
 				~EXT4_FC_SUPPORTED_FEATURES) {
 				ret = -EOPNOTSUPP;
 				break;
 			}
-			if (le32_to_cpu(head->fc_tid) != expected_tid) {
+			if (le32_to_cpu(head.fc_tid) != expected_tid) {
 				ret = JBD2_FC_REPLAY_STOP;
 				break;
 			}
 			state->fc_cur_tag++;
-			state->fc_crc = ext4_chksum(sbi, state->fc_crc, tl,
+			state->fc_crc = ext4_chksum(sbi, state->fc_crc, cur,
-					sizeof(*tl) + ext4_fc_tag_len(tl));
+					    sizeof(tl) + le16_to_cpu(tl.fc_len));
 			break;
 		default:
 			ret = state->fc_replay_num_tags ?
 {
 	struct super_block *sb = journal->j_private;
 	struct ext4_sb_info *sbi = EXT4_SB(sb);
-	struct ext4_fc_tl *tl;
+	struct ext4_fc_tl tl;
-	__u8 *start, *end;
+	__u8 *start, *end, *cur, *val;
 	int ret = JBD2_FC_REPLAY_CONTINUE;
 	struct ext4_fc_replay_state *state = &sbi->s_fc_replay_state;
-	struct ext4_fc_tail *tail;
+	struct ext4_fc_tail tail;
 	if (pass == PASS_SCAN) {
 		state->fc_current_pass = PASS_SCAN;
 	start = (u8 *)bh->b_data;
 	end = (__u8 *)bh->b_data + journal->j_blocksize - 1;
-	fc_for_each_tl(start, end, tl) {
+	for (cur = start; cur < end; cur = cur + sizeof(tl) + le16_to_cpu(tl.fc_len)) {
+		memcpy(&tl, cur, sizeof(tl));
+		val = cur + sizeof(tl);
 		if (state->fc_replay_num_tags == 0) {
 			ret = JBD2_FC_REPLAY_STOP;
 			ext4_fc_set_bitmaps_and_counters(sb);
 			break;
 		}
 		jbd_debug(3, "Replay phase, tag:%s\n",
-				tag2str(le16_to_cpu(tl->fc_tag)));
+				tag2str(le16_to_cpu(tl.fc_tag)));
 		state->fc_replay_num_tags--;
-		switch (le16_to_cpu(tl->fc_tag)) {
+		switch (le16_to_cpu(tl.fc_tag)) {
 		case EXT4_FC_TAG_LINK:
-			ret = ext4_fc_replay_link(sb, tl);
+			ret = ext4_fc_replay_link(sb, &tl, val);
 			break;
 		case EXT4_FC_TAG_UNLINK:
-			ret = ext4_fc_replay_unlink(sb, tl);
+			ret = ext4_fc_replay_unlink(sb, &tl, val);
 			break;
 		case EXT4_FC_TAG_ADD_RANGE:
-			ret = ext4_fc_replay_add_range(sb, tl);
+			ret = ext4_fc_replay_add_range(sb, &tl, val);
 			break;
 		case EXT4_FC_TAG_CREAT:
-			ret = ext4_fc_replay_create(sb, tl);
+			ret = ext4_fc_replay_create(sb, &tl, val);
 			break;
 		case EXT4_FC_TAG_DEL_RANGE:
-			ret = ext4_fc_replay_del_range(sb, tl);
+			ret = ext4_fc_replay_del_range(sb, &tl, val);
 			break;
 		case EXT4_FC_TAG_INODE:
-			ret = ext4_fc_replay_inode(sb, tl);
+			ret = ext4_fc_replay_inode(sb, &tl, val);
 			break;
 		case EXT4_FC_TAG_PAD:
 			trace_ext4_fc_replay(sb, EXT4_FC_TAG_PAD, 0,
-				ext4_fc_tag_len(tl), 0);
+					     le16_to_cpu(tl.fc_len), 0);
 			break;
 		case EXT4_FC_TAG_TAIL:
 			trace_ext4_fc_replay(sb, EXT4_FC_TAG_TAIL, 0,
-				ext4_fc_tag_len(tl), 0);
+					     le16_to_cpu(tl.fc_len), 0);
-			tail = (struct ext4_fc_tail *)ext4_fc_tag_val(tl);
+			memcpy(&tail, val, sizeof(tail));
-			WARN_ON(le32_to_cpu(tail->fc_tid) != expected_tid);
+			WARN_ON(le32_to_cpu(tail.fc_tid) != expected_tid);
 			break;
 		case EXT4_FC_TAG_HEAD:
 			break;
 		default:
-			trace_ext4_fc_replay(sb, le16_to_cpu(tl->fc_tag), 0,
+			trace_ext4_fc_replay(sb, le16_to_cpu(tl.fc_tag), 0,
-				ext4_fc_tag_len(tl), 0);
+					     le16_to_cpu(tl.fc_len), 0);
 			ret = -ECANCELED;
 			break;
 		}

fs/ext4/fast_commit.h+0−19

@@ -153,13 +153,6 @@ struct ext4_fc_replay_state { · 152 unmodified lines
153	#define region_last(__region) (((__region)->lblk) + ((__region)->len) - 1)	153	#define region_last(__region) (((__region)->lblk) + ((__region)->len) - 1)
154	#endif	154	#endif
155		155
156	#define fc_for_each_tl(__start, __end, __tl) \
157	for (tl = (struct ext4_fc_tl *)(__start); \
158	(__u8 )tl < (__u8 )(__end); \
159	tl = (struct ext4_fc_tl )((__u8 )tl + \
160	sizeof(struct ext4_fc_tl) + \
161	+ le16_to_cpu(tl->fc_len)))
162
163	static inline const char *tag2str(__u16 tag)	156	static inline const char *tag2str(__u16 tag)
164	{	157	{
165	switch (tag) {	158	switch (tag) {
@@ -186,16 +179,4 @@ static inline const char *tag2str(__u16 tag) · 20 unmodified lines
186	}	179	}
187	}	180	}
188		181
189	/* Get length of a particular tlv */
190	static inline int ext4_fc_tag_len(struct ext4_fc_tl *tl)
191	{
192	return le16_to_cpu(tl->fc_len);
193	}
194
195	/* Get a pointer to "value" of a tlv */
196	static inline __u8 ext4_fc_tag_val(struct ext4_fc_tl tl)
197	{
198	return (__u8 )tl + sizeof(tl);
199	}
200
201	#endif /* __FAST_COMMIT_H__ */	182	#endif /* __FAST_COMMIT_H__ */

fs/ext4/ialloc.c+4−2

 	if (is_directory) {
 		count = ext4_used_dirs_count(sb, gdp) - 1;
 		ext4_used_dirs_set(sb, gdp, count);
-		percpu_counter_dec(&sbi->s_dirs_counter);
+		if (percpu_counter_initialized(&sbi->s_dirs_counter))
+			percpu_counter_dec(&sbi->s_dirs_counter);
 	}
 	ext4_inode_bitmap_csum_set(sb, block_group, gdp, bitmap_bh,
 				   EXT4_INODES_PER_GROUP(sb) / 8);
 	ext4_group_desc_csum_set(sb, block_group, gdp);
 	ext4_unlock_group(sb, block_group);
-	percpu_counter_inc(&sbi->s_freeinodes_counter);
+	if (percpu_counter_initialized(&sbi->s_freeinodes_counter))
+		percpu_counter_inc(&sbi->s_freeinodes_counter);
 	if (sbi->s_log_groups_per_flex) {
 		struct flex_groups *fg;

fs/ext4/mballoc.c+1−1

@@ -3217,7 +3217,7 @@ static int ext4_mb_init_backend(struct super_block *sb) · 3216 unmodified lines
3217	*/	3217	*/
3218	if (sbi->s_es->s_log_groups_per_flex >= 32) {	3218	if (sbi->s_es->s_log_groups_per_flex >= 32) {
3219	ext4_msg(sb, KERN_ERR, "too many log groups per flexible block group");	3219	ext4_msg(sb, KERN_ERR, "too many log groups per flexible block group");
3220	goto err_freesgi;	3220	goto err_freebuddy;
3221	}	3221	}
3222	sbi->s_mb_prefetch = min_t(uint, 1 << sbi->s_es->s_log_groups_per_flex,	3222	sbi->s_mb_prefetch = min_t(uint, 1 << sbi->s_es->s_log_groups_per_flex,
3223	BLK_MAX_SEGMENT_SIZE >> (sb->s_blocksize_bits - 9));	3223	BLK_MAX_SEGMENT_SIZE >> (sb->s_blocksize_bits - 9));

fs/ext4/namei.c+4−2

 	struct dx_hash_info *hinfo = &name->hinfo;
 	int len;
-	if (!IS_CASEFOLDED(dir) || !dir->i_sb->s_encoding) {
+	if (!IS_CASEFOLDED(dir) || !dir->i_sb->s_encoding ||
+	    (IS_ENCRYPTED(dir) && !fscrypt_has_encryption_key(dir))) {
 		cf_name->name = NULL;
 		return 0;
 	}
 #endif
 #ifdef CONFIG_UNICODE
-	if (parent->i_sb->s_encoding && IS_CASEFOLDED(parent)) {
+	if (parent->i_sb->s_encoding && IS_CASEFOLDED(parent) &&
+	    (!IS_ENCRYPTED(parent) || fscrypt_has_encryption_key(parent))) {
 		if (fname->cf_name.name) {
 			struct qstr cf = {.name = fname->cf_name.name,
 					  .len = fname->cf_name.len};

fs/ext4/super.c+9−2

 	}
 	if (sb->s_blocksize != blocksize) {
+		/*
+		 * bh must be released before kill_bdev(), otherwise
+		 * it won't be freed and its page also. kill_bdev()
+		 * is called by sb_set_blocksize().
+		 */
+		brelse(bh);
 		/* Validate the filesystem blocksize */
 		if (!sb_set_blocksize(sb, blocksize)) {
 			ext4_msg(sb, KERN_ERR, "bad block size %d",
 					blocksize);
+			bh = NULL;
 			goto failed_mount;
 		}
-		brelse(bh);
 		logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
 		offset = do_div(logical_sb_block, blocksize);
 		bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
 		kfree(get_qf_name(sb, sbi, i));
 #endif
 	fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
-	ext4_blkdev_remove(sbi);
+	/* ext4_blkdev_remove() calls kill_bdev(), release bh before it. */
 	brelse(bh);
+	ext4_blkdev_remove(sbi);
 out_fail:
 	sb->s_fs_info = NULL;
 	kfree(sbi->s_blockgroup_lock);

fs/ext4/sysfs.c+4−0

 #endif
 EXT4_ATTR_FEATURE(metadata_csum_seed);
 EXT4_ATTR_FEATURE(fast_commit);
+#if defined(CONFIG_UNICODE) && defined(CONFIG_FS_ENCRYPTION)
 EXT4_ATTR_FEATURE(encrypted_casefold);
+#endif
 static struct attribute *ext4_feat_attrs[] = {
 	ATTR_LIST(lazy_itable_init),
 #endif
 	ATTR_LIST(metadata_csum_seed),
 	ATTR_LIST(fast_commit),
+#if defined(CONFIG_UNICODE) && defined(CONFIG_FS_ENCRYPTION)
 	ATTR_LIST(encrypted_casefold),
+#endif
 	NULL,
 };
 ATTRIBUTE_GROUPS(ext4_feat);

fs/gfs2/file.c+4−1

 		current->backing_dev_info = inode_to_bdi(inode);
 		buffered = iomap_file_buffered_write(iocb, from, &gfs2_iomap_ops);
 		current->backing_dev_info = NULL;
-		if (unlikely(buffered <= 0))
+		if (unlikely(buffered <= 0)) {
+			if (!ret)
+				ret = buffered;
 			goto out_unlock;
+		}
 		/*
 		 * We need to ensure that the page cache pages are written to

fs/gfs2/glock.c+24−4

 	spin_unlock(&gl->gl_lockref.lock);
 }
+static bool is_system_glock(struct gfs2_glock *gl)
+{
+	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
+	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
+	if (gl == m_ip->i_gl)
+		return true;
+	return false;
+}
 /**
  * do_xmote - Calls the DLM to change the state of a lock
  * @gl: The lock state
 	 * to see sd_log_error and withdraw, and in the meantime, requeue the
 	 * work for later.
 	 *
+	 * We make a special exception for some system glocks, such as the
+	 * system statfs inode glock, which needs to be granted before the
+	 * gfs2_quotad daemon can exit, and that exit needs to finish before
+	 * we can unmount the withdrawn file system.
+	 *
 	 * However, if we're just unlocking the lock (say, for unmount, when
 	 * gfs2_gl_hash_clear calls clear_glock) and recovery is complete
 	 * then it's okay to tell dlm to unlock it.
 	 */
 	if (unlikely(sdp->sd_log_error && !gfs2_withdrawn(sdp)))
 		gfs2_withdraw_delayed(sdp);
-	if (glock_blocked_by_withdraw(gl)) {
+	if (glock_blocked_by_withdraw(gl) &&
-		if (target != LM_ST_UNLOCKED ||
+	    (target != LM_ST_UNLOCKED ||
-		    test_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags)) {
+	     test_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags))) {
+		if (!is_system_glock(gl)) {
 			gfs2_glock_queue_work(gl, GL_GLOCK_DFT_HOLD);
 			goto out;
+		} else {
+			clear_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);
 		}
 	}
 	    glock_blocked_by_withdraw(gl) &&
 	    gh->gh_gl != sdp->sd_jinode_gl) {
 		sdp->sd_glock_dqs_held++;
+		spin_unlock(&gl->gl_lockref.lock);
 		might_sleep();
 		wait_on_bit(&sdp->sd_flags, SDF_WITHDRAW_RECOVERY,
 			    TASK_UNINTERRUPTIBLE);
+		spin_lock(&gl->gl_lockref.lock);
 	}
 	if (gh->gh_flags & GL_NOCACHE)
 		handle_callback(gl, LM_ST_UNLOCKED, 0, false);
 	while(!list_empty(list)) {
 		gl = list_first_entry(list, struct gfs2_glock, gl_lru);
 		list_del_init(&gl->gl_lru);
+		clear_bit(GLF_LRU, &gl->gl_flags);
 		if (!spin_trylock(&gl->gl_lockref.lock)) {
 add_back_to_lru:
 			list_add(&gl->gl_lru, &lru_list);
 		if (!test_bit(GLF_LOCK, &gl->gl_flags)) {
 			list_move(&gl->gl_lru, &dispose);
 			atomic_dec(&lru_count);
-			clear_bit(GLF_LRU, &gl->gl_flags);
 			freed++;
 			continue;
 		}

fs/gfs2/glops.c+1−1

@@ -396,7 +396,7 @@ static int gfs2_dinode_in(struct gfs2_inode ip, const void buf) · 395 unmodified lines
396	struct timespec64 atime;	396	struct timespec64 atime;
397	u16 height, depth;	397	u16 height, depth;
398	umode_t mode = be32_to_cpu(str->di_mode);	398	umode_t mode = be32_to_cpu(str->di_mode);
399	bool is_new = ip->i_inode.i_flags & I_NEW;	399	bool is_new = ip->i_inode.i_state & I_NEW;
400		400
401	if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)))	401	if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)))
402	goto corrupt;	402	goto corrupt;

fs/gfs2/log.c+3−3

 }
 /**
- * ail_drain - drain the ail lists after a withdraw
+ * gfs2_ail_drain - drain the ail lists after a withdraw
  * @sdp: Pointer to GFS2 superblock
  */
-static void ail_drain(struct gfs2_sbd *sdp)
+void gfs2_ail_drain(struct gfs2_sbd *sdp)
 {
 	struct gfs2_trans *tr;
 		list_del(&tr->tr_list);
 		gfs2_trans_free(sdp, tr);
 	}
+	gfs2_drain_revokes(sdp);
 	spin_unlock(&sdp->sd_ail_lock);
 }
 	if (tr && list_empty(&tr->tr_list))
 		list_add(&tr->tr_list, &sdp->sd_ail1_list);
 	spin_unlock(&sdp->sd_ail_lock);
-	ail_drain(sdp); /* frees all transactions */
 	tr = NULL;
 	goto out_end;
 }

fs/gfs2/log.h+1−0

@@ -93,5 +93,6 @@ extern int gfs2_logd(void *data); · 92 unmodified lines
93	extern void gfs2_add_revoke(struct gfs2_sbd sdp, struct gfs2_bufdata bd);	93	extern void gfs2_add_revoke(struct gfs2_sbd sdp, struct gfs2_bufdata bd);
94	extern void gfs2_glock_remove_revoke(struct gfs2_glock *gl);	94	extern void gfs2_glock_remove_revoke(struct gfs2_glock *gl);
95	extern void gfs2_flush_revokes(struct gfs2_sbd *sdp);	95	extern void gfs2_flush_revokes(struct gfs2_sbd *sdp);
		96	extern void gfs2_ail_drain(struct gfs2_sbd *sdp);
96		97
97	#endif /* __LOG_DOT_H__ */	98	#endif /* __LOG_DOT_H__ */

fs/gfs2/lops.c+6−1

 	gfs2_log_write_page(sdp, page);
 }
-static void revoke_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
+void gfs2_drain_revokes(struct gfs2_sbd *sdp)
 {
 	struct list_head *head = &sdp->sd_log_revokes;
 	struct gfs2_bufdata *bd;
 	}
 }
+static void revoke_lo_after_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
+{
+	gfs2_drain_revokes(sdp);
+}
 static void revoke_lo_before_scan(struct gfs2_jdesc *jd,
 				  struct gfs2_log_header_host *head, int pass)
 {

fs/gfs2/lops.h+1−0

@@ -20,6 +20,7 @@ extern void gfs2_log_submit_bio(struct bio **biop, int opf); · 19 unmodified lines
20	extern void gfs2_pin(struct gfs2_sbd sdp, struct buffer_head bh);	20	extern void gfs2_pin(struct gfs2_sbd sdp, struct buffer_head bh);
21	extern int gfs2_find_jhead(struct gfs2_jdesc *jd,	21	extern int gfs2_find_jhead(struct gfs2_jdesc *jd,
22	struct gfs2_log_header_host *head, bool keep_cache);	22	struct gfs2_log_header_host *head, bool keep_cache);
		23	extern void gfs2_drain_revokes(struct gfs2_sbd *sdp);
23	static inline unsigned int buf_limit(struct gfs2_sbd *sdp)	24	static inline unsigned int buf_limit(struct gfs2_sbd *sdp)
24	{	25	{
25	return sdp->sd_ldptrs;	26	return sdp->sd_ldptrs;

fs/gfs2/util.c+1−0

@@ -131,6 +131,7 @@ static void signal_our_withdraw(struct gfs2_sbd *sdp) · 130 unmodified lines
131	if (test_bit(SDF_NORECOVERY, &sdp->sd_flags) \|\| !sdp->sd_jdesc)	131	if (test_bit(SDF_NORECOVERY, &sdp->sd_flags) \|\| !sdp->sd_jdesc)
132	return;	132	return;
133		133
		134	gfs2_ail_drain(sdp); /* frees all transactions */
134	inode = sdp->sd_jdesc->jd_inode;	135	inode = sdp->sd_jdesc->jd_inode;
135	ip = GFS2_I(inode);	136	ip = GFS2_I(inode);
136	i_gl = ip->i_gl;	137	i_gl = ip->i_gl;

fs/io_uring.c+30−13

 	task_work_func_t	func;
 };
+enum {
+	IORING_RSRC_FILE		= 0,
+	IORING_RSRC_BUFFER		= 1,
+};
 /*
  * NOTE! Each of the iocb union members has the file pointer
  * as the first entry in their struct definition. So you can
 {
 	int i, ret;
+	imu->acct_pages = 0;
 	for (i = 0; i < nr_pages; i++) {
 		if (!PageCompound(pages[i])) {
 			imu->acct_pages++;
 			IORING_FEAT_SUBMIT_STABLE | IORING_FEAT_RW_CUR_POS |
 			IORING_FEAT_CUR_PERSONALITY | IORING_FEAT_FAST_POLL |
 			IORING_FEAT_POLL_32BITS | IORING_FEAT_SQPOLL_NONFIXED |
-			IORING_FEAT_EXT_ARG | IORING_FEAT_NATIVE_WORKERS;
+			IORING_FEAT_EXT_ARG | IORING_FEAT_NATIVE_WORKERS |
+			IORING_FEAT_RSRC_TAGS;
 	if (copy_to_user(params, p, sizeof(*p))) {
 		ret = -EFAULT;
 }
 static int io_register_rsrc_update(struct io_ring_ctx *ctx, void __user *arg,
-				   unsigned size)
+				   unsigned size, unsigned type)
 {
 	struct io_uring_rsrc_update2 up;
 		return -EINVAL;
 	if (copy_from_user(&up, arg, sizeof(up)))
 		return -EFAULT;
-	if (!up.nr)
+	if (!up.nr || up.resv)
 		return -EINVAL;
-	return __io_register_rsrc_update(ctx, up.type, &up, up.nr);
+	return __io_register_rsrc_update(ctx, type, &up, up.nr);
 }
 static int io_register_rsrc(struct io_ring_ctx *ctx, void __user *arg,
-			    unsigned int size)
+			    unsigned int size, unsigned int type)
 {
 	struct io_uring_rsrc_register rr;
 	memset(&rr, 0, sizeof(rr));
 	if (copy_from_user(&rr, arg, size))
 		return -EFAULT;
-	if (!rr.nr)
+	if (!rr.nr || rr.resv || rr.resv2)
 		return -EINVAL;
-	switch (rr.type) {
+	switch (type) {
 	case IORING_RSRC_FILE:
 		return io_sqe_files_register(ctx, u64_to_user_ptr(rr.data),
 					     rr.nr, u64_to_user_ptr(rr.tags));
 	case IORING_REGISTER_PROBE:
 	case IORING_REGISTER_PERSONALITY:
 	case IORING_UNREGISTER_PERSONALITY:
-	case IORING_REGISTER_RSRC:
+	case IORING_REGISTER_FILES2:
-	case IORING_REGISTER_RSRC_UPDATE:
+	case IORING_REGISTER_FILES_UPDATE2:
+	case IORING_REGISTER_BUFFERS2:
+	case IORING_REGISTER_BUFFERS_UPDATE:
 		return false;
 	default:
 		return true;
 	case IORING_REGISTER_RESTRICTIONS:
 		ret = io_register_restrictions(ctx, arg, nr_args);
 		break;
-	case IORING_REGISTER_RSRC:
+	case IORING_REGISTER_FILES2:
-		ret = io_register_rsrc(ctx, arg, nr_args);
+		ret = io_register_rsrc(ctx, arg, nr_args, IORING_RSRC_FILE);
+		break;
+	case IORING_REGISTER_FILES_UPDATE2:
+		ret = io_register_rsrc_update(ctx, arg, nr_args,
+					      IORING_RSRC_FILE);
+		break;
+	case IORING_REGISTER_BUFFERS2:
+		ret = io_register_rsrc(ctx, arg, nr_args, IORING_RSRC_BUFFER);
 		break;
-	case IORING_REGISTER_RSRC_UPDATE:
+	case IORING_REGISTER_BUFFERS_UPDATE:
-		ret = io_register_rsrc_update(ctx, arg, nr_args);
+		ret = io_register_rsrc_update(ctx, arg, nr_args,
+					      IORING_RSRC_BUFFER);
 		break;
 	default:
 		ret = -EINVAL;

fs/nfs/client.c+1−1

@@ -406,7 +406,7 @@ struct nfs_client nfs_get_client(const struct nfs_client_initdata cl_init) · 405 unmodified lines
406		406
407	if (cl_init->hostname == NULL) {	407	if (cl_init->hostname == NULL) {
408	WARN_ON(1);	408	WARN_ON(1);
409	return NULL;	409	return ERR_PTR(-EINVAL);
410	}	410	}
411		411
412	/* see if the client already exists */	412	/* see if the client already exists */

fs/nfs/nfs4_fs.h+1−0

@@ -205,6 +205,7 @@ struct nfs4_exception { · 204 unmodified lines
205	struct inode *inode;	205	struct inode *inode;
206	nfs4_stateid *stateid;	206	nfs4_stateid *stateid;
207	long timeout;	207	long timeout;
		208	unsigned char task_is_privileged : 1;
208	unsigned char delay : 1,	209	unsigned char delay : 1,
209	recovering : 1,	210	recovering : 1,
210	retry : 1;	211	retry : 1;

fs/nfs/nfs4client.c+1−1

 		 */
 		nfs_mark_client_ready(clp, -EPERM);
 	}
-	nfs_put_client(clp);
 	clear_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags);
+	nfs_put_client(clp);
 	return old;
 error:

fs/nfs/nfs4proc.c+30−7

 		goto out_retry;
 	}
 	if (exception->recovering) {
+		if (exception->task_is_privileged)
+			return -EDEADLOCK;
 		ret = nfs4_wait_clnt_recover(clp);
 		if (test_bit(NFS_MIG_FAILED, &server->mig_status))
 			return -EIO;
 		goto out_retry;
 	}
 	if (exception->recovering) {
+		if (exception->task_is_privileged)
+			return -EDEADLOCK;
 		rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
 		if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)
 			rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
 			server->caps |= NFS_CAP_HARDLINKS;
 		if (res.has_symlinks != 0)
 			server->caps |= NFS_CAP_SYMLINKS;
+#ifdef CONFIG_NFS_V4_SECURITY_LABEL
+		if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL)
+			server->caps |= NFS_CAP_SECURITY_LABEL;
+#endif
 		if (!(res.attr_bitmask[0] & FATTR4_WORD0_FILEID))
 			server->fattr_valid &= ~NFS_ATTR_FATTR_FILEID;
 		if (!(res.attr_bitmask[1] & FATTR4_WORD1_MODE))
 			server->fattr_valid &= ~NFS_ATTR_FATTR_CTIME;
 		if (!(res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY))
 			server->fattr_valid &= ~NFS_ATTR_FATTR_MTIME;
-#ifdef CONFIG_NFS_V4_SECURITY_LABEL
-		if (!(res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL))
-			server->fattr_valid &= ~NFS_ATTR_FATTR_V4_SECURITY_LABEL;
-#endif
 		memcpy(server->attr_bitmask_nl, res.attr_bitmask,
 				sizeof(server->attr_bitmask));
 		server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
 	do {
 		err = __nfs4_proc_set_acl(inode, buf, buflen);
 		trace_nfs4_set_acl(inode, err);
+		if (err == -NFS4ERR_BADOWNER || err == -NFS4ERR_BADNAME) {
+			/*
+			 * no need to retry since the kernel
+			 * isn't involved in encoding the ACEs.
+			 */
+			err = -EINVAL;
+			break;
+		}
 		err = nfs4_handle_exception(NFS_SERVER(inode), err,
 				&exception);
 	} while (exception.retry);
 	struct nfs4_exception exception = {
 		.inode = data->inode,
 		.stateid = &data->stateid,
+		.task_is_privileged = data->args.seq_args.sa_privileged,
 	};
 	if (!nfs4_sequence_done(task, &data->res.seq_res))
 	data = kzalloc(sizeof(*data), GFP_NOFS);
 	if (data == NULL)
 		return -ENOMEM;
-	nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, 0);
 	nfs4_state_protect(server->nfs_client,
 			NFS_SP4_MACH_CRED_CLEANUP,
 		}
 	}
+	if (!data->inode)
+		nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1,
+				   1);
+	else
+		nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1,
+				   0);
 	task_setup_data.callback_data = data;
 	msg.rpc_argp = &data->args;
 	msg.rpc_resp = &data->res;
 			&task_setup_data.rpc_client, &msg);
 	dprintk("--> %s\n", __func__);
+	lrp->inode = nfs_igrab_and_active(lrp->args.inode);
 	if (!sync) {
-		lrp->inode = nfs_igrab_and_active(lrp->args.inode);
 		if (!lrp->inode) {
 			nfs4_layoutreturn_release(lrp);
 			return -EAGAIN;
 		}
 		task_setup_data.flags |= RPC_TASK_ASYNC;
 	}
-	nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1, 0);
+	if (!lrp->inode)
+		nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1,
+				   1);
+	else
+		nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1,
+				   0);
 	task = rpc_run_task(&task_setup_data);
 	if (IS_ERR(task))
 		return PTR_ERR(task);

fs/nfs/nfstrace.h+0−4

 		{ O_NOATIME, "O_NOATIME" }, \
 		{ O_CLOEXEC, "O_CLOEXEC" })
-TRACE_DEFINE_ENUM(FMODE_READ);
-TRACE_DEFINE_ENUM(FMODE_WRITE);
-TRACE_DEFINE_ENUM(FMODE_EXEC);
 #define show_fmode_flags(mode) \
 	__print_flags(mode, "|", \
 		{ ((__force unsigned long)FMODE_READ), "READ" }, \

fs/notify/fanotify/fanotify_user.c+24−6

 	 * events generated by the listener process itself, without disclosing
 	 * the pids of other processes.
 	 */
-	if (!capable(CAP_SYS_ADMIN) &&
+	if (FAN_GROUP_FLAG(group, FANOTIFY_UNPRIV) &&
 	    task_tgid(current) != event->pid)
 		metadata.pid = 0;
-	if (path && path->mnt && path->dentry) {
+	/*
+	 * For now, fid mode is required for an unprivileged listener and
+	 * fid mode does not report fd in events.  Keep this check anyway
+	 * for safety in case fid mode requirement is relaxed in the future
+	 * to allow unprivileged listener to get events with no fd and no fid.
+	 */
+	if (!FAN_GROUP_FLAG(group, FANOTIFY_UNPRIV) &&
+	    path && path->mnt && path->dentry) {
 		fd = create_fd(group, path, &f);
 		if (fd < 0)
 			return fd;
 	int f_flags, fd;
 	unsigned int fid_mode = flags & FANOTIFY_FID_BITS;
 	unsigned int class = flags & FANOTIFY_CLASS_BITS;
+	unsigned int internal_flags = 0;
 	pr_debug("%s: flags=%x event_f_flags=%x\n",
 		 __func__, flags, event_f_flags);
 		 */
 		if ((flags & FANOTIFY_ADMIN_INIT_FLAGS) || !fid_mode)
 			return -EPERM;
+		/*
+		 * Setting the internal flag FANOTIFY_UNPRIV on the group
+		 * prevents setting mount/filesystem marks on this group and
+		 * prevents reporting pid and open fd in events.
+		 */
+		internal_flags |= FANOTIFY_UNPRIV;
 	}
 #ifdef CONFIG_AUDITSYSCALL
 		goto out_destroy_group;
 	}
-	group->fanotify_data.flags = flags;
+	group->fanotify_data.flags = flags | internal_flags;
 	group->memcg = get_mem_cgroup_from_mm(current->mm);
 	group->fanotify_data.merge_hash = fanotify_alloc_merge_hash();
 	group = f.file->private_data;
 	/*
-	 * An unprivileged user is not allowed to watch a mount point nor
+	 * An unprivileged user is not allowed to setup mount nor filesystem
-	 * a filesystem.
+	 * marks.  This also includes setting up such marks by a group that
+	 * was initialized by an unprivileged user.
 	 */
 	ret = -EPERM;
-	if (!capable(CAP_SYS_ADMIN) &&
+	if ((!capable(CAP_SYS_ADMIN) ||
+	     FAN_GROUP_FLAG(group, FANOTIFY_UNPRIV)) &&
 	    mark_type != FAN_MARK_INODE)
 		goto fput_and_out;
 	max_marks = clamp(max_marks, FANOTIFY_OLD_DEFAULT_MAX_MARKS,
 				     FANOTIFY_DEFAULT_MAX_USER_MARKS);
+	BUILD_BUG_ON(FANOTIFY_INIT_FLAGS & FANOTIFY_INTERNAL_GROUP_FLAGS);
 	BUILD_BUG_ON(HWEIGHT32(FANOTIFY_INIT_FLAGS) != 10);
 	BUILD_BUG_ON(HWEIGHT32(FANOTIFY_MARK_FLAGS) != 9);

fs/notify/fdinfo.c+1−1

@@ -144,7 +144,7 @@ void fanotify_show_fdinfo(struct seq_file m, struct file f) · 143 unmodified lines
144	struct fsnotify_group *group = f->private_data;	144	struct fsnotify_group *group = f->private_data;
145		145
146	seq_printf(m, "fanotify flags:%x event-flags:%x\n",	146	seq_printf(m, "fanotify flags:%x event-flags:%x\n",
147	group->fanotify_data.flags,	147	group->fanotify_data.flags & FANOTIFY_INIT_FLAGS,
148	group->fanotify_data.f_flags);	148	group->fanotify_data.f_flags);
149		149
150	show_fdinfo(m, f, fanotify_fdinfo);	150	show_fdinfo(m, f, fanotify_fdinfo);

fs/ocfs2/file.c+50−5

@@ -1855,6 +1855,45 @@ out: · 1854 unmodified lines
1855	return ret;	1855	return ret;
1856	}	1856	}
1857		1857
		1858	/*
		1859	* zero out partial blocks of one cluster.
		1860	*
		1861	* start: file offset where zero starts, will be made upper block aligned.
		1862	* len: it will be trimmed to the end of current cluster if "start + len"
		1863	* is bigger than it.
		1864	*/
		1865	static int ocfs2_zeroout_partial_cluster(struct inode *inode,
		1866	u64 start, u64 len)
		1867	{
		1868	int ret;
		1869	u64 start_block, end_block, nr_blocks;
		1870	u64 p_block, offset;
		1871	u32 cluster, p_cluster, nr_clusters;
		1872	struct super_block *sb = inode->i_sb;
		1873	u64 end = ocfs2_align_bytes_to_clusters(sb, start);
		1874
		1875	if (start + len < end)
		1876	end = start + len;
		1877
		1878	start_block = ocfs2_blocks_for_bytes(sb, start);
		1879	end_block = ocfs2_blocks_for_bytes(sb, end);
		1880	nr_blocks = end_block - start_block;
		1881	if (!nr_blocks)
		1882	return 0;
		1883
		1884	cluster = ocfs2_bytes_to_clusters(sb, start);
		1885	ret = ocfs2_get_clusters(inode, cluster, &p_cluster,
		1886	&nr_clusters, NULL);
		1887	if (ret)
		1888	return ret;
		1889	if (!p_cluster)
		1890	return 0;
		1891
		1892	offset = start_block - ocfs2_clusters_to_blocks(sb, cluster);
		1893	p_block = ocfs2_clusters_to_blocks(sb, p_cluster) + offset;
		1894	return sb_issue_zeroout(sb, p_block, nr_blocks, GFP_NOFS);
		1895	}
		1896
1858	/*	1897	/*
1859	* Parts of this function taken from xfs_change_file_space()	1898	* Parts of this function taken from xfs_change_file_space()
1860	*/	1899	*/
@@ -1865,7 +1904,7 @@ static int __ocfs2_change_file_space(struct file file, struct inode inode, · 4 unmodified lines
1865	{	1904	{
1866	int ret;	1905	int ret;
1867	s64 llen;	1906	s64 llen;
1868	loff_t size;	1907	loff_t size, orig_isize;
1869	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);	1908	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1870	struct buffer_head *di_bh = NULL;	1909	struct buffer_head *di_bh = NULL;
1871	handle_t *handle;	1910	handle_t *handle;
@@ -1896,6 +1935,7 @@ static int __ocfs2_change_file_space(struct file file, struct inode inode, · 24 unmodified lines
1896	goto out_inode_unlock;	1935	goto out_inode_unlock;
1897	}	1936	}
1898		1937
		1938	orig_isize = i_size_read(inode);
1899	switch (sr->l_whence) {	1939	switch (sr->l_whence) {
1900	case 0: /SEEK_SET/	1940	case 0: /SEEK_SET/
1901	break;	1941	break;
@@ -1903,7 +1943,7 @@ static int __ocfs2_change_file_space(struct file file, struct inode inode, · 1 unmodified line
1903	sr->l_start += f_pos;	1943	sr->l_start += f_pos;
1904	break;	1944	break;
1905	case 2: /SEEK_END/	1945	case 2: /SEEK_END/
1906	sr->l_start += i_size_read(inode);	1946	sr->l_start += orig_isize;
1907	break;	1947	break;
1908	default:	1948	default:
1909	ret = -EINVAL;	1949	ret = -EINVAL;
@@ -1957,6 +1997,14 @@ static int __ocfs2_change_file_space(struct file file, struct inode inode, · 47 unmodified lines
1957	default:	1997	default:
1958	ret = -EINVAL;	1998	ret = -EINVAL;
1959	}	1999	}
		2000
		2001	/* zeroout eof blocks in the cluster. */
		2002	if (!ret && change_size && orig_isize < size) {
		2003	ret = ocfs2_zeroout_partial_cluster(inode, orig_isize,
		2004	size - orig_isize);
		2005	if (!ret)
		2006	i_size_write(inode, size);
		2007	}
1960	up_write(&OCFS2_I(inode)->ip_alloc_sem);	2008	up_write(&OCFS2_I(inode)->ip_alloc_sem);
1961	if (ret) {	2009	if (ret) {
1962	mlog_errno(ret);	2010	mlog_errno(ret);
@@ -1973,9 +2021,6 @@ static int __ocfs2_change_file_space(struct file file, struct inode inode, · 10 unmodified lines
1973	goto out_inode_unlock;	2021	goto out_inode_unlock;
1974	}	2022	}
1975		2023
1976	if (change_size && i_size_read(inode) < size)
1977	i_size_write(inode, size);
1978
1979	inode->i_ctime = inode->i_mtime = current_time(inode);	2024	inode->i_ctime = inode->i_mtime = current_time(inode);
1980	ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);	2025	ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
1981	if (ret < 0)	2026	if (ret < 0)

fs/proc/base.c+8−1

 }
 #ifdef CONFIG_SECURITY
+static int proc_pid_attr_open(struct inode *inode, struct file *file)
+{
+	return __mem_open(inode, file, PTRACE_MODE_READ_FSCREDS);
+}
 static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
 				  size_t count, loff_t *ppos)
 {
 	int rv;
 	/* A task may only write when it was the opener. */
-	if (file->f_cred != current_real_cred())
+	if (file->private_data != current->mm)
 		return -EPERM;
 	rcu_read_lock();
 }
 static const struct file_operations proc_pid_attr_operations = {
+	.open		= proc_pid_attr_open,
 	.read		= proc_pid_attr_read,
 	.write		= proc_pid_attr_write,
 	.llseek		= generic_file_llseek,
+	.release	= mem_release,
 };
 #define LSM_DIR_OPS(LSM) \

include/asm-generic/vmlinux.lds.h+1−0

@@ -960,6 +960,7 @@ · 959 unmodified lines
960	#ifdef CONFIG_AMD_MEM_ENCRYPT	960	#ifdef CONFIG_AMD_MEM_ENCRYPT
961	#define PERCPU_DECRYPTED_SECTION \	961	#define PERCPU_DECRYPTED_SECTION \
962	. = ALIGN(PAGE_SIZE); \	962	. = ALIGN(PAGE_SIZE); \
		963	*(.data..decrypted) \
963	*(.data..percpu..decrypted) \	964	*(.data..percpu..decrypted) \
964	. = ALIGN(PAGE_SIZE);	965	. = ALIGN(PAGE_SIZE);
965	#else	966	#else

include/dt-bindings/usb/pd.h+76−13

  * <20:16>  :: Reserved, Shall be set to zero
  * <15:0>   :: USB-IF assigned VID for this cable vendor
  */
+/* PD Rev2.0 definition */
+#define IDH_PTYPE_UNDEF		0
 /* SOP Product Type (UFP) */
 #define IDH_PTYPE_NOT_UFP       0
 #define IDH_PTYPE_HUB           1
 #define UFP_VDO_VER1_2		2
 /* Device Capability */
-#define DEV_USB2_CAPABLE	BIT(0)
+#define DEV_USB2_CAPABLE	(1 << 0)
-#define DEV_USB2_BILLBOARD	BIT(1)
+#define DEV_USB2_BILLBOARD	(1 << 1)
-#define DEV_USB3_CAPABLE	BIT(2)
+#define DEV_USB3_CAPABLE	(1 << 2)
-#define DEV_USB4_CAPABLE	BIT(3)
+#define DEV_USB4_CAPABLE	(1 << 3)
 /* Connector Type */
 #define UFP_RECEPTACLE		2
 /* Alternate Modes */
 #define UFP_ALTMODE_NOT_SUPP	0
-#define UFP_ALTMODE_TBT3	BIT(0)
+#define UFP_ALTMODE_TBT3	(1 << 0)
-#define UFP_ALTMODE_RECFG	BIT(1)
+#define UFP_ALTMODE_RECFG	(1 << 1)
-#define UFP_ALTMODE_NO_RECFG	BIT(2)
+#define UFP_ALTMODE_NO_RECFG	(1 << 2)
 /* USB Highest Speed */
 #define UFP_USB2_ONLY		0
  * <4:0>   :: Port number
  */
 #define DFP_VDO_VER1_1		1
-#define HOST_USB2_CAPABLE	BIT(0)
+#define HOST_USB2_CAPABLE	(1 << 0)
-#define HOST_USB3_CAPABLE	BIT(1)
+#define HOST_USB3_CAPABLE	(1 << 1)
-#define HOST_USB4_CAPABLE	BIT(2)
+#define HOST_USB4_CAPABLE	(1 << 2)
 #define DFP_RECEPTACLE		2
 #define DFP_CAPTIVE		3
 	 | ((pnum) & 0x1f))
 /*
- * Passive Cable VDO
+ * Cable VDO (for both Passive and Active Cable VDO in PD Rev2.0)
+ * ---------
+ * <31:28> :: Cable HW version
+ * <27:24> :: Cable FW version
+ * <23:20> :: Reserved, Shall be set to zero
+ * <19:18> :: type-C to Type-A/B/C/Captive (00b == A, 01 == B, 10 == C, 11 == Captive)
+ * <17>    :: Reserved, Shall be set to zero
+ * <16:13> :: cable latency (0001 == <10ns(~1m length))
+ * <12:11> :: cable termination type (11b == both ends active VCONN req)
+ * <10>    :: SSTX1 Directionality support (0b == fixed, 1b == cfgable)
+ * <9>     :: SSTX2 Directionality support
+ * <8>     :: SSRX1 Directionality support
+ * <7>     :: SSRX2 Directionality support
+ * <6:5>   :: Vbus current handling capability (01b == 3A, 10b == 5A)
+ * <4>     :: Vbus through cable (0b == no, 1b == yes)
+ * <3>     :: SOP" controller present? (0b == no, 1b == yes)
+ * <2:0>   :: USB SS Signaling support
+ *
+ * Passive Cable VDO (PD Rev3.0+)
  * ---------
  * <31:28> :: Cable HW version
  * <27:24> :: Cable FW version
  * <4:3>   :: Reserved, Shall be set to zero
  * <2:0>   :: USB highest speed
  *
- * Active Cable VDO 1
+ * Active Cable VDO 1 (PD Rev3.0+)
  * ---------
  * <31:28> :: Cable HW version
  * <27:24> :: Cable FW version
 #define CABLE_VDO_VER1_0	0
 #define CABLE_VDO_VER1_3	3
-/* Connector Type */
+/* Connector Type (_ATYPE and _BTYPE are for PD Rev2.0 only) */
+#define CABLE_ATYPE		0
+#define CABLE_BTYPE		1
 #define CABLE_CTYPE		2
 #define CABLE_CAPTIVE		3
 #define CABLE_CURR_3A		1
 #define CABLE_CURR_5A		2
+/* USB SuperSpeed Signaling Support (PD Rev2.0) */
+#define CABLE_USBSS_U2_ONLY	0
+#define CABLE_USBSS_U31_GEN1	1
+#define CABLE_USBSS_U31_GEN2	2
 /* USB Highest Speed */
 #define CABLE_USB2_ONLY		0
 #define CABLE_USB32_GEN1	1
 #define CABLE_USB32_4_GEN2	2
 #define CABLE_USB4_GEN3		3
+#define VDO_CABLE(hw, fw, cbl, lat, term, tx1d, tx2d, rx1d, rx2d, cur, vps, sopp, usbss) \
+	(((hw) & 0x7) << 28 | ((fw) & 0x7) << 24 | ((cbl) & 0x3) << 18		\
+	 | ((lat) & 0x7) << 13 | ((term) & 0x3) << 11 | (tx1d) << 10		\
+	 | (tx2d) << 9 | (rx1d) << 8 | (rx2d) << 7 | ((cur) & 0x3) << 5		\
+	 | (vps) << 4 | (sopp) << 3 | ((usbss) & 0x7))
 #define VDO_PCABLE(hw, fw, ver, conn, lat, term, vbm, cur, spd)			\
 	(((hw) & 0xf) << 28 | ((fw) & 0xf) << 24 | ((ver) & 0x7) << 21		\
 	 | ((conn) & 0x3) << 18 | ((lat) & 0xf) << 13 | ((term) & 0x3) << 11	\
 	 | ((hops) & 0x3) << 6 | (u2) << 5 | (u32) << 4 | (lane) << 3		\
 	 | (iso) << 2 | (gen))
+/*
+ * AMA VDO (PD Rev2.0)
+ * ---------
+ * <31:28> :: Cable HW version
+ * <27:24> :: Cable FW version
+ * <23:12> :: Reserved, Shall be set to zero
+ * <11>    :: SSTX1 Directionality support (0b == fixed, 1b == cfgable)
+ * <10>    :: SSTX2 Directionality support
+ * <9>     :: SSRX1 Directionality support
+ * <8>     :: SSRX2 Directionality support
+ * <7:5>   :: Vconn power
+ * <4>     :: Vconn power required
+ * <3>     :: Vbus power required
+ * <2:0>   :: USB SS Signaling support
+ */
+#define VDO_AMA(hw, fw, tx1d, tx2d, rx1d, rx2d, vcpwr, vcr, vbr, usbss) \
+	(((hw) & 0x7) << 28 | ((fw) & 0x7) << 24			\
+	 | (tx1d) << 11 | (tx2d) << 10 | (rx1d) << 9 | (rx2d) << 8	\
+	 | ((vcpwr) & 0x7) << 5 | (vcr) << 4 | (vbr) << 3		\
+	 | ((usbss) & 0x7))
+#define PD_VDO_AMA_VCONN_REQ(vdo)	(((vdo) >> 4) & 1)
+#define PD_VDO_AMA_VBUS_REQ(vdo)	(((vdo) >> 3) & 1)
+#define AMA_USBSS_U2_ONLY	0
+#define AMA_USBSS_U31_GEN1	1
+#define AMA_USBSS_U31_GEN2	2
+#define AMA_USBSS_BBONLY	3
 /*
  * VPD VDO
  * ---------

include/linux/avf/virtchnl.h+1−0

@@ -830,6 +830,7 @@ VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_proto_hdr); · 829 unmodified lines
830		830
831	struct virtchnl_proto_hdrs {	831	struct virtchnl_proto_hdrs {
832	u8 tunnel_level;	832	u8 tunnel_level;
		833	u8 pad[3];
833	/**	834	/**
834	* specify where protocol header start from.	835	* specify where protocol header start from.
835	* 0 - from the outer layer	836	* 0 - from the outer layer

include/linux/compiler_attributes.h+1−0

@@ -199,6 +199,7 @@ · 198 unmodified lines
199	* must end with any of these keywords:	199	* must end with any of these keywords:
200	* break;	200	* break;
201	* fallthrough;	201	* fallthrough;
		202	* continue;
202	* goto <label>;	203	* goto <label>;
203	* return [expression];	204	* return [expression];
204	*	205	*

include/linux/entry-kvm.h+2−1

 #define __LINUX_ENTRYKVM_H
 #include <linux/entry-common.h>
+#include <linux/tick.h>
 /* Transfer to guest mode work */
 #ifdef CONFIG_KVM_XFER_TO_GUEST_WORK
 static inline void xfer_to_guest_mode_prepare(void)
 {
 	lockdep_assert_irqs_disabled();
-	rcu_nocb_flush_deferred_wakeup();
+	tick_nohz_user_enter_prepare();
 }
 /**

include/linux/fanotify.h+4−0

@@ -51,6 +51,10 @@ extern struct ctl_table fanotify_table[]; /* for sysctl */ · 50 unmodified lines
51	#define FANOTIFY_INIT_FLAGS (FANOTIFY_ADMIN_INIT_FLAGS \| \	51	#define FANOTIFY_INIT_FLAGS (FANOTIFY_ADMIN_INIT_FLAGS \| \
52	FANOTIFY_USER_INIT_FLAGS)	52	FANOTIFY_USER_INIT_FLAGS)
53		53
		54	/* Internal group flags */
		55	#define FANOTIFY_UNPRIV 0x80000000
		56	#define FANOTIFY_INTERNAL_GROUP_FLAGS (FANOTIFY_UNPRIV)
		57
54	#define FANOTIFY_MARK_TYPE_BITS (FAN_MARK_INODE \| FAN_MARK_MOUNT \| \	58	#define FANOTIFY_MARK_TYPE_BITS (FAN_MARK_INODE \| FAN_MARK_MOUNT \| \
55	FAN_MARK_FILESYSTEM)	59	FAN_MARK_FILESYSTEM)
56		60

include/linux/fb.h+3−0

 /* drivers/video/fb_defio.c */
 int fb_deferred_io_mmap(struct fb_info *info, struct vm_area_struct *vma);
 extern void fb_deferred_io_init(struct fb_info *info);
+extern void fb_deferred_io_open(struct fb_info *info,
+				struct inode *inode,
+				struct file *file);
 extern void fb_deferred_io_cleanup(struct fb_info *info);
 extern int fb_deferred_io_fsync(struct file *file, loff_t start,
 				loff_t end, int datasync);

include/linux/hid.h+1−2

@@ -1167,8 +1167,7 @@ static inline void hid_hw_wait(struct hid_device *hdev) · 1166 unmodified lines
1167	*/	1167	*/
1168	static inline u32 hid_report_len(struct hid_report *report)	1168	static inline u32 hid_report_len(struct hid_report *report)
1169	{	1169	{
1170	/* equivalent to DIV_ROUND_UP(report->size, 8) + !!(report->id > 0) */	1170	return DIV_ROUND_UP(report->size, 8) + (report->id > 0);
1171	return ((report->size - 1) >> 3) + 1 + (report->id > 0);
1172	}	1171	}
1173		1172
1174	int hid_report_raw_event(struct hid_device hid, int type, u8 data, u32 size,	1173	int hid_report_raw_event(struct hid_device hid, int type, u8 data, u32 size,

include/linux/host1x.h+24−6

@@ -332,12 +332,30 @@ static inline struct host1x_device to_host1x_device(struct device dev) · 331 unmodified lines
332	int host1x_device_init(struct host1x_device *device);	332	int host1x_device_init(struct host1x_device *device);
333	int host1x_device_exit(struct host1x_device *device);	333	int host1x_device_exit(struct host1x_device *device);
334		334
335	int __host1x_client_register(struct host1x_client *client,	335	void __host1x_client_init(struct host1x_client client, struct lock_class_key key);
336	struct lock_class_key *key);	336	void host1x_client_exit(struct host1x_client *client);
337	#define host1x_client_register(class) \	337
338	({ \	338	#define host1x_client_init(client) \
339	static struct lock_class_key __key; \	339	({ \
340	__host1x_client_register(class, &__key); \	340	static struct lock_class_key __key; \
		341	__host1x_client_init(client, &__key); \
		342	})
		343
		344	int __host1x_client_register(struct host1x_client *client);
		345
		346	/*
		347	* Note that this wrapper calls __host1x_client_init() for compatibility
		348	* with existing callers. Callers that want to separately initialize and
		349	* register a host1x client must first initialize using either of the
		350	* __host1x_client_init() or host1x_client_init() functions and then use
		351	* the low-level __host1x_client_register() function to avoid the client
		352	* getting reinitialized.
		353	*/
		354	#define host1x_client_register(client) \
		355	({ \
		356	static struct lock_class_key __key; \
		357	__host1x_client_init(client, &__key); \
		358	__host1x_client_register(client); \
341	})	359	})
342		360
343	int host1x_client_unregister(struct host1x_client *client);	361	int host1x_client_unregister(struct host1x_client *client);

include/linux/kvm_host.h+9−1

@@ -1185,7 +1185,15 @@ __gfn_to_memslot(struct kvm_memslots *slots, gfn_t gfn) · 1184 unmodified lines
1185	static inline unsigned long	1185	static inline unsigned long
1186	__gfn_to_hva_memslot(const struct kvm_memory_slot *slot, gfn_t gfn)	1186	__gfn_to_hva_memslot(const struct kvm_memory_slot *slot, gfn_t gfn)
1187	{	1187	{
1188	return slot->userspace_addr + (gfn - slot->base_gfn) * PAGE_SIZE;	1188	/*
		1189	* The index was checked originally in search_memslots. To avoid
		1190	* that a malicious guest builds a Spectre gadget out of e.g. page
		1191	* table walks, do not let the processor speculate loads outside
		1192	* the guest's registered memslots.
		1193	*/
		1194	unsigned long offset = gfn - slot->base_gfn;
		1195	offset = array_index_nospec(offset, slot->npages);
		1196	return slot->userspace_addr + offset * PAGE_SIZE;
1189	}	1197	}
1190		1198
1191	static inline int memslot_id(struct kvm *kvm, gfn_t gfn)	1199	static inline int memslot_id(struct kvm *kvm, gfn_t gfn)

include/linux/mfd/rohm-bd70528.h+1−3

@@ -26,9 +26,7 @@ struct bd70528_data { · 25 unmodified lines
26	struct mutex rtc_timer_lock;	26	struct mutex rtc_timer_lock;
27	};	27	};
28		28
29	#define BD70528_BUCK_VOLTS 17	29	#define BD70528_BUCK_VOLTS 0x10
30	#define BD70528_BUCK_VOLTS 17
31	#define BD70528_BUCK_VOLTS 17
32	#define BD70528_LDO_VOLTS 0x20	30	#define BD70528_LDO_VOLTS 0x20
33		31
34	#define BD70528_REG_BUCK1_EN 0x0F	32	#define BD70528_REG_BUCK1_EN 0x0F

include/linux/mfd/rohm-bd71828.h+5−5

@@ -26,11 +26,11 @@ enum { · 25 unmodified lines
26	BD71828_REGULATOR_AMOUNT,	26	BD71828_REGULATOR_AMOUNT,
27	};	27	};
28		28
29	#define BD71828_BUCK1267_VOLTS 0xEF	29	#define BD71828_BUCK1267_VOLTS 0x100
30	#define BD71828_BUCK3_VOLTS 0x10	30	#define BD71828_BUCK3_VOLTS 0x20
31	#define BD71828_BUCK4_VOLTS 0x20	31	#define BD71828_BUCK4_VOLTS 0x40
32	#define BD71828_BUCK5_VOLTS 0x10	32	#define BD71828_BUCK5_VOLTS 0x20
33	#define BD71828_LDO_VOLTS 0x32	33	#define BD71828_LDO_VOLTS 0x40
34	/* LDO6 is fixed 1.8V voltage */	34	/* LDO6 is fixed 1.8V voltage */
35	#define BD71828_LDO_6_VOLTAGE 1800000	35	#define BD71828_LDO_6_VOLTAGE 1800000
36		36

include/linux/mlx4/device.h+1−0

@@ -630,6 +630,7 @@ struct mlx4_caps { · 629 unmodified lines
630	bool wol_port[MLX4_MAX_PORTS + 1];	630	bool wol_port[MLX4_MAX_PORTS + 1];
631	struct mlx4_rate_limit_caps rl_caps;	631	struct mlx4_rate_limit_caps rl_caps;
632	u32 health_buffer_addrs;	632	u32 health_buffer_addrs;
		633	bool map_clock_to_user;
633	};	634	};
634		635
635	struct mlx4_buf_list {	636	struct mlx4_buf_list {

include/linux/mlx5/mlx5_ifc.h+2−0

@@ -1289,6 +1289,8 @@ enum mlx5_fc_bulk_alloc_bitmask { · 1288 unmodified lines
1289		1289
1290	#define MLX5_FC_BULK_NUM_FCS(fc_enum) (MLX5_FC_BULK_SIZE_FACTOR * (fc_enum))	1290	#define MLX5_FC_BULK_NUM_FCS(fc_enum) (MLX5_FC_BULK_SIZE_FACTOR * (fc_enum))
1291		1291
		1292	#define MLX5_FT_MAX_MULTIPATH_LEVEL 63
		1293
1292	enum {	1294	enum {
1293	MLX5_STEERING_FORMAT_CONNECTX_5 = 0,	1295	MLX5_STEERING_FORMAT_CONNECTX_5 = 0,
1294	MLX5_STEERING_FORMAT_CONNECTX_6DX = 1,	1296	MLX5_STEERING_FORMAT_CONNECTX_6DX = 1,

include/linux/mm_types.h+20−7

 		 */
 		atomic_t has_pinned;
-		/**
-		 * @write_protect_seq: Locked when any thread is write
-		 * protecting pages mapped by this mm to enforce a later COW,
-		 * for instance during page table copying for fork().
-		 */
-		seqcount_t write_protect_seq;
 #ifdef CONFIG_MMU
 		atomic_long_t pgtables_bytes;	/* PTE page table pages */
 #endif
 		spinlock_t page_table_lock; /* Protects page tables and some
 					     * counters
 					     */
+		/*
+		 * With some kernel config, the current mmap_lock's offset
+		 * inside 'mm_struct' is at 0x120, which is very optimal, as
+		 * its two hot fields 'count' and 'owner' sit in 2 different
+		 * cachelines,  and when mmap_lock is highly contended, both
+		 * of the 2 fields will be accessed frequently, current layout
+		 * will help to reduce cache bouncing.
+		 *
+		 * So please be careful with adding new fields before
+		 * mmap_lock, which can easily push the 2 fields into one
+		 * cacheline.
+		 */
 		struct rw_semaphore mmap_lock;
 		struct list_head mmlist; /* List of maybe swapped mm's.	These
 		unsigned long stack_vm;	   /* VM_STACK */
 		unsigned long def_flags;
+		/**
+		 * @write_protect_seq: Locked when any thread is write
+		 * protecting pages mapped by this mm to enforce a later COW,
+		 * for instance during page table copying for fork().
+		 */
+		seqcount_t write_protect_seq;
 		spinlock_t arg_lock; /* protect the below fields */
 		unsigned long start_code, end_code, start_data, end_data;
 		unsigned long start_brk, brk, start_stack;
 		unsigned long arg_start, arg_end, env_start, env_end;

include/linux/pci.h+2−0

 struct device_node;
 struct irq_domain;
 struct irq_domain *pci_host_bridge_of_msi_domain(struct pci_bus *bus);
+bool pci_host_of_has_msi_map(struct device *dev);
 /* Arch may override this (weak) */
 struct device_node *pcibios_get_phb_of_node(struct pci_bus *bus);
 #else	/* CONFIG_OF */
 static inline struct irq_domain *
 pci_host_bridge_of_msi_domain(struct pci_bus *bus) { return NULL; }
+static inline bool pci_host_of_has_msi_map(struct device *dev) { return false; }
 #endif  /* CONFIG_OF */
 static inline struct device_node *

include/linux/pgtable.h+8−0

@@ -432,6 +432,14 @@ static inline void ptep_set_wrprotect(struct mm_struct *mm, unsigned long addres · 431 unmodified lines
432	* To be differentiate with macro pte_mkyoung, this macro is used on platforms	432	* To be differentiate with macro pte_mkyoung, this macro is used on platforms
433	* where software maintains page access bit.	433	* where software maintains page access bit.
434	*/	434	*/
		435	#ifndef pte_sw_mkyoung
		436	static inline pte_t pte_sw_mkyoung(pte_t pte)
		437	{
		438	return pte;
		439	}
		440	#define pte_sw_mkyoung pte_sw_mkyoung
		441	#endif
		442
435	#ifndef pte_savedwrite	443	#ifndef pte_savedwrite
436	#define pte_savedwrite pte_write	444	#define pte_savedwrite pte_write
437	#endif	445	#endif

include/linux/platform_data/ti-sysc.h+1−0

@@ -50,6 +50,7 @@ struct sysc_regbits { · 49 unmodified lines
50	s8 emufree_shift;	50	s8 emufree_shift;
51	};	51	};
52		52
		53	#define SYSC_QUIRK_REINIT_ON_RESUME BIT(27)
53	#define SYSC_QUIRK_GPMC_DEBUG BIT(26)	54	#define SYSC_QUIRK_GPMC_DEBUG BIT(26)
54	#define SYSC_MODULE_QUIRK_ENA_RESETDONE BIT(25)	55	#define SYSC_MODULE_QUIRK_ENA_RESETDONE BIT(25)
55	#define SYSC_MODULE_QUIRK_PRUSS BIT(24)	56	#define SYSC_MODULE_QUIRK_PRUSS BIT(24)

include/linux/rtsx_pci.h+2−0

 };
 enum PDEV_STAT  {PDEV_STAT_IDLE, PDEV_STAT_RUN};
+enum ASPM_MODE  {ASPM_MODE_CFG, ASPM_MODE_REG};
 #define ASPM_L1_1_EN			BIT(0)
 #define ASPM_L1_2_EN			BIT(1)
 	u8				card_drive_sel;
 #define ASPM_L1_EN			0x02
 	u8				aspm_en;
+	enum ASPM_MODE			aspm_mode;
 	bool				aspm_enabled;
 #define PCR_MS_PMOS			(1 << 0)

include/linux/sched.h+8−0

  * Only for tasks we track a moving average of the past instantaneous
  * estimated utilization. This allows to absorb sporadic drops in utilization
  * of an otherwise almost periodic task.
+ *
+ * The UTIL_AVG_UNCHANGED flag is used to synchronize util_est with util_avg
+ * updates. When a task is dequeued, its util_est should not be updated if its
+ * util_avg has not been updated in the meantime.
+ * This information is mapped into the MSB bit of util_est.enqueued at dequeue
+ * time. Since max value of util_est.enqueued for a task is 1024 (PELT util_avg
+ * for a task) it is safe to use MSB.
  */
 struct util_est {
 	unsigned int			enqueued;
 	unsigned int			ewma;
 #define UTIL_EST_WEIGHT_SHIFT		2
+#define UTIL_AVG_UNCHANGED		0x80000000
 } __attribute__((__aligned__(sizeof(u64))));
 /*

include/linux/tick.h+7−0

 #include <linux/context_tracking_state.h>
 #include <linux/cpumask.h>
 #include <linux/sched.h>
+#include <linux/rcupdate.h>
 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 extern void __init tick_init(void);
 		__tick_nohz_task_switch();
 }
+static inline void tick_nohz_user_enter_prepare(void)
+{
+	if (tick_nohz_full_cpu(smp_processor_id()))
+		rcu_nocb_flush_deferred_wakeup();
+}
 #endif

include/linux/usb/pd.h+1−1

@@ -460,7 +460,7 @@ static inline unsigned int rdo_max_power(u32 rdo) · 459 unmodified lines
460	#define PD_T_RECEIVER_RESPONSE 15 /* 15ms max */	460	#define PD_T_RECEIVER_RESPONSE 15 /* 15ms max */
461	#define PD_T_SOURCE_ACTIVITY 45	461	#define PD_T_SOURCE_ACTIVITY 45
462	#define PD_T_SINK_ACTIVITY 135	462	#define PD_T_SINK_ACTIVITY 135
463	#define PD_T_SINK_WAIT_CAP 240	463	#define PD_T_SINK_WAIT_CAP 310 /* 310 - 620 ms */
464	#define PD_T_PS_TRANSITION 500	464	#define PD_T_PS_TRANSITION 500
465	#define PD_T_SRC_TRANSITION 35	465	#define PD_T_SRC_TRANSITION 35
466	#define PD_T_DRP_SNK 40	466	#define PD_T_DRP_SNK 40

include/linux/usb/pd_ext_sdb.h+0−4

@@ -24,8 +24,4 @@ enum usb_pd_ext_sdb_fields { · 23 unmodified lines
24	#define USB_PD_EXT_SDB_EVENT_OVP BIT(3)	24	#define USB_PD_EXT_SDB_EVENT_OVP BIT(3)
25	#define USB_PD_EXT_SDB_EVENT_CF_CV_MODE BIT(4)	25	#define USB_PD_EXT_SDB_EVENT_CF_CV_MODE BIT(4)
26		26
27	#define USB_PD_EXT_SDB_PPS_EVENTS (USB_PD_EXT_SDB_EVENT_OCP \| \
28	USB_PD_EXT_SDB_EVENT_OTP \| \
29	USB_PD_EXT_SDB_EVENT_OVP)
30
31	#endif /* __LINUX_USB_PD_EXT_SDB_H */	27	#endif /* __LINUX_USB_PD_EXT_SDB_H */

include/net/caif/caif_dev.h+1−1

@@ -119,7 +119,7 @@ void caif_free_client(struct cflayer *adap_layer); · 118 unmodified lines
119	* The link_support layer is used to add any Link Layer specific	119	* The link_support layer is used to add any Link Layer specific
120	* framing.	120	* framing.
121	*/	121	*/
122	void caif_enroll_dev(struct net_device dev, struct caif_dev_common caifdev,	122	int caif_enroll_dev(struct net_device dev, struct caif_dev_common caifdev,
123	struct cflayer *link_support, int head_room,	123	struct cflayer *link_support, int head_room,
124	struct cflayer layer, int (rcv_func)(	124	struct cflayer layer, int (rcv_func)(
125	struct sk_buff , struct net_device ,	125	struct sk_buff , struct net_device ,

include/net/caif/cfcnfg.h+1−1

@@ -62,7 +62,7 @@ void cfcnfg_remove(struct cfcnfg *cfg); · 61 unmodified lines
62	* @fcs: Specify if checksum is used in CAIF Framing Layer.	62	* @fcs: Specify if checksum is used in CAIF Framing Layer.
63	* @head_room: Head space needed by link specific protocol.	63	* @head_room: Head space needed by link specific protocol.
64	*/	64	*/
65	void	65	int
66	cfcnfg_add_phy_layer(struct cfcnfg *cnfg,	66	cfcnfg_add_phy_layer(struct cfcnfg *cnfg,
67	struct net_device dev, struct cflayer phy_layer,	67	struct net_device dev, struct cflayer phy_layer,
68	enum cfcnfg_phy_preference pref,	68	enum cfcnfg_phy_preference pref,

include/net/caif/cfserl.h+1−0

@@ -9,4 +9,5 @@ · 8 unmodified lines
9	#include <net/caif/caif_layer.h>	9	#include <net/caif/caif_layer.h>
10		10
11	struct cflayer *cfserl_create(int instance, bool use_stx);	11	struct cflayer *cfserl_create(int instance, bool use_stx);
		12	void cfserl_release(struct cflayer *layer);
12	#endif	13	#endif

include/net/netfilter/nf_tables.h+0−6

 struct nft_trans_table {
 	bool				update;
-	u8				state;
-	u32				flags;
 };
 #define nft_trans_table_update(trans)	\
 	(((struct nft_trans_table *)trans->data)->update)
-#define nft_trans_table_state(trans)	\
-	(((struct nft_trans_table *)trans->data)->state)
-#define nft_trans_table_flags(trans)	\
-	(((struct nft_trans_table *)trans->data)->flags)
 struct nft_trans_elem {
 	struct nft_set			*set;

include/net/tls.h+9−1

 	(sizeof(struct tls_offload_context_tx) + TLS_DRIVER_STATE_SIZE_TX)
 enum tls_context_flags {
-	TLS_RX_SYNC_RUNNING = 0,
+	/* tls_device_down was called after the netdev went down, device state
+	 * was released, and kTLS works in software, even though rx_conf is
+	 * still TLS_HW (needed for transition).
+	 */
+	TLS_RX_DEV_DEGRADED = 0,
 	/* Unlike RX where resync is driven entirely by the core in TX only
 	 * the driver knows when things went out of sync, so we need the flag
 	 * to be atomic.
 	/* cache cold stuff */
 	struct proto *sk_proto;
+	struct sock *sk;
 	void (*sk_destruct)(struct sock *sk);
 struct sk_buff *
 tls_validate_xmit_skb(struct sock *sk, struct net_device *dev,
 		      struct sk_buff *skb);
+struct sk_buff *
+tls_validate_xmit_skb_sw(struct sock *sk, struct net_device *dev,
+			 struct sk_buff *skb);
 static inline bool tls_is_sk_tx_device_offloaded(struct sock *sk)
 {

include/uapi/linux/input-event-codes.h+1−0

@@ -611,6 +611,7 @@ · 610 unmodified lines
611	#define KEY_VOICECOMMAND 0x246 /* Listening Voice Command */	611	#define KEY_VOICECOMMAND 0x246 /* Listening Voice Command */
612	#define KEY_ASSISTANT 0x247 /* AL Context-aware desktop assistant */	612	#define KEY_ASSISTANT 0x247 /* AL Context-aware desktop assistant */
613	#define KEY_KBD_LAYOUT_NEXT 0x248 /* AC Next Keyboard Layout Select */	613	#define KEY_KBD_LAYOUT_NEXT 0x248 /* AC Next Keyboard Layout Select */
		614	#define KEY_EMOJI_PICKER 0x249 /* Show/hide emoji picker (HUTRR101) */
614		615
615	#define KEY_BRIGHTNESS_MIN 0x250 /* Set Brightness to Minimum */	616	#define KEY_BRIGHTNESS_MIN 0x250 /* Set Brightness to Minimum */
616	#define KEY_BRIGHTNESS_MAX 0x251 /* Set Brightness to Maximum */	617	#define KEY_BRIGHTNESS_MAX 0x251 /* Set Brightness to Maximum */

include/uapi/linux/io_uring.h+10−9

@@ -280,6 +280,7 @@ struct io_uring_params { · 279 unmodified lines
280	#define IORING_FEAT_SQPOLL_NONFIXED (1U << 7)	280	#define IORING_FEAT_SQPOLL_NONFIXED (1U << 7)
281	#define IORING_FEAT_EXT_ARG (1U << 8)	281	#define IORING_FEAT_EXT_ARG (1U << 8)
282	#define IORING_FEAT_NATIVE_WORKERS (1U << 9)	282	#define IORING_FEAT_NATIVE_WORKERS (1U << 9)
		283	#define IORING_FEAT_RSRC_TAGS (1U << 10)
283		284
284	/*	285	/*
285	* io_uring_register(2) opcodes and arguments	286	* io_uring_register(2) opcodes and arguments
@@ -298,8 +299,12 @@ enum { · 12 unmodified lines
298	IORING_UNREGISTER_PERSONALITY = 10,	299	IORING_UNREGISTER_PERSONALITY = 10,
299	IORING_REGISTER_RESTRICTIONS = 11,	300	IORING_REGISTER_RESTRICTIONS = 11,
300	IORING_REGISTER_ENABLE_RINGS = 12,	301	IORING_REGISTER_ENABLE_RINGS = 12,
301	IORING_REGISTER_RSRC = 13,	302
302	IORING_REGISTER_RSRC_UPDATE = 14,	303	/* extended with tagging */
		304	IORING_REGISTER_FILES2 = 13,
		305	IORING_REGISTER_FILES_UPDATE2 = 14,
		306	IORING_REGISTER_BUFFERS2 = 15,
		307	IORING_REGISTER_BUFFERS_UPDATE = 16,
303		308
304	/* this goes last */	309	/* this goes last */
305	IORING_REGISTER_LAST	310	IORING_REGISTER_LAST
@@ -312,14 +317,10 @@ struct io_uring_files_update { · 6 unmodified lines
312	__aligned_u64 /* __s32 * */ fds;	317	__aligned_u64 /* __s32 * */ fds;
313	};	318	};
314		319
315	enum {
316	IORING_RSRC_FILE = 0,
317	IORING_RSRC_BUFFER = 1,
318	};
319
320	struct io_uring_rsrc_register {	320	struct io_uring_rsrc_register {
321	__u32 type;
322	__u32 nr;	321	__u32 nr;
		322	__u32 resv;
		323	__u64 resv2;
323	__aligned_u64 data;	324	__aligned_u64 data;
324	__aligned_u64 tags;	325	__aligned_u64 tags;
325	};	326	};
@@ -335,8 +336,8 @@ struct io_uring_rsrc_update2 { · 9 unmodified lines
335	__u32 resv;	336	__u32 resv;
336	__aligned_u64 data;	337	__aligned_u64 data;
337	__aligned_u64 tags;	338	__aligned_u64 tags;
338	__u32 type;
339	__u32 nr;	339	__u32 nr;
		340	__u32 resv2;
340	};	341	};
341		342
342	/* Skip updating fd indexes set to this value in the fd table */	343	/* Skip updating fd indexes set to this value in the fd table */

include/uapi/linux/virtio_ids.h+1−1

@@ -54,7 +54,7 @@ · 53 unmodified lines
54	#define VIRTIO_ID_SOUND 25 /* virtio sound */	54	#define VIRTIO_ID_SOUND 25 /* virtio sound */
55	#define VIRTIO_ID_FS 26 /* virtio filesystem */	55	#define VIRTIO_ID_FS 26 /* virtio filesystem */
56	#define VIRTIO_ID_PMEM 27 /* virtio pmem */	56	#define VIRTIO_ID_PMEM 27 /* virtio pmem */
57	#define VIRTIO_ID_BT 28 /* virtio bluetooth */
58	#define VIRTIO_ID_MAC80211_HWSIM 29 /* virtio mac80211-hwsim */	57	#define VIRTIO_ID_MAC80211_HWSIM 29 /* virtio mac80211-hwsim */
		58	#define VIRTIO_ID_BT 40 /* virtio bluetooth */
59		59
60	#endif /* _LINUX_VIRTIO_IDS_H */	60	#endif /* _LINUX_VIRTIO_IDS_H */

init/main.c+1−1

@@ -1537,7 +1537,7 @@ static noinline void __init kernel_init_freeable(void) · 1536 unmodified lines
1537	*/	1537	*/
1538	set_mems_allowed(node_states[N_MEMORY]);	1538	set_mems_allowed(node_states[N_MEMORY]);
1539		1539
1540	cad_pid = task_pid(current);	1540	cad_pid = get_pid(task_pid(current));
1541		1541
1542	smp_prepare_cpus(setup_max_cpus);	1542	smp_prepare_cpus(setup_max_cpus);
1543		1543

kernel/bpf/helpers.c+5−2

 #include <linux/jiffies.h>
 #include <linux/pid_namespace.h>
 #include <linux/proc_ns.h>
+#include <linux/security.h>
 #include "../../lib/kstrtox.h"
 	case BPF_FUNC_probe_read_user:
 		return &bpf_probe_read_user_proto;
 	case BPF_FUNC_probe_read_kernel:
-		return &bpf_probe_read_kernel_proto;
+		return security_locked_down(LOCKDOWN_BPF_READ) < 0 ?
+		       NULL : &bpf_probe_read_kernel_proto;
 	case BPF_FUNC_probe_read_user_str:
 		return &bpf_probe_read_user_str_proto;
 	case BPF_FUNC_probe_read_kernel_str:
-		return &bpf_probe_read_kernel_str_proto;
+		return security_locked_down(LOCKDOWN_BPF_READ) < 0 ?
+		       NULL : &bpf_probe_read_kernel_str_proto;
 	case BPF_FUNC_snprintf_btf:
 		return &bpf_snprintf_btf_proto;
 	case BPF_FUNC_snprintf:

kernel/cgroup/cgroup-v1.c+4−0

 	struct cgroup *cgrp = kn->priv;
 	int ret;
+	/* do not accept '\n' to prevent making /proc/<pid>/cgroup unparsable */
+	if (strchr(new_name_str, '\n'))
+		return -EINVAL;
 	if (kernfs_type(kn) != KERNFS_DIR)
 		return -ENOTDIR;
 	if (kn->parent != new_parent)

kernel/entry/common.c+3−2

 #include <linux/highmem.h>
 #include <linux/livepatch.h>
 #include <linux/audit.h>
+#include <linux/tick.h>
 #include "common.h"
 		local_irq_disable_exit_to_user();
 		/* Check if any of the above work has queued a deferred wakeup */
-		rcu_nocb_flush_deferred_wakeup();
+		tick_nohz_user_enter_prepare();
 		ti_work = READ_ONCE(current_thread_info()->flags);
 	}
 	lockdep_assert_irqs_disabled();
 	/* Flush pending rcuog wakeup before the last need_resched() check */
-	rcu_nocb_flush_deferred_wakeup();
+	tick_nohz_user_enter_prepare();
 	if (unlikely(ti_work & EXIT_TO_USER_MODE_WORK))
 		ti_work = exit_to_user_mode_loop(regs, ti_work);

kernel/events/core.c+2−0

 		cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
 		ctx = &cpuctx->ctx;
 		get_ctx(ctx);
+		raw_spin_lock_irqsave(&ctx->lock, flags);
 		++ctx->pin_count;
+		raw_spin_unlock_irqrestore(&ctx->lock, flags);
 		return ctx;
 	}

kernel/irq_work.c+0−3

@@ -70,9 +70,6 @@ bool irq_work_queue(struct irq_work *work) · 69 unmodified lines
70	if (!irq_work_claim(work))	70	if (!irq_work_claim(work))
71	return false;	71	return false;
72		72
73	/record irq_work call stack in order to print it in KASAN reports/
74	kasan_record_aux_stack(work);
75
76	/* Queue the entry and raise the IPI if needed. */	73	/* Queue the entry and raise the IPI if needed. */
77	preempt_disable();	74	preempt_disable();
78	__irq_work_queue_local(work);	75	__irq_work_queue_local(work);

kernel/sched/debug.c+2−1

 #define __PS(S, F) SEQ_printf(m, "%-45s:%21Ld\n", S, (long long)(F))
 #define __P(F) __PS(#F, F)
 #define   P(F) __PS(#F, p->F)
+#define   PM(F, M) __PS(#F, p->F & (M))
 #define __PSN(S, F) SEQ_printf(m, "%-45s:%14Ld.%06ld\n", S, SPLIT_NS((long long)(F)))
 #define __PN(F) __PSN(#F, F)
 #define   PN(F) __PSN(#F, p->F)
 	P(se.avg.util_avg);
 	P(se.avg.last_update_time);
 	P(se.avg.util_est.ewma);
-	P(se.avg.util_est.enqueued);
+	PM(se.avg.util_est.enqueued, ~UTIL_AVG_UNCHANGED);
 #endif
 #ifdef CONFIG_UCLAMP_TASK
 	__PS("uclamp.min", p->uclamp_req[UCLAMP_MIN].value);

kernel/sched/fair.c+17−11

@@ -3499,10 +3499,9 @@ update_tg_cfs_runnable(struct cfs_rq cfs_rq, struct sched_entity se, struct cf · 3498 unmodified lines
3499	static inline void	3499	static inline void
3500	update_tg_cfs_load(struct cfs_rq cfs_rq, struct sched_entity se, struct cfs_rq *gcfs_rq)	3500	update_tg_cfs_load(struct cfs_rq cfs_rq, struct sched_entity se, struct cfs_rq *gcfs_rq)
3501	{	3501	{
3502	long delta_avg, running_sum, runnable_sum = gcfs_rq->prop_runnable_sum;	3502	long delta, running_sum, runnable_sum = gcfs_rq->prop_runnable_sum;
3503	unsigned long load_avg;	3503	unsigned long load_avg;
3504	u64 load_sum = 0;	3504	u64 load_sum = 0;
3505	s64 delta_sum;
3506	u32 divider;	3505	u32 divider;
3507		3506
3508	if (!runnable_sum)	3507	if (!runnable_sum)
@@ -3549,13 +3548,13 @@ update_tg_cfs_load(struct cfs_rq cfs_rq, struct sched_entity se, struct cfs_rq · 40 unmodified lines
3549	load_sum = (s64)se_weight(se) * runnable_sum;	3548	load_sum = (s64)se_weight(se) * runnable_sum;
3550	load_avg = div_s64(load_sum, divider);	3549	load_avg = div_s64(load_sum, divider);
3551		3550
3552	delta_sum = load_sum - (s64)se_weight(se) * se->avg.load_sum;	3551	delta = load_avg - se->avg.load_avg;
3553	delta_avg = load_avg - se->avg.load_avg;
3554		3552
3555	se->avg.load_sum = runnable_sum;	3553	se->avg.load_sum = runnable_sum;
3556	se->avg.load_avg = load_avg;	3554	se->avg.load_avg = load_avg;
3557	add_positive(&cfs_rq->avg.load_avg, delta_avg);	3555
3558	add_positive(&cfs_rq->avg.load_sum, delta_sum);	3556	add_positive(&cfs_rq->avg.load_avg, delta);
		3557	cfs_rq->avg.load_sum = cfs_rq->avg.load_avg * divider;
3559	}	3558	}
3560		3559
3561	static inline void add_tg_cfs_propagate(struct cfs_rq *cfs_rq, long runnable_sum)	3560	static inline void add_tg_cfs_propagate(struct cfs_rq *cfs_rq, long runnable_sum)
@@ -3766,11 +3765,17 @@ static void attach_entity_load_avg(struct cfs_rq cfs_rq, struct sched_entity s · 204 unmodified lines
3766	*/	3765	*/
3767	static void detach_entity_load_avg(struct cfs_rq cfs_rq, struct sched_entity se)	3766	static void detach_entity_load_avg(struct cfs_rq cfs_rq, struct sched_entity se)
3768	{	3767	{
		3768	/*
		3769	* cfs_rq->avg.period_contrib can be used for both cfs_rq and se.
		3770	* See ___update_load_avg() for details.
		3771	*/
		3772	u32 divider = get_pelt_divider(&cfs_rq->avg);
		3773
3769	dequeue_load_avg(cfs_rq, se);	3774	dequeue_load_avg(cfs_rq, se);
3770	sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg);	3775	sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg);
3771	sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum);	3776	cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * divider;
3772	sub_positive(&cfs_rq->avg.runnable_avg, se->avg.runnable_avg);	3777	sub_positive(&cfs_rq->avg.runnable_avg, se->avg.runnable_avg);
3773	sub_positive(&cfs_rq->avg.runnable_sum, se->avg.runnable_sum);	3778	cfs_rq->avg.runnable_sum = cfs_rq->avg.runnable_avg * divider;
3774		3779
3775	add_tg_cfs_propagate(cfs_rq, -se->avg.load_sum);	3780	add_tg_cfs_propagate(cfs_rq, -se->avg.load_sum);
3776		3781
@@ -3902,7 +3907,7 @@ static inline unsigned long _task_util_est(struct task_struct *p) · 125 unmodified lines
3902	{	3907	{
3903	struct util_est ue = READ_ONCE(p->se.avg.util_est);	3908	struct util_est ue = READ_ONCE(p->se.avg.util_est);
3904		3909
3905	return (max(ue.ewma, ue.enqueued) \| UTIL_AVG_UNCHANGED);	3910	return max(ue.ewma, (ue.enqueued & ~UTIL_AVG_UNCHANGED));
3906	}	3911	}
3907		3912
3908	static inline unsigned long task_util_est(struct task_struct *p)	3913	static inline unsigned long task_util_est(struct task_struct *p)
@@ -4002,7 +4007,7 @@ static inline void util_est_update(struct cfs_rq *cfs_rq, · 93 unmodified lines
4002	* Reset EWMA on utilization increases, the moving average is used only	4007	* Reset EWMA on utilization increases, the moving average is used only
4003	* to smooth utilization decreases.	4008	* to smooth utilization decreases.
4004	*/	4009	*/
4005	ue.enqueued = (task_util(p) \| UTIL_AVG_UNCHANGED);	4010	ue.enqueued = task_util(p);
4006	if (sched_feat(UTIL_EST_FASTUP)) {	4011	if (sched_feat(UTIL_EST_FASTUP)) {
4007	if (ue.ewma < ue.enqueued) {	4012	if (ue.ewma < ue.enqueued) {
4008	ue.ewma = ue.enqueued;	4013	ue.ewma = ue.enqueued;
@@ -4051,6 +4056,7 @@ static inline void util_est_update(struct cfs_rq *cfs_rq, · 42 unmodified lines
4051	ue.ewma += last_ewma_diff;	4056	ue.ewma += last_ewma_diff;
4052	ue.ewma >>= UTIL_EST_WEIGHT_SHIFT;	4057	ue.ewma >>= UTIL_EST_WEIGHT_SHIFT;
4053	done:	4058	done:
		4059	ue.enqueued \|= UTIL_AVG_UNCHANGED;
4054	WRITE_ONCE(p->se.avg.util_est, ue);	4060	WRITE_ONCE(p->se.avg.util_est, ue);
4055		4061
4056	trace_sched_util_est_se_tp(&p->se);	4062	trace_sched_util_est_se_tp(&p->se);
@@ -8030,7 +8036,7 @@ static bool __update_blocked_fair(struct rq rq, bool done) · 3973 unmodified lines
8030	/* Propagate pending load changes to the parent, if any: */	8036	/* Propagate pending load changes to the parent, if any: */
8031	se = cfs_rq->tg->se[cpu];	8037	se = cfs_rq->tg->se[cpu];
8032	if (se && !skip_blocked_update(se))	8038	if (se && !skip_blocked_update(se))
8033	update_load_avg(cfs_rq_of(se), se, 0);	8039	update_load_avg(cfs_rq_of(se), se, UPDATE_TG);
8034		8040
8035	/*	8041	/*
8036	* There can be a lot of idle CPU cgroups. Don't let fully	8042	* There can be a lot of idle CPU cgroups. Don't let fully

kernel/sched/pelt.h+1−10

 	return LOAD_AVG_MAX - 1024 + avg->period_contrib;
 }
-/*
- * When a task is dequeued, its estimated utilization should not be update if
- * its util_avg has not been updated at least once.
- * This flag is used to synchronize util_avg updates with util_est updates.
- * We map this information into the LSB bit of the utilization saved at
- * dequeue time (i.e. util_est.dequeued).
- */
-#define UTIL_AVG_UNCHANGED 0x1
 static inline void cfs_se_util_change(struct sched_avg *avg)
 {
 	unsigned int enqueued;
 	if (!sched_feat(UTIL_EST))
 		return;
-	/* Avoid store if the flag has been already set */
+	/* Avoid store if the flag has been already reset */
 	enqueued = avg->util_est.enqueued;
 	if (!(enqueued & UTIL_AVG_UNCHANGED))
 		return;

kernel/time/tick-sched.c+1−0

@@ -230,6 +230,7 @@ static void tick_sched_handle(struct tick_sched ts, struct pt_regs regs) · 229 unmodified lines
230		230
231	#ifdef CONFIG_NO_HZ_FULL	231	#ifdef CONFIG_NO_HZ_FULL
232	cpumask_var_t tick_nohz_full_mask;	232	cpumask_var_t tick_nohz_full_mask;
		233	EXPORT_SYMBOL_GPL(tick_nohz_full_mask);
233	bool tick_nohz_full_running;	234	bool tick_nohz_full_running;
234	EXPORT_SYMBOL_GPL(tick_nohz_full_running);	235	EXPORT_SYMBOL_GPL(tick_nohz_full_running);
235	static atomic_t tick_dep_mask;	236	static atomic_t tick_dep_mask;

kernel/trace/bpf_trace.c+12−20

 static __always_inline int
 bpf_probe_read_kernel_common(void *dst, u32 size, const void *unsafe_ptr)
 {
-	int ret = security_locked_down(LOCKDOWN_BPF_READ);
+	int ret;
-	if (unlikely(ret < 0))
-		goto fail;
 	ret = copy_from_kernel_nofault(dst, unsafe_ptr, size);
 	if (unlikely(ret < 0))
-		goto fail;
+		memset(dst, 0, size);
-	return ret;
-fail:
-	memset(dst, 0, size);
 	return ret;
 }
 static __always_inline int
 bpf_probe_read_kernel_str_common(void *dst, u32 size, const void *unsafe_ptr)
 {
-	int ret = security_locked_down(LOCKDOWN_BPF_READ);
+	int ret;
-	if (unlikely(ret < 0))
-		goto fail;
 	/*
 	 * The strncpy_from_kernel_nofault() call will likely not fill the
 	 */
 	ret = strncpy_from_kernel_nofault(dst, unsafe_ptr, size);
 	if (unlikely(ret < 0))
-		goto fail;
+		memset(dst, 0, size);
-	return ret;
-fail:
-	memset(dst, 0, size);
 	return ret;
 }
 	case BPF_FUNC_probe_read_user:
 		return &bpf_probe_read_user_proto;
 	case BPF_FUNC_probe_read_kernel:
-		return &bpf_probe_read_kernel_proto;
+		return security_locked_down(LOCKDOWN_BPF_READ) < 0 ?
+		       NULL : &bpf_probe_read_kernel_proto;
 	case BPF_FUNC_probe_read_user_str:
 		return &bpf_probe_read_user_str_proto;
 	case BPF_FUNC_probe_read_kernel_str:
-		return &bpf_probe_read_kernel_str_proto;
+		return security_locked_down(LOCKDOWN_BPF_READ) < 0 ?
+		       NULL : &bpf_probe_read_kernel_str_proto;
 #ifdef CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE
 	case BPF_FUNC_probe_read:
-		return &bpf_probe_read_compat_proto;
+		return security_locked_down(LOCKDOWN_BPF_READ) < 0 ?
+		       NULL : &bpf_probe_read_compat_proto;
 	case BPF_FUNC_probe_read_str:
-		return &bpf_probe_read_compat_str_proto;
+		return security_locked_down(LOCKDOWN_BPF_READ) < 0 ?
+		       NULL : &bpf_probe_read_compat_str_proto;
 #endif
 #ifdef CONFIG_CGROUPS
 	case BPF_FUNC_get_current_cgroup_id:

kernel/trace/ftrace.c+7−1

 static void print_ip_ins(const char *fmt, const unsigned char *p)
 {
+	char ins[MCOUNT_INSN_SIZE];
 	int i;
+	if (copy_from_kernel_nofault(ins, p, MCOUNT_INSN_SIZE)) {
+		printk(KERN_CONT "%s[FAULT] %px\n", fmt, p);
+		return;
+	}
 	printk(KERN_CONT "%s", fmt);
 	for (i = 0; i < MCOUNT_INSN_SIZE; i++)
-		printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
+		printk(KERN_CONT "%s%02x", i ? ":" : "", ins[i]);
 }
 enum ftrace_bug_type ftrace_bug_type;

kernel/trace/trace.c+1−1

@@ -2736,7 +2736,7 @@ trace_event_buffer_lock_reserve(struct trace_buffer **current_rb, · 2735 unmodified lines
2736	(entry = this_cpu_read(trace_buffered_event))) {	2736	(entry = this_cpu_read(trace_buffered_event))) {
2737	/* Try to use the per cpu buffer first */	2737	/* Try to use the per cpu buffer first */
2738	val = this_cpu_inc_return(trace_buffered_event_cnt);	2738	val = this_cpu_inc_return(trace_buffered_event_cnt);
2739	if ((len < (PAGE_SIZE - sizeof(*entry))) && val == 1) {	2739	if ((len < (PAGE_SIZE - sizeof(*entry) - sizeof(entry->array[0]))) && val == 1) {
2740	trace_event_setup(entry, type, trace_ctx);	2740	trace_event_setup(entry, type, trace_ctx);
2741	entry->array[0] = len;	2741	entry->array[0] = len;
2742	return entry;	2742	return entry;

lib/crc64.c+1−1

@@ -37,7 +37,7 @@ MODULE_LICENSE("GPL v2"); · 36 unmodified lines
37	/**	37	/**
38	* crc64_be - Calculate bitwise big-endian ECMA-182 CRC64	38	* crc64_be - Calculate bitwise big-endian ECMA-182 CRC64
39	* @crc: seed value for computation. 0 or (u64)~0 for a new CRC calculation,	39	* @crc: seed value for computation. 0 or (u64)~0 for a new CRC calculation,
40	or the previous crc64 value if computing incrementally.	40	* or the previous crc64 value if computing incrementally.
41	* @p: pointer to buffer over which CRC64 is run	41	* @p: pointer to buffer over which CRC64 is run
42	* @len: length of buffer @p	42	* @len: length of buffer @p
43	*/	43	*/

mm/debug_vm_pgtable.c+2−2

@@ -192,7 +192,7 @@ static void __init pmd_advanced_tests(struct mm_struct *mm, · 191 unmodified lines
192		192
193	pr_debug("Validating PMD advanced\n");	193	pr_debug("Validating PMD advanced\n");
194	/* Align the address wrt HPAGE_PMD_SIZE */	194	/* Align the address wrt HPAGE_PMD_SIZE */
195	vaddr = (vaddr & HPAGE_PMD_MASK) + HPAGE_PMD_SIZE;	195	vaddr &= HPAGE_PMD_MASK;
196		196
197	pgtable_trans_huge_deposit(mm, pmdp, pgtable);	197	pgtable_trans_huge_deposit(mm, pmdp, pgtable);
198		198
@@ -330,7 +330,7 @@ static void __init pud_advanced_tests(struct mm_struct *mm, · 131 unmodified lines
330		330
331	pr_debug("Validating PUD advanced\n");	331	pr_debug("Validating PUD advanced\n");
332	/* Align the address wrt HPAGE_PUD_SIZE */	332	/* Align the address wrt HPAGE_PUD_SIZE */
333	vaddr = (vaddr & HPAGE_PUD_MASK) + HPAGE_PUD_SIZE;	333	vaddr &= HPAGE_PUD_MASK;
334		334
335	set_pud_at(mm, vaddr, pudp, pud);	335	set_pud_at(mm, vaddr, pudp, pud);
336	pudp_set_wrprotect(mm, vaddr, pudp);	336	pudp_set_wrprotect(mm, vaddr, pudp);

mm/hugetlb.c+13−3

 			SetPageHWPoison(page);
 			ClearPageHWPoison(head);
 		}
-		remove_hugetlb_page(h, page, false);
+		remove_hugetlb_page(h, head, false);
 		h->max_huge_pages--;
 		spin_unlock_irq(&hugetlb_lock);
 		update_and_free_page(h, head);
 		if (!page)
 			goto out;
 	} else if (!*pagep) {
-		ret = -ENOMEM;
+		/* If a page already exists, then it's UFFDIO_COPY for
+		 * a non-missing case. Return -EEXIST.
+		 */
+		if (vm_shared &&
+		    hugetlbfs_pagecache_present(h, dst_vma, dst_addr)) {
+			ret = -EEXIST;
+			goto out;
+		}
 		page = alloc_huge_page(dst_vma, dst_addr, 0);
-		if (IS_ERR(page))
+		if (IS_ERR(page)) {
+			ret = -ENOMEM;
 			goto out;
+		}
 		ret = copy_huge_page_from_user(page,
 						(const void __user *) src_addr,

mm/kasan/init.c+2−2

@@ -220,8 +220,8 @@ static int __ref zero_p4d_populate(pgd_t *pgd, unsigned long addr, · 219 unmodified lines
220	/**	220	/**
221	* kasan_populate_early_shadow - populate shadow memory region with	221	* kasan_populate_early_shadow - populate shadow memory region with
222	* kasan_early_shadow_page	222	* kasan_early_shadow_page
223	* @shadow_start - start of the memory range to populate	223	* @shadow_start: start of the memory range to populate
224	* @shadow_end - end of the memory range to populate	224	* @shadow_end: end of the memory range to populate
225	*/	225	*/
226	int __ref kasan_populate_early_shadow(const void *shadow_start,	226	int __ref kasan_populate_early_shadow(const void *shadow_start,
227	const void *shadow_end)	227	const void *shadow_end)

mm/kfence/core.c+3−3

@@ -627,10 +627,10 @@ static void toggle_allocation_gate(struct work_struct *work) · 626 unmodified lines
627	* During low activity with no allocations we might wait a	627	* During low activity with no allocations we might wait a
628	* while; let's avoid the hung task warning.	628	* while; let's avoid the hung task warning.
629	*/	629	*/
630	wait_event_timeout(allocation_wait, atomic_read(&kfence_allocation_gate),	630	wait_event_idle_timeout(allocation_wait, atomic_read(&kfence_allocation_gate),
631	sysctl_hung_task_timeout_secs * HZ / 2);	631	sysctl_hung_task_timeout_secs * HZ / 2);
632	} else {	632	} else {
633	wait_event(allocation_wait, atomic_read(&kfence_allocation_gate));	633	wait_event_idle(allocation_wait, atomic_read(&kfence_allocation_gate));
634	}	634	}
635		635
636	/* Disable static key and reset timer. */	636	/* Disable static key and reset timer. */

mm/memory.c+4−0

 		}
 		flush_cache_page(vma, vmf->address, pte_pfn(vmf->orig_pte));
 		entry = mk_pte(new_page, vma->vm_page_prot);
+		entry = pte_sw_mkyoung(entry);
 		entry = maybe_mkwrite(pte_mkdirty(entry), vma);
 		/*
 	__SetPageUptodate(page);
 	entry = mk_pte(page, vma->vm_page_prot);
+	entry = pte_sw_mkyoung(entry);
 	if (vma->vm_flags & VM_WRITE)
 		entry = pte_mkwrite(pte_mkdirty(entry));
 	if (prefault && arch_wants_old_prefaulted_pte())
 		entry = pte_mkold(entry);
+	else
+		entry = pte_sw_mkyoung(entry);
 	if (write)
 		entry = maybe_mkwrite(pte_mkdirty(entry), vma);

mm/page_alloc.c+2−0

 			del_page_from_free_list(page_head, zone, page_order);
 			break_down_buddy_pages(zone, page_head, page, 0,
 						page_order, migratetype);
+			if (!is_migrate_isolate(migratetype))
+				__mod_zone_freepage_state(zone, -1, migratetype);
 			ret = true;
 			break;
 		}

net/bluetooth/hci_core.c+6−1

@@ -1610,8 +1610,13 @@ setup_failed: · 1609 unmodified lines
1610	} else {	1610	} else {
1611	/* Init failed, cleanup */	1611	/* Init failed, cleanup */
1612	flush_work(&hdev->tx_work);	1612	flush_work(&hdev->tx_work);
1613	flush_work(&hdev->cmd_work);	1613
		1614	/* Since hci_rx_work() is possible to awake new cmd_work
		1615	* it should be flushed first to avoid unexpected call of
		1616	* hci_cmd_work()
		1617	*/
1614	flush_work(&hdev->rx_work);	1618	flush_work(&hdev->rx_work);
		1619	flush_work(&hdev->cmd_work);
1615		1620
1616	skb_queue_purge(&hdev->cmd_q);	1621	skb_queue_purge(&hdev->cmd_q);
1617	skb_queue_purge(&hdev->rx_q);	1622	skb_queue_purge(&hdev->rx_q);

net/bluetooth/hci_sock.c+2−2

@@ -762,7 +762,7 @@ void hci_sock_dev_event(struct hci_dev *hdev, int event) · 761 unmodified lines
762	/* Detach sockets from device */	762	/* Detach sockets from device */
763	read_lock(&hci_sk_list.lock);	763	read_lock(&hci_sk_list.lock);
764	sk_for_each(sk, &hci_sk_list.head) {	764	sk_for_each(sk, &hci_sk_list.head) {
765	bh_lock_sock_nested(sk);	765	lock_sock(sk);
766	if (hci_pi(sk)->hdev == hdev) {	766	if (hci_pi(sk)->hdev == hdev) {
767	hci_pi(sk)->hdev = NULL;	767	hci_pi(sk)->hdev = NULL;
768	sk->sk_err = EPIPE;	768	sk->sk_err = EPIPE;
@@ -771,7 +771,7 @@ void hci_sock_dev_event(struct hci_dev *hdev, int event) · 2 unmodified lines
771		771
772	hci_dev_put(hdev);	772	hci_dev_put(hdev);
773	}	773	}
774	bh_unlock_sock(sk);	774	release_sock(sk);
775	}	775	}
776	read_unlock(&hci_sk_list.lock);	776	read_unlock(&hci_sk_list.lock);
777	}	777	}

net/caif/caif_dev.c+9−4

 	caifd_put(caifd);
 }
-void caif_enroll_dev(struct net_device *dev, struct caif_dev_common *caifdev,
+int caif_enroll_dev(struct net_device *dev, struct caif_dev_common *caifdev,
 		     struct cflayer *link_support, int head_room,
 		     struct cflayer **layer,
 		     int (**rcv_func)(struct sk_buff *, struct net_device *,
 	enum cfcnfg_phy_preference pref;
 	struct cfcnfg *cfg = get_cfcnfg(dev_net(dev));
 	struct caif_device_entry_list *caifdevs;
+	int res;
 	caifdevs = caif_device_list(dev_net(dev));
 	caifd = caif_device_alloc(dev);
 	if (!caifd)
-		return;
+		return -ENOMEM;
 	*layer = &caifd->layer;
 	spin_lock_init(&caifd->flow_lock);
 	strlcpy(caifd->layer.name, dev->name,
 		sizeof(caifd->layer.name));
 	caifd->layer.transmit = transmit;
-	cfcnfg_add_phy_layer(cfg,
+	res = cfcnfg_add_phy_layer(cfg,
 				dev,
 				&caifd->layer,
 				pref,
 	mutex_unlock(&caifdevs->lock);
 	if (rcv_func)
 		*rcv_func = receive;
+	return res;
 }
 EXPORT_SYMBOL(caif_enroll_dev);
 	struct cflayer *layer, *link_support;
 	int head_room = 0;
 	struct caif_device_entry_list *caifdevs;
+	int res;
 	cfg = get_cfcnfg(dev_net(dev));
 	caifdevs = caif_device_list(dev_net(dev));
 				break;
 			}
 		}
-		caif_enroll_dev(dev, caifdev, link_support, head_room,
+		res = caif_enroll_dev(dev, caifdev, link_support, head_room,
 				&layer, NULL);
+		if (res)
+			cfserl_release(link_support);
 		caifdev->flowctrl = dev_flowctrl;
 		break;

net/caif/caif_usb.c+13−1

 	return (struct cflayer *) this;
 }
+static void cfusbl_release(struct cflayer *layer)
+{
+	kfree(layer);
+}
 static struct packet_type caif_usb_type __read_mostly = {
 	.type = cpu_to_be16(ETH_P_802_EX1),
 };
 	struct cflayer *layer, *link_support;
 	struct usbnet *usbnet;
 	struct usb_device *usbdev;
+	int res;
 	/* Check whether we have a NCM device, and find its VID/PID. */
 	if (!(dev->dev.parent && dev->dev.parent->driver &&
 	if (dev->num_tx_queues > 1)
 		pr_warn("USB device uses more than one tx queue\n");
-	caif_enroll_dev(dev, &common, link_support, CFUSB_MAX_HEADLEN,
+	res = caif_enroll_dev(dev, &common, link_support, CFUSB_MAX_HEADLEN,
 			&layer, &caif_usb_type.func);
+	if (res)
+		goto err;
 	if (!pack_added)
 		dev_add_pack(&caif_usb_type);
 	pack_added = true;
 	strlcpy(layer->name, dev->name, sizeof(layer->name));
 	return 0;
+err:
+	cfusbl_release(link_support);
+	return res;
 }
 static struct notifier_block caif_device_notifier = {

net/caif/cfcnfg.c+11−5

 	rcu_read_unlock();
 }
-void
+int
 cfcnfg_add_phy_layer(struct cfcnfg *cnfg,
 		     struct net_device *dev, struct cflayer *phy_layer,
 		     enum cfcnfg_phy_preference pref,
 {
 	struct cflayer *frml;
 	struct cfcnfg_phyinfo *phyinfo = NULL;
-	int i;
+	int i, res = 0;
 	u8 phyid;
 	mutex_lock(&cnfg->lock);
 			goto got_phyid;
 	}
 	pr_warn("Too many CAIF Link Layers (max 6)\n");
+	res = -EEXIST;
 	goto out;
 got_phyid:
 	phyinfo = kzalloc(sizeof(struct cfcnfg_phyinfo), GFP_ATOMIC);
-	if (!phyinfo)
+	if (!phyinfo) {
+		res = -ENOMEM;
 		goto out_err;
+	}
 	phy_layer->id = phyid;
 	phyinfo->pref = pref;
 	frml = cffrml_create(phyid, fcs);
-	if (!frml)
+	if (!frml) {
+		res = -ENOMEM;
 		goto out_err;
+	}
 	phyinfo->frm_layer = frml;
 	layer_set_up(frml, cnfg->mux);
 	list_add_rcu(&phyinfo->node, &cnfg->phys);
 out:
 	mutex_unlock(&cnfg->lock);
-	return;
+	return res;
 out_err:
 	kfree(phyinfo);
 	mutex_unlock(&cnfg->lock);
+	return res;
 }
 EXPORT_SYMBOL(cfcnfg_add_phy_layer);

net/caif/cfserl.c+5−0

 static void cfserl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
 			   int phyid);
+void cfserl_release(struct cflayer *layer)
+{
+	kfree(layer);
+}
 struct cflayer *cfserl_create(int instance, bool use_stx)
 {
 	struct cfserl *this = kzalloc(sizeof(struct cfserl), GFP_ATOMIC);

net/compat.c+1−1

@@ -177,7 +177,7 @@ int cmsghdr_from_user_compat_to_kern(struct msghdr kmsg, struct sock sk, · 176 unmodified lines
177	if (kcmlen > stackbuf_size)	177	if (kcmlen > stackbuf_size)
178	kcmsg_base = kcmsg = sock_kmalloc(sk, kcmlen, GFP_KERNEL);	178	kcmsg_base = kcmsg = sock_kmalloc(sk, kcmlen, GFP_KERNEL);
179	if (kcmsg == NULL)	179	if (kcmsg == NULL)
180	return -ENOBUFS;	180	return -ENOMEM;
181		181
182	/* Now copy them over neatly. */	182	/* Now copy them over neatly. */
183	memset(kcmsg, 0, kcmlen);	183	memset(kcmsg, 0, kcmlen);

net/core/devlink.c+2−2

 	case DEVLINK_PORT_FLAVOUR_PHYSICAL:
 	case DEVLINK_PORT_FLAVOUR_CPU:
 	case DEVLINK_PORT_FLAVOUR_DSA:
-	case DEVLINK_PORT_FLAVOUR_VIRTUAL:
 		if (nla_put_u32(msg, DEVLINK_ATTR_PORT_NUMBER,
 				attrs->phys.port_number))
 			return -EMSGSIZE;
 	switch (attrs->flavour) {
 	case DEVLINK_PORT_FLAVOUR_PHYSICAL:
-	case DEVLINK_PORT_FLAVOUR_VIRTUAL:
 		if (!attrs->split)
 			n = snprintf(name, len, "p%u", attrs->phys.port_number);
 		else
 		n = snprintf(name, len, "pf%usf%u", attrs->pci_sf.pf,
 			     attrs->pci_sf.sf);
 		break;
+	case DEVLINK_PORT_FLAVOUR_VIRTUAL:
+		return -EOPNOTSUPP;
 	}
 	if (n >= len)

net/core/fib_rules.c+1−1

@@ -1168,7 +1168,7 @@ static void notify_rule_change(int event, struct fib_rule *rule, · 1167 unmodified lines
1168	{	1168	{
1169	struct net *net;	1169	struct net *net;
1170	struct sk_buff *skb;	1170	struct sk_buff *skb;
1171	int err = -ENOBUFS;	1171	int err = -ENOMEM;
1172		1172
1173	net = ops->fro_net;	1173	net = ops->fro_net;
1174	skb = nlmsg_new(fib_rule_nlmsg_size(ops, rule), GFP_KERNEL);	1174	skb = nlmsg_new(fib_rule_nlmsg_size(ops, rule), GFP_KERNEL);

net/core/rtnetlink.c+3−1

 	if (err < 0)
 		goto errout;
-	if (!skb->len)
+	if (!skb->len) {
+		err = -EINVAL;
 		goto errout;
+	}
 	rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
 	return 0;

net/core/sock.c+12−4

 }
 EXPORT_SYMBOL(sock_set_rcvbuf);
+static void __sock_set_mark(struct sock *sk, u32 val)
+{
+	if (val != sk->sk_mark) {
+		sk->sk_mark = val;
+		sk_dst_reset(sk);
+	}
+}
 void sock_set_mark(struct sock *sk, u32 val)
 {
 	lock_sock(sk);
-	sk->sk_mark = val;
+	__sock_set_mark(sk, val);
 	release_sock(sk);
 }
 EXPORT_SYMBOL(sock_set_mark);
 	case SO_MARK:
 		if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) {
 			ret = -EPERM;
-		} else if (val != sk->sk_mark) {
+			break;
-			sk->sk_mark = val;
-			sk_dst_reset(sk);
 		}
+		__sock_set_mark(sk, val);
 		break;
 	case SO_RXQ_OVFL:

net/dsa/tag_8021q.c+1−1

@@ -64,7 +64,7 @@ · 63 unmodified lines
64	#define DSA_8021Q_SUBVLAN_HI_SHIFT 9	64	#define DSA_8021Q_SUBVLAN_HI_SHIFT 9
65	#define DSA_8021Q_SUBVLAN_HI_MASK GENMASK(9, 9)	65	#define DSA_8021Q_SUBVLAN_HI_MASK GENMASK(9, 9)
66	#define DSA_8021Q_SUBVLAN_LO_SHIFT 4	66	#define DSA_8021Q_SUBVLAN_LO_SHIFT 4
67	#define DSA_8021Q_SUBVLAN_LO_MASK GENMASK(4, 3)	67	#define DSA_8021Q_SUBVLAN_LO_MASK GENMASK(5, 4)
68	#define DSA_8021Q_SUBVLAN_HI(x) (((x) & GENMASK(2, 2)) >> 2)	68	#define DSA_8021Q_SUBVLAN_HI(x) (((x) & GENMASK(2, 2)) >> 2)
69	#define DSA_8021Q_SUBVLAN_LO(x) ((x) & GENMASK(1, 0))	69	#define DSA_8021Q_SUBVLAN_LO(x) ((x) & GENMASK(1, 0))
70	#define DSA_8021Q_SUBVLAN(x) \	70	#define DSA_8021Q_SUBVLAN(x) \

net/ieee802154/nl-mac.c+6−4

 	    nla_put_u8(msg, IEEE802154_ATTR_LLSEC_SECLEVEL, params.out_level) ||
 	    nla_put_u32(msg, IEEE802154_ATTR_LLSEC_FRAME_COUNTER,
 			be32_to_cpu(params.frame_counter)) ||
-	    ieee802154_llsec_fill_key_id(msg, &params.out_key))
+	    ieee802154_llsec_fill_key_id(msg, &params.out_key)) {
+		rc = -ENOBUFS;
 		goto out_free;
+	}
 	dev_put(dev);
 {
 	struct ieee802154_llsec_device *dpos;
 	struct ieee802154_llsec_device_key *kpos;
-	int rc = 0, idx = 0, idx2;
+	int idx = 0, idx2;
 	list_for_each_entry(dpos, &data->table->devices, list) {
 		if (idx++ < data->s_idx)
 						      data->nlmsg_seq,
 						      dpos->hwaddr, kpos,
 						      data->dev)) {
-				return rc = -EMSGSIZE;
+				return -EMSGSIZE;
 			}
 			data->s_idx2++;
 		data->s_idx++;
 	}
-	return rc;
+	return 0;
 }
 int ieee802154_llsec_dump_devkeys(struct sk_buff *skb,

net/ieee802154/nl-phy.c+3−1

 	}
 	if (nla_put_string(msg, IEEE802154_ATTR_PHY_NAME, wpan_phy_name(phy)) ||
-	    nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name))
+	    nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, dev->name)) {
+		rc = -EMSGSIZE;
 		goto nla_put_failure;
+	}
 	dev_put(dev);
 	wpan_phy_put(phy);

net/ieee802154/nl802154.c+5−4

 	if (!nla || nla_parse_nested_deprecated(attrs, NL802154_DEV_ADDR_ATTR_MAX, nla, nl802154_dev_addr_policy, NULL))
 		return -EINVAL;
-	if (!attrs[NL802154_DEV_ADDR_ATTR_PAN_ID] ||
+	if (!attrs[NL802154_DEV_ADDR_ATTR_PAN_ID] || !attrs[NL802154_DEV_ADDR_ATTR_MODE])
-	    !attrs[NL802154_DEV_ADDR_ATTR_MODE] ||
-	    !(attrs[NL802154_DEV_ADDR_ATTR_SHORT] ||
-	      attrs[NL802154_DEV_ADDR_ATTR_EXTENDED]))
 		return -EINVAL;
 	addr->pan_id = nla_get_le16(attrs[NL802154_DEV_ADDR_ATTR_PAN_ID]);
 	addr->mode = nla_get_u32(attrs[NL802154_DEV_ADDR_ATTR_MODE]);
 	switch (addr->mode) {
 	case NL802154_DEV_ADDR_SHORT:
+		if (!attrs[NL802154_DEV_ADDR_ATTR_SHORT])
+			return -EINVAL;
 		addr->short_addr = nla_get_le16(attrs[NL802154_DEV_ADDR_ATTR_SHORT]);
 		break;
 	case NL802154_DEV_ADDR_EXTENDED:
+		if (!attrs[NL802154_DEV_ADDR_ATTR_EXTENDED])
+			return -EINVAL;
 		addr->extended_addr = nla_get_le64(attrs[NL802154_DEV_ADDR_ATTR_EXTENDED]);
 		break;
 	default:

net/ipv4/ipconfig.c+8−5

 /*
- *  Copy BOOTP-supplied string if not already set.
+ *  Copy BOOTP-supplied string
  */
 static int __init ic_bootp_string(char *dest, char *src, int len, int max)
 {
 		}
 		break;
 	case 12:	/* Host name */
-		ic_bootp_string(utsname()->nodename, ext+1, *ext,
+		if (!ic_host_name_set) {
-				__NEW_UTS_LEN);
+			ic_bootp_string(utsname()->nodename, ext+1, *ext,
-		ic_host_name_set = 1;
+					__NEW_UTS_LEN);
+			ic_host_name_set = 1;
+		}
 		break;
 	case 15:	/* Domain name (DNS) */
-		ic_bootp_string(ic_domain, ext+1, *ext, sizeof(ic_domain));
+		if (!ic_domain[0])
+			ic_bootp_string(ic_domain, ext+1, *ext, sizeof(ic_domain));
 		break;
 	case 17:	/* Root path */
 		if (!root_server_path[0])

net/ipv6/route.c+6−2

 	if (nh) {
 		if (rt->fib6_src.plen) {
 			NL_SET_ERR_MSG(extack, "Nexthops can not be used with source routing");
-			goto out;
+			goto out_free;
 		}
 		if (!nexthop_get(nh)) {
 			NL_SET_ERR_MSG(extack, "Nexthop has been deleted");
-			goto out;
+			goto out_free;
 		}
 		rt->nh = nh;
 		fib6_nh = nexthop_fib6_nh(rt->nh);
 out:
 	fib6_info_release(rt);
 	return ERR_PTR(err);
+out_free:
+	ip_fib_metrics_put(rt->fib6_metrics);
+	kfree(rt);
+	return ERR_PTR(err);
 }
 int ip6_route_add(struct fib6_config *cfg, gfp_t gfp_flags,

net/ipv6/sit.c+3−0

@@ -271,6 +271,9 @@ static struct ip_tunnel ipip6_tunnel_locate(struct net net, · 270 unmodified lines
271	if (ipip6_tunnel_create(dev) < 0)	271	if (ipip6_tunnel_create(dev) < 0)
272	goto failed_free;	272	goto failed_free;
273		273
		274	if (!parms->name[0])
		275	strcpy(parms->name, dev->name);
		276
274	return nt;	277	return nt;
275		278
276	failed_free:	279	failed_free:

net/kcm/kcmsock.c+5−0

 		goto partial_message;
 	}
+	if (skb_has_frag_list(head)) {
+		kfree_skb_list(skb_shinfo(head)->frag_list);
+		skb_shinfo(head)->frag_list = NULL;
+	}
 	if (head != kcm->seq_skb)
 		kfree_skb(head);

net/mptcp/protocol.c+15−1

 {
 	struct mptcp_sock *msk = mptcp_sk(sk);
+#ifdef CONFIG_LOCKDEP
+	WARN_ON_ONCE(!lockdep_is_held(&sk->sk_lock.slock));
+#endif
 	if (!msk->wmem_reserved)
 		return;
 static void __mptcp_clean_una_wakeup(struct sock *sk)
 {
+#ifdef CONFIG_LOCKDEP
+	WARN_ON_ONCE(!lockdep_is_held(&sk->sk_lock.slock));
+#endif
 	__mptcp_clean_una(sk);
 	mptcp_write_space(sk);
 }
+static void mptcp_clean_una_wakeup(struct sock *sk)
+{
+	mptcp_data_lock(sk);
+	__mptcp_clean_una_wakeup(sk);
+	mptcp_data_unlock(sk);
+}
 static void mptcp_enter_memory_pressure(struct sock *sk)
 {
 	struct mptcp_subflow_context *subflow;
 	struct sock *ssk;
 	int ret;
-	__mptcp_clean_una_wakeup(sk);
+	mptcp_clean_una_wakeup(sk);
 	dfrag = mptcp_rtx_head(sk);
 	if (!dfrag) {
 		if (mptcp_data_fin_enabled(msk)) {

net/mptcp/subflow.c+40−39

@@ -630,21 +630,20 @@ static struct sock subflow_syn_recv_sock(const struct sock sk, · 629 unmodified lines
630		630
631	/* if the sk is MP_CAPABLE, we try to fetch the client key */	631	/* if the sk is MP_CAPABLE, we try to fetch the client key */
632	if (subflow_req->mp_capable) {	632	if (subflow_req->mp_capable) {
633	if (TCP_SKB_CB(skb)->seq != subflow_req->ssn_offset + 1) {	633	/* we can receive and accept an in-window, out-of-order pkt,
634	/* here we can receive and accept an in-window,	634	* which may not carry the MP_CAPABLE opt even on mptcp enabled
635	* out-of-order pkt, which will not carry the MP_CAPABLE	635	* paths: always try to extract the peer key, and fallback
636	* opt even on mptcp enabled paths	636	* for packets missing it.
637	*/	637	* Even OoO DSS packets coming legitly after dropped or
638	goto create_msk;	638	* reordered MPC will cause fallback, but we don't have other
639	}	639	* options.
640		640	*/
641	mptcp_get_options(skb, &mp_opt);	641	mptcp_get_options(skb, &mp_opt);
642	if (!mp_opt.mp_capable) {	642	if (!mp_opt.mp_capable) {
643	fallback = true;	643	fallback = true;
644	goto create_child;	644	goto create_child;
645	}	645	}
646		646
647	create_msk:
648	new_msk = mptcp_sk_clone(listener->conn, &mp_opt, req);	647	new_msk = mptcp_sk_clone(listener->conn, &mp_opt, req);
649	if (!new_msk)	648	if (!new_msk)
650	fallback = true;	649	fallback = true;
@@ -1012,21 +1011,11 @@ static bool subflow_check_data_avail(struct sock *ssk) · 361 unmodified lines
1012		1011
1013	status = get_mapping_status(ssk, msk);	1012	status = get_mapping_status(ssk, msk);
1014	trace_subflow_check_data_avail(status, skb_peek(&ssk->sk_receive_queue));	1013	trace_subflow_check_data_avail(status, skb_peek(&ssk->sk_receive_queue));
1015	if (status == MAPPING_INVALID) {	1014	if (unlikely(status == MAPPING_INVALID))
1016	ssk->sk_err = EBADMSG;	1015	goto fallback;
1017	goto fatal;	1016
1018	}	1017	if (unlikely(status == MAPPING_DUMMY))
1019	if (status == MAPPING_DUMMY) {	1018	goto fallback;
1020	__mptcp_do_fallback(msk);
1021	skb = skb_peek(&ssk->sk_receive_queue);
1022	subflow->map_valid = 1;
1023	subflow->map_seq = READ_ONCE(msk->ack_seq);
1024	subflow->map_data_len = skb->len;
1025	subflow->map_subflow_seq = tcp_sk(ssk)->copied_seq -
1026	subflow->ssn_offset;
1027	subflow->data_avail = MPTCP_SUBFLOW_DATA_AVAIL;
1028	return true;
1029	}
1030		1019
1031	if (status != MAPPING_OK)	1020	if (status != MAPPING_OK)
1032	goto no_data;	1021	goto no_data;
@@ -1039,10 +1028,8 @@ static bool subflow_check_data_avail(struct sock *ssk) · 6 unmodified lines
1039	* MP_CAPABLE-based mapping	1028	* MP_CAPABLE-based mapping
1040	*/	1029	*/
1041	if (unlikely(!READ_ONCE(msk->can_ack))) {	1030	if (unlikely(!READ_ONCE(msk->can_ack))) {
1042	if (!subflow->mpc_map) {	1031	if (!subflow->mpc_map)
1043	ssk->sk_err = EBADMSG;	1032	goto fallback;
1044	goto fatal;
1045	}
1046	WRITE_ONCE(msk->remote_key, subflow->remote_key);	1033	WRITE_ONCE(msk->remote_key, subflow->remote_key);
1047	WRITE_ONCE(msk->ack_seq, subflow->map_seq);	1034	WRITE_ONCE(msk->ack_seq, subflow->map_seq);
1048	WRITE_ONCE(msk->can_ack, true);	1035	WRITE_ONCE(msk->can_ack, true);
@@ -1070,17 +1057,31 @@ static bool subflow_check_data_avail(struct sock *ssk) · 21 unmodified lines
1070	no_data:	1057	no_data:
1071	subflow_sched_work_if_closed(msk, ssk);	1058	subflow_sched_work_if_closed(msk, ssk);
1072	return false;	1059	return false;
1073	fatal:	1060
1074	/* fatal protocol error, close the socket */	1061	fallback:
1075	/* This barrier is coupled with smp_rmb() in tcp_poll() */	1062	/* RFC 8684 section 3.7. */
1076	smp_wmb();	1063	if (subflow->mp_join \|\| subflow->fully_established) {
1077	ssk->sk_error_report(ssk);	1064	/* fatal protocol error, close the socket.
1078	tcp_set_state(ssk, TCP_CLOSE);	1065	* subflow_error_report() will introduce the appropriate barriers
1079	subflow->reset_transient = 0;	1066	*/
1080	subflow->reset_reason = MPTCP_RST_EMPTCP;	1067	ssk->sk_err = EBADMSG;
1081	tcp_send_active_reset(ssk, GFP_ATOMIC);	1068	ssk->sk_error_report(ssk);
1082	subflow->data_avail = 0;	1069	tcp_set_state(ssk, TCP_CLOSE);
1083	return false;	1070	subflow->reset_transient = 0;
		1071	subflow->reset_reason = MPTCP_RST_EMPTCP;
		1072	tcp_send_active_reset(ssk, GFP_ATOMIC);
		1073	subflow->data_avail = 0;
		1074	return false;
		1075	}
		1076
		1077	__mptcp_do_fallback(msk);
		1078	skb = skb_peek(&ssk->sk_receive_queue);
		1079	subflow->map_valid = 1;
		1080	subflow->map_seq = READ_ONCE(msk->ack_seq);
		1081	subflow->map_data_len = skb->len;
		1082	subflow->map_subflow_seq = tcp_sk(ssk)->copied_seq - subflow->ssn_offset;
		1083	subflow->data_avail = MPTCP_SUBFLOW_DATA_AVAIL;
		1084	return true;
1084	}	1085	}
1085		1086
1086	bool mptcp_subflow_data_available(struct sock *sk)	1087	bool mptcp_subflow_data_available(struct sock *sk)

net/netfilter/ipvs/ip_vs_ctl.c+1−1

@@ -1367,7 +1367,7 @@ ip_vs_add_service(struct netns_ipvs ipvs, struct ip_vs_service_user_kern u, · 1366 unmodified lines
1367	ip_vs_addr_copy(svc->af, &svc->addr, &u->addr);	1367	ip_vs_addr_copy(svc->af, &svc->addr, &u->addr);
1368	svc->port = u->port;	1368	svc->port = u->port;
1369	svc->fwmark = u->fwmark;	1369	svc->fwmark = u->fwmark;
1370	svc->flags = u->flags;	1370	svc->flags = u->flags & ~IP_VS_SVC_F_HASHED;
1371	svc->timeout = u->timeout * HZ;	1371	svc->timeout = u->timeout * HZ;
1372	svc->netmask = u->netmask;	1372	svc->netmask = u->netmask;
1373	svc->ipvs = ipvs;	1373	svc->ipvs = ipvs;

net/netfilter/nf_conntrack_proto.c+1−1

@@ -664,7 +664,7 @@ int nf_conntrack_proto_init(void) · 663 unmodified lines
664		664
665	#if IS_ENABLED(CONFIG_IPV6)	665	#if IS_ENABLED(CONFIG_IPV6)
666	cleanup_sockopt:	666	cleanup_sockopt:
667	nf_unregister_sockopt(&so_getorigdst6);	667	nf_unregister_sockopt(&so_getorigdst);
668	#endif	668	#endif
669	return ret;	669	return ret;
670	}	670	}

net/netfilter/nf_tables_api.c+57−27

@@ -736,7 +736,8 @@ static int nf_tables_fill_table_info(struct sk_buff skb, struct net net, · 735 unmodified lines
736	goto nla_put_failure;	736	goto nla_put_failure;
737		737
738	if (nla_put_string(skb, NFTA_TABLE_NAME, table->name) \|\|	738	if (nla_put_string(skb, NFTA_TABLE_NAME, table->name) \|\|
739	nla_put_be32(skb, NFTA_TABLE_FLAGS, htonl(table->flags)) \|\|	739	nla_put_be32(skb, NFTA_TABLE_FLAGS,
		740	htonl(table->flags & NFT_TABLE_F_MASK)) \|\|
740	nla_put_be32(skb, NFTA_TABLE_USE, htonl(table->use)) \|\|	741	nla_put_be32(skb, NFTA_TABLE_USE, htonl(table->use)) \|\|
741	nla_put_be64(skb, NFTA_TABLE_HANDLE, cpu_to_be64(table->handle),	742	nla_put_be64(skb, NFTA_TABLE_HANDLE, cpu_to_be64(table->handle),
742	NFTA_TABLE_PAD))	743	NFTA_TABLE_PAD))
@@ -947,20 +948,22 @@ err_register_hooks: · 204 unmodified lines
947		948
948	static void nf_tables_table_disable(struct net net, struct nft_table table)	949	static void nf_tables_table_disable(struct net net, struct nft_table table)
949	{	950	{
		951	table->flags &= ~NFT_TABLE_F_DORMANT;
950	nft_table_disable(net, table, 0);	952	nft_table_disable(net, table, 0);
		953	table->flags \|= NFT_TABLE_F_DORMANT;
951	}	954	}
952		955
953	enum {	956	#define __NFT_TABLE_F_INTERNAL (NFT_TABLE_F_MASK + 1)
954	NFT_TABLE_STATE_UNCHANGED = 0,	957	#define __NFT_TABLE_F_WAS_DORMANT (__NFT_TABLE_F_INTERNAL << 0)
955	NFT_TABLE_STATE_DORMANT,	958	#define __NFT_TABLE_F_WAS_AWAKEN (__NFT_TABLE_F_INTERNAL << 1)
956	NFT_TABLE_STATE_WAKEUP	959	#define __NFT_TABLE_F_UPDATE (__NFT_TABLE_F_WAS_DORMANT \| \
957	};	960	__NFT_TABLE_F_WAS_AWAKEN)
958		961
959	static int nf_tables_updtable(struct nft_ctx *ctx)	962	static int nf_tables_updtable(struct nft_ctx *ctx)
960	{	963	{
961	struct nft_trans *trans;	964	struct nft_trans *trans;
962	u32 flags;	965	u32 flags;
963	int ret = 0;	966	int ret;
964		967
965	if (!ctx->nla[NFTA_TABLE_FLAGS])	968	if (!ctx->nla[NFTA_TABLE_FLAGS])
966	return 0;	969	return 0;
@@ -985,21 +988,27 @@ static int nf_tables_updtable(struct nft_ctx *ctx) · 18 unmodified lines
985		988
986	if ((flags & NFT_TABLE_F_DORMANT) &&	989	if ((flags & NFT_TABLE_F_DORMANT) &&
987	!(ctx->table->flags & NFT_TABLE_F_DORMANT)) {	990	!(ctx->table->flags & NFT_TABLE_F_DORMANT)) {
988	nft_trans_table_state(trans) = NFT_TABLE_STATE_DORMANT;	991	ctx->table->flags \|= NFT_TABLE_F_DORMANT;
		992	if (!(ctx->table->flags & __NFT_TABLE_F_UPDATE))
		993	ctx->table->flags \|= __NFT_TABLE_F_WAS_AWAKEN;
989	} else if (!(flags & NFT_TABLE_F_DORMANT) &&	994	} else if (!(flags & NFT_TABLE_F_DORMANT) &&
990	ctx->table->flags & NFT_TABLE_F_DORMANT) {	995	ctx->table->flags & NFT_TABLE_F_DORMANT) {
991	ret = nf_tables_table_enable(ctx->net, ctx->table);	996	ctx->table->flags &= ~NFT_TABLE_F_DORMANT;
992	if (ret >= 0)	997	if (!(ctx->table->flags & __NFT_TABLE_F_UPDATE)) {
993	nft_trans_table_state(trans) = NFT_TABLE_STATE_WAKEUP;	998	ret = nf_tables_table_enable(ctx->net, ctx->table);
		999	if (ret < 0)
		1000	goto err_register_hooks;
		1001
		1002	ctx->table->flags \|= __NFT_TABLE_F_WAS_DORMANT;
		1003	}
994	}	1004	}
995	if (ret < 0)
996	goto err;
997		1005
998	nft_trans_table_flags(trans) = flags;
999	nft_trans_table_update(trans) = true;	1006	nft_trans_table_update(trans) = true;
1000	nft_trans_commit_list_add_tail(ctx->net, trans);	1007	nft_trans_commit_list_add_tail(ctx->net, trans);
		1008
1001	return 0;	1009	return 0;
1002	err:	1010
		1011	err_register_hooks:
1003	nft_trans_destroy(trans);	1012	nft_trans_destroy(trans);
1004	return ret;	1013	return ret;
1005	}	1014	}
@@ -1905,7 +1914,7 @@ static int nft_chain_parse_netdev(struct net *net, · 899 unmodified lines
1905	static int nft_chain_parse_hook(struct net *net,	1914	static int nft_chain_parse_hook(struct net *net,
1906	const struct nlattr * const nla[],	1915	const struct nlattr * const nla[],
1907	struct nft_chain_hook *hook, u8 family,	1916	struct nft_chain_hook *hook, u8 family,
1908	bool autoload)	1917	struct netlink_ext_ack *extack, bool autoload)
1909	{	1918	{
1910	struct nftables_pernet *nft_net = nft_pernet(net);	1919	struct nftables_pernet *nft_net = nft_pernet(net);
1911	struct nlattr *ha[NFTA_HOOK_MAX + 1];	1920	struct nlattr *ha[NFTA_HOOK_MAX + 1];
@@ -1935,8 +1944,10 @@ static int nft_chain_parse_hook(struct net *net, · 23 unmodified lines
1935	if (nla[NFTA_CHAIN_TYPE]) {	1944	if (nla[NFTA_CHAIN_TYPE]) {
1936	type = nf_tables_chain_type_lookup(net, nla[NFTA_CHAIN_TYPE],	1945	type = nf_tables_chain_type_lookup(net, nla[NFTA_CHAIN_TYPE],
1937	family, autoload);	1946	family, autoload);
1938	if (IS_ERR(type))	1947	if (IS_ERR(type)) {
		1948	NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_TYPE]);
1939	return PTR_ERR(type);	1949	return PTR_ERR(type);
		1950	}
1940	}	1951	}
1941	if (hook->num >= NFT_MAX_HOOKS \|\| !(type->hook_mask & (1 << hook->num)))	1952	if (hook->num >= NFT_MAX_HOOKS \|\| !(type->hook_mask & (1 << hook->num)))
1942	return -EOPNOTSUPP;	1953	return -EOPNOTSUPP;
@@ -1945,8 +1956,11 @@ static int nft_chain_parse_hook(struct net *net, · 2 unmodified lines
1945	hook->priority <= NF_IP_PRI_CONNTRACK)	1956	hook->priority <= NF_IP_PRI_CONNTRACK)
1946	return -EOPNOTSUPP;	1957	return -EOPNOTSUPP;
1947		1958
1948	if (!try_module_get(type->owner))	1959	if (!try_module_get(type->owner)) {
		1960	if (nla[NFTA_CHAIN_TYPE])
		1961	NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_TYPE]);
1949	return -ENOENT;	1962	return -ENOENT;
		1963	}
1950		1964
1951	hook->type = type;	1965	hook->type = type;
1952		1966
@@ -2057,7 +2071,8 @@ static int nft_chain_add(struct nft_table table, struct nft_chain chain) · 104 unmodified lines
2057	static u64 chain_id;	2071	static u64 chain_id;
2058		2072
2059	static int nf_tables_addchain(struct nft_ctx *ctx, u8 family, u8 genmask,	2073	static int nf_tables_addchain(struct nft_ctx *ctx, u8 family, u8 genmask,
2060	u8 policy, u32 flags)	2074	u8 policy, u32 flags,
		2075	struct netlink_ext_ack *extack)
2061	{	2076	{
2062	const struct nlattr * const *nla = ctx->nla;	2077	const struct nlattr * const *nla = ctx->nla;
2063	struct nft_table *table = ctx->table;	2078	struct nft_table *table = ctx->table;
@@ -2079,7 +2094,8 @@ static int nf_tables_addchain(struct nft_ctx *ctx, u8 family, u8 genmask, · 15 unmodified lines
2079	if (flags & NFT_CHAIN_BINDING)	2094	if (flags & NFT_CHAIN_BINDING)
2080	return -EOPNOTSUPP;	2095	return -EOPNOTSUPP;
2081		2096
2082	err = nft_chain_parse_hook(net, nla, &hook, family, true);	2097	err = nft_chain_parse_hook(net, nla, &hook, family, extack,
		2098	true);
2083	if (err < 0)	2099	if (err < 0)
2084	return err;	2100	return err;
2085		2101
@@ -2234,7 +2250,7 @@ static int nf_tables_updchain(struct nft_ctx *ctx, u8 genmask, u8 policy, · 148 unmodified lines
2234	return -EEXIST;	2250	return -EEXIST;
2235	}	2251	}
2236	err = nft_chain_parse_hook(ctx->net, nla, &hook, ctx->family,	2252	err = nft_chain_parse_hook(ctx->net, nla, &hook, ctx->family,
2237	false);	2253	extack, false);
2238	if (err < 0)	2254	if (err < 0)
2239	return err;	2255	return err;
2240		2256
@@ -2447,7 +2463,7 @@ static int nf_tables_newchain(struct sk_buff skb, const struct nfnl_info info, · 206 unmodified lines
2447	extack);	2463	extack);
2448	}	2464	}
2449		2465
2450	return nf_tables_addchain(&ctx, family, genmask, policy, flags);	2466	return nf_tables_addchain(&ctx, family, genmask, policy, flags, extack);
2451	}	2467	}
2452		2468
2453	static int nf_tables_delchain(struct sk_buff skb, const struct nfnl_info info,	2469	static int nf_tables_delchain(struct sk_buff skb, const struct nfnl_info info,
@@ -3328,8 +3344,10 @@ static int nf_tables_newrule(struct sk_buff skb, const struct nfnl_info info, · 874 unmodified lines
3328	if (n == NFT_RULE_MAXEXPRS)	3344	if (n == NFT_RULE_MAXEXPRS)
3329	goto err1;	3345	goto err1;
3330	err = nf_tables_expr_parse(&ctx, tmp, &expr_info[n]);	3346	err = nf_tables_expr_parse(&ctx, tmp, &expr_info[n]);
3331	if (err < 0)	3347	if (err < 0) {
		3348	NL_SET_BAD_ATTR(extack, tmp);
3332	goto err1;	3349	goto err1;
		3350	}
3333	size += expr_info[n].ops->size;	3351	size += expr_info[n].ops->size;
3334	n++;	3352	n++;
3335	}	3353	}
@@ -8547,10 +8565,14 @@ static int nf_tables_commit(struct net net, struct sk_buff skb) · 5211 unmodified lines
8547	switch (trans->msg_type) {	8565	switch (trans->msg_type) {
8548	case NFT_MSG_NEWTABLE:	8566	case NFT_MSG_NEWTABLE:
8549	if (nft_trans_table_update(trans)) {	8567	if (nft_trans_table_update(trans)) {
8550	if (nft_trans_table_state(trans) == NFT_TABLE_STATE_DORMANT)	8568	if (!(trans->ctx.table->flags & __NFT_TABLE_F_UPDATE)) {
		8569	nft_trans_destroy(trans);
		8570	break;
		8571	}
		8572	if (trans->ctx.table->flags & NFT_TABLE_F_DORMANT)
8551	nf_tables_table_disable(net, trans->ctx.table);	8573	nf_tables_table_disable(net, trans->ctx.table);
8552		8574
8553	trans->ctx.table->flags = nft_trans_table_flags(trans);	8575	trans->ctx.table->flags &= ~__NFT_TABLE_F_UPDATE;
8554	} else {	8576	} else {
8555	nft_clear(net, trans->ctx.table);	8577	nft_clear(net, trans->ctx.table);
8556	}	8578	}
@@ -8768,9 +8790,17 @@ static int __nf_tables_abort(struct net *net, enum nfnl_abort_action action) · 211 unmodified lines
8768	switch (trans->msg_type) {	8790	switch (trans->msg_type) {
8769	case NFT_MSG_NEWTABLE:	8791	case NFT_MSG_NEWTABLE:
8770	if (nft_trans_table_update(trans)) {	8792	if (nft_trans_table_update(trans)) {
8771	if (nft_trans_table_state(trans) == NFT_TABLE_STATE_WAKEUP)	8793	if (!(trans->ctx.table->flags & __NFT_TABLE_F_UPDATE)) {
		8794	nft_trans_destroy(trans);
		8795	break;
		8796	}
		8797	if (trans->ctx.table->flags & __NFT_TABLE_F_WAS_DORMANT) {
8772	nf_tables_table_disable(net, trans->ctx.table);	8798	nf_tables_table_disable(net, trans->ctx.table);
8773		8799	trans->ctx.table->flags \|= NFT_TABLE_F_DORMANT;
		8800	} else if (trans->ctx.table->flags & __NFT_TABLE_F_WAS_AWAKEN) {
		8801	trans->ctx.table->flags &= ~NFT_TABLE_F_DORMANT;
		8802	}
		8803	trans->ctx.table->flags &= ~__NFT_TABLE_F_UPDATE;
8774	nft_trans_destroy(trans);	8804	nft_trans_destroy(trans);
8775	} else {	8805	} else {
8776	list_del_rcu(&trans->ctx.table->list);	8806	list_del_rcu(&trans->ctx.table->list);

net/netfilter/nfnetlink_cthelper.c+6−2

 nfnl_cthelper_update(const struct nlattr * const tb[],
 		     struct nf_conntrack_helper *helper)
 {
+	u32 size;
 	int ret;
-	if (tb[NFCTH_PRIV_DATA_LEN])
+	if (tb[NFCTH_PRIV_DATA_LEN]) {
-		return -EBUSY;
+		size = ntohl(nla_get_be32(tb[NFCTH_PRIV_DATA_LEN]));
+		if (size != helper->data_len)
+			return -EBUSY;
+	}
 	if (tb[NFCTH_POLICY]) {
 		ret = nfnl_cthelper_update_policy(helper, tb[NFCTH_POLICY]);

net/netfilter/nft_ct.c+1−1

@@ -1217,7 +1217,7 @@ static void nft_ct_expect_obj_eval(struct nft_object *obj, · 1216 unmodified lines
1217	struct nf_conn *ct;	1217	struct nf_conn *ct;
1218		1218
1219	ct = nf_ct_get(pkt->skb, &ctinfo);	1219	ct = nf_ct_get(pkt->skb, &ctinfo);
1220	if (!ct \|\| ctinfo == IP_CT_UNTRACKED) {	1220	if (!ct \|\| nf_ct_is_confirmed(ct) \|\| nf_ct_is_template(ct)) {
1221	regs->verdict.code = NFT_BREAK;	1221	regs->verdict.code = NFT_BREAK;
1222	return;	1222	return;
1223	}	1223	}

net/nfc/llcp_sock.c+2−0

 	if (!llcp_sock->service_name) {
 		nfc_llcp_local_put(llcp_sock->local);
 		llcp_sock->local = NULL;
+		llcp_sock->dev = NULL;
 		ret = -ENOMEM;
 		goto put_dev;
 	}
 		llcp_sock->local = NULL;
 		kfree(llcp_sock->service_name);
 		llcp_sock->service_name = NULL;
+		llcp_sock->dev = NULL;
 		ret = -EADDRINUSE;
 		goto put_dev;
 	}

net/sched/act_ct.c+4−6

 	 */
 	cached = tcf_ct_skb_nfct_cached(net, skb, p->zone, force);
 	if (!cached) {
-		if (!commit && tcf_ct_flow_table_lookup(p, skb, family)) {
+		if (tcf_ct_flow_table_lookup(p, skb, family)) {
 			skip_add = true;
 			goto do_nat;
 		}
 		 * even if the connection is already confirmed.
 		 */
 		nf_conntrack_confirm(skb);
-	} else if (!skip_add) {
-		tcf_ct_flow_table_process_conn(p->ct_ft, ct, ctinfo);
 	}
+	if (!skip_add)
+		tcf_ct_flow_table_process_conn(p->ct_ft, ct, ctinfo);
 out_push:
 	skb_push_rcsum(skb, nh_ofs);
 				   sizeof(p->zone));
 	}
-	if (p->zone == NF_CT_DEFAULT_ZONE_ID)
-		return 0;
 	nf_ct_zone_init(&zone, p->zone, NF_CT_DEFAULT_ZONE_DIR, 0);
 	tmpl = nf_ct_tmpl_alloc(net, &zone, GFP_KERNEL);
 	if (!tmpl) {

net/sched/sch_htb.c+4−4

 	struct Qdisc *old_q;
 	/* One ref for cl->leaf.q, the other for dev_queue->qdisc. */
-	qdisc_refcount_inc(new_q);
+	if (new_q)
+		qdisc_refcount_inc(new_q);
 	old_q = htb_graft_helper(dev_queue, new_q);
 	WARN_ON(!(old_q->flags & TCQ_F_BUILTIN));
 }
 					  cl->parent->common.classid,
 					  NULL);
 		if (q->offload) {
-			if (new_q) {
+			if (new_q)
 				htb_set_lockdep_class_child(new_q);
-				htb_parent_to_leaf_offload(sch, dev_queue, new_q);
+			htb_parent_to_leaf_offload(sch, dev_queue, new_q);
-			}
 		}
 	}

net/tls/tls_device.c+49−11

@@ -50,6 +50,7 @@ static void tls_device_gc_task(struct work_struct *work); · 49 unmodified lines
50	static DECLARE_WORK(tls_device_gc_work, tls_device_gc_task);	50	static DECLARE_WORK(tls_device_gc_work, tls_device_gc_task);
51	static LIST_HEAD(tls_device_gc_list);	51	static LIST_HEAD(tls_device_gc_list);
52	static LIST_HEAD(tls_device_list);	52	static LIST_HEAD(tls_device_list);
		53	static LIST_HEAD(tls_device_down_list);
53	static DEFINE_SPINLOCK(tls_device_lock);	54	static DEFINE_SPINLOCK(tls_device_lock);
54		55
55	static void tls_device_free_ctx(struct tls_context *ctx)	56	static void tls_device_free_ctx(struct tls_context *ctx)
@@ -680,15 +681,13 @@ static void tls_device_resync_rx(struct tls_context *tls_ctx, · 624 unmodified lines
680	struct tls_offload_context_rx *rx_ctx = tls_offload_ctx_rx(tls_ctx);	681	struct tls_offload_context_rx *rx_ctx = tls_offload_ctx_rx(tls_ctx);
681	struct net_device *netdev;	682	struct net_device *netdev;
682		683
683	if (WARN_ON(test_and_set_bit(TLS_RX_SYNC_RUNNING, &tls_ctx->flags)))
684	return;
685
686	trace_tls_device_rx_resync_send(sk, seq, rcd_sn, rx_ctx->resync_type);	684	trace_tls_device_rx_resync_send(sk, seq, rcd_sn, rx_ctx->resync_type);
		685	rcu_read_lock();
687	netdev = READ_ONCE(tls_ctx->netdev);	686	netdev = READ_ONCE(tls_ctx->netdev);
688	if (netdev)	687	if (netdev)
689	netdev->tlsdev_ops->tls_dev_resync(netdev, sk, seq, rcd_sn,	688	netdev->tlsdev_ops->tls_dev_resync(netdev, sk, seq, rcd_sn,
690	TLS_OFFLOAD_CTX_DIR_RX);	689	TLS_OFFLOAD_CTX_DIR_RX);
691	clear_bit_unlock(TLS_RX_SYNC_RUNNING, &tls_ctx->flags);	690	rcu_read_unlock();
692	TLS_INC_STATS(sock_net(sk), LINUX_MIB_TLSRXDEVICERESYNC);	691	TLS_INC_STATS(sock_net(sk), LINUX_MIB_TLSRXDEVICERESYNC);
693	}	692	}
694		693
@@ -761,6 +760,8 @@ void tls_device_rx_resync_new_rec(struct sock *sk, u32 rcd_len, u32 seq) · 66 unmodified lines
761		760
762	if (tls_ctx->rx_conf != TLS_HW)	761	if (tls_ctx->rx_conf != TLS_HW)
763	return;	762	return;
		763	if (unlikely(test_bit(TLS_RX_DEV_DEGRADED, &tls_ctx->flags)))
		764	return;
764		765
765	prot = &tls_ctx->prot_info;	766	prot = &tls_ctx->prot_info;
766	rx_ctx = tls_offload_ctx_rx(tls_ctx);	767	rx_ctx = tls_offload_ctx_rx(tls_ctx);
@@ -963,6 +964,17 @@ int tls_device_decrypted(struct sock sk, struct tls_context tls_ctx, · 196 unmodified lines
963		964
964	ctx->sw.decrypted \|= is_decrypted;	965	ctx->sw.decrypted \|= is_decrypted;
965		966
		967	if (unlikely(test_bit(TLS_RX_DEV_DEGRADED, &tls_ctx->flags))) {
		968	if (likely(is_encrypted \|\| is_decrypted))
		969	return 0;
		970
		971	/* After tls_device_down disables the offload, the next SKB will
		972	* likely have initial fragments decrypted, and final ones not
		973	* decrypted. We need to reencrypt that single SKB.
		974	*/
		975	return tls_device_reencrypt(sk, skb);
		976	}
		977
966	/* Return immediately if the record is either entirely plaintext or	978	/* Return immediately if the record is either entirely plaintext or
967	* entirely ciphertext. Otherwise handle reencrypt partially decrypted	979	* entirely ciphertext. Otherwise handle reencrypt partially decrypted
968	* record.	980	* record.
@@ -1292,6 +1304,26 @@ static int tls_device_down(struct net_device *netdev) · 323 unmodified lines
1292	spin_unlock_irqrestore(&tls_device_lock, flags);	1304	spin_unlock_irqrestore(&tls_device_lock, flags);
1293		1305
1294	list_for_each_entry_safe(ctx, tmp, &list, list) {	1306	list_for_each_entry_safe(ctx, tmp, &list, list) {
		1307	/* Stop offloaded TX and switch to the fallback.
		1308	* tls_is_sk_tx_device_offloaded will return false.
		1309	*/
		1310	WRITE_ONCE(ctx->sk->sk_validate_xmit_skb, tls_validate_xmit_skb_sw);
		1311
		1312	/* Stop the RX and TX resync.
		1313	* tls_dev_resync must not be called after tls_dev_del.
		1314	*/
		1315	WRITE_ONCE(ctx->netdev, NULL);
		1316
		1317	/* Start skipping the RX resync logic completely. */
		1318	set_bit(TLS_RX_DEV_DEGRADED, &ctx->flags);
		1319
		1320	/* Sync with inflight packets. After this point:
		1321	* TX: no non-encrypted packets will be passed to the driver.
		1322	* RX: resync requests from the driver will be ignored.
		1323	*/
		1324	synchronize_net();
		1325
		1326	/* Release the offload context on the driver side. */
1295	if (ctx->tx_conf == TLS_HW)	1327	if (ctx->tx_conf == TLS_HW)
1296	netdev->tlsdev_ops->tls_dev_del(netdev, ctx,	1328	netdev->tlsdev_ops->tls_dev_del(netdev, ctx,
1297	TLS_OFFLOAD_CTX_DIR_TX);	1329	TLS_OFFLOAD_CTX_DIR_TX);
@@ -1299,15 +1331,21 @@ static int tls_device_down(struct net_device *netdev) · 1 unmodified line
1299	!test_bit(TLS_RX_DEV_CLOSED, &ctx->flags))	1331	!test_bit(TLS_RX_DEV_CLOSED, &ctx->flags))
1300	netdev->tlsdev_ops->tls_dev_del(netdev, ctx,	1332	netdev->tlsdev_ops->tls_dev_del(netdev, ctx,
1301	TLS_OFFLOAD_CTX_DIR_RX);	1333	TLS_OFFLOAD_CTX_DIR_RX);
1302	WRITE_ONCE(ctx->netdev, NULL);	1334
1303	smp_mb__before_atomic(); /* pairs with test_and_set_bit() */
1304	while (test_bit(TLS_RX_SYNC_RUNNING, &ctx->flags))
1305	usleep_range(10, 200);
1306	dev_put(netdev);	1335	dev_put(netdev);
1307	list_del_init(&ctx->list);
1308		1336
1309	if (refcount_dec_and_test(&ctx->refcount))	1337	/* Move the context to a separate list for two reasons:
1310	tls_device_free_ctx(ctx);	1338	* 1. When the context is deallocated, list_del is called.
		1339	* 2. It's no longer an offloaded context, so we don't want to
		1340	* run offload-specific code on this context.
		1341	*/
		1342	spin_lock_irqsave(&tls_device_lock, flags);
		1343	list_move_tail(&ctx->list, &tls_device_down_list);
		1344	spin_unlock_irqrestore(&tls_device_lock, flags);
		1345
		1346	/* Device contexts for RX and TX will be freed in on sk_destruct
		1347	* by tls_device_free_ctx. rx_conf and tx_conf stay in TLS_HW.
		1348	*/
1311	}	1349	}
1312		1350
1313	up_write(&device_offload_lock);	1351	up_write(&device_offload_lock);

net/tls/tls_device_fallback.c+7−0

@@ -431,6 +431,13 @@ struct sk_buff tls_validate_xmit_skb(struct sock sk, · 430 unmodified lines
431	}	431	}
432	EXPORT_SYMBOL_GPL(tls_validate_xmit_skb);	432	EXPORT_SYMBOL_GPL(tls_validate_xmit_skb);
433		433
		434	struct sk_buff tls_validate_xmit_skb_sw(struct sock sk,
		435	struct net_device *dev,
		436	struct sk_buff *skb)
		437	{
		438	return tls_sw_fallback(sk, skb);
		439	}
		440
434	struct sk_buff tls_encrypt_skb(struct sk_buff skb)	441	struct sk_buff tls_encrypt_skb(struct sk_buff skb)
435	{	442	{
436	return tls_sw_fallback(skb->sk, skb);	443	return tls_sw_fallback(skb->sk, skb);

net/tls/tls_main.c+1−0

@@ -636,6 +636,7 @@ struct tls_context tls_ctx_create(struct sock sk) · 635 unmodified lines
636	mutex_init(&ctx->tx_lock);	636	mutex_init(&ctx->tx_lock);
637	rcu_assign_pointer(icsk->icsk_ulp_data, ctx);	637	rcu_assign_pointer(icsk->icsk_ulp_data, ctx);
638	ctx->sk_proto = READ_ONCE(sk->sk_prot);	638	ctx->sk_proto = READ_ONCE(sk->sk_prot);
		639	ctx->sk = sk;
639	return ctx;	640	return ctx;
640	}	641	}
641		642

net/x25/af_x25.c+1−1

@@ -536,7 +536,7 @@ static int x25_create(struct net net, struct socket sock, int protocol, · 535 unmodified lines
536	if (protocol)	536	if (protocol)
537	goto out;	537	goto out;
538		538
539	rc = -ENOBUFS;	539	rc = -ENOMEM;
540	if ((sk = x25_alloc_socket(net, kern)) == NULL)	540	if ((sk = x25_alloc_socket(net, kern)) == NULL)
541	goto out;	541	goto out;
542		542

samples/vfio-mdev/mdpy-fb.c+9−4

 	if (format != DRM_FORMAT_XRGB8888) {
 		pci_err(pdev, "format mismatch (0x%x != 0x%x)\n",
 			format, DRM_FORMAT_XRGB8888);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto err_release_regions;
 	}
 	if (width < 100	 || width > 10000) {
 		pci_err(pdev, "width (%d) out of range\n", width);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto err_release_regions;
 	}
 	if (height < 100 || height > 10000) {
 		pci_err(pdev, "height (%d) out of range\n", height);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto err_release_regions;
 	}
 	pci_info(pdev, "mdpy found: %dx%d framebuffer\n",
 		 width, height);
 	info = framebuffer_alloc(sizeof(struct mdpy_fb_par), &pdev->dev);
-	if (!info)
+	if (!info) {
+		ret = -ENOMEM;
 		goto err_release_regions;
+	}
 	pci_set_drvdata(pdev, info);
 	par = info->par;

scripts/Makefile.modfinal+1−1

@@ -59,7 +59,7 @@ quiet_cmd_ld_ko_o = LD [M] $@ · 58 unmodified lines
59	quiet_cmd_btf_ko = BTF [M] $@	59	quiet_cmd_btf_ko = BTF [M] $@
60	cmd_btf_ko = \	60	cmd_btf_ko = \
61	if [ -f vmlinux ]; then \	61	if [ -f vmlinux ]; then \
62	LLVM_OBJCOPY=$(OBJCOPY) $(PAHOLE) -J --btf_base vmlinux $@; \	62	LLVM_OBJCOPY="$(OBJCOPY)" $(PAHOLE) -J --btf_base vmlinux $@; \
63	else \	63	else \
64	printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \	64	printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \
65	fi;	65	fi;

scripts/link-vmlinux.sh+1−1

@@ -240,7 +240,7 @@ gen_btf() · 239 unmodified lines
240	fi	240	fi
241		241
242	info "BTF" ${2}	242	info "BTF" ${2}
243	LLVM_OBJCOPY=${OBJCOPY} ${PAHOLE} -J ${extra_paholeopt} ${1}	243	LLVM_OBJCOPY="${OBJCOPY}" ${PAHOLE} -J ${extra_paholeopt} ${1}
244		244
245	# Create ${2} which contains just .BTF section but no symbols. Add	245	# Create ${2} which contains just .BTF section but no symbols. Add
246	# SHF_ALLOC because .BTF will be part of the vmlinux image. --strip-all	246	# SHF_ALLOC because .BTF will be part of the vmlinux image. --strip-all

sound/core/control_led.c+26−7

 #define MAX_LED (((SNDRV_CTL_ELEM_ACCESS_MIC_LED - SNDRV_CTL_ELEM_ACCESS_SPK_LED) \
 			>> SNDRV_CTL_ELEM_ACCESS_LED_SHIFT) + 1)
+#define to_led_card_dev(_dev) \
+	container_of(_dev, struct snd_ctl_led_card, dev)
 enum snd_ctl_led_mode {
 	 MODE_FOLLOW_MUTE = 0,
 	 MODE_FOLLOW_ROUTE,
 	snd_ctl_led_refresh();
 }
+static void snd_ctl_led_card_release(struct device *dev)
+{
+	struct snd_ctl_led_card *led_card = to_led_card_dev(dev);
+	kfree(led_card);
+}
+static void snd_ctl_led_release(struct device *dev)
+{
+}
+static void snd_ctl_led_dev_release(struct device *dev)
+{
+}
 /*
  * sysfs
  */
 		led_card->number = card->number;
 		led_card->led = led;
 		device_initialize(&led_card->dev);
+		led_card->dev.release = snd_ctl_led_card_release;
 		if (dev_set_name(&led_card->dev, "card%d", card->number) < 0)
 			goto cerr;
 		led_card->dev.parent = &led->dev;
 		put_device(&led_card->dev);
 cerr2:
 		printk(KERN_ERR "snd_ctl_led: unable to add card%d", card->number);
-		kfree(led_card);
 	}
 }
 		snprintf(link_name, sizeof(link_name), "led-%s", led->name);
 		sysfs_remove_link(&card->ctl_dev.kobj, link_name);
 		sysfs_remove_link(&led_card->dev.kobj, "card");
-		device_del(&led_card->dev);
+		device_unregister(&led_card->dev);
-		kfree(led_card);
 		led->cards[card->number] = NULL;
 	}
 }
 	device_initialize(&snd_ctl_led_dev);
 	snd_ctl_led_dev.class = sound_class;
+	snd_ctl_led_dev.release = snd_ctl_led_dev_release;
 	dev_set_name(&snd_ctl_led_dev, "ctl-led");
 	if (device_add(&snd_ctl_led_dev)) {
 		put_device(&snd_ctl_led_dev);
 		INIT_LIST_HEAD(&led->controls);
 		device_initialize(&led->dev);
 		led->dev.parent = &snd_ctl_led_dev;
+		led->dev.release = snd_ctl_led_release;
 		led->dev.groups = snd_ctl_led_dev_attr_groups;
 		dev_set_name(&led->dev, led->name);
 		if (device_add(&led->dev)) {
 			put_device(&led->dev);
 			for (; group > 0; group--) {
 				led = &snd_ctl_leds[group - 1];
-				device_del(&led->dev);
+				device_unregister(&led->dev);
 			}
-			device_del(&snd_ctl_led_dev);
+			device_unregister(&snd_ctl_led_dev);
 			return -ENOMEM;
 		}
 	}
 	}
 	for (group = 0; group < MAX_LED; group++) {
 		led = &snd_ctl_leds[group];
-		device_del(&led->dev);
+		device_unregister(&led->dev);
 	}
-	device_del(&snd_ctl_led_dev);
+	device_unregister(&snd_ctl_led_dev);
 	snd_ctl_led_clean(NULL);
 }

sound/core/seq/seq_timer.c+9−1

 		return err;
 	}
 	spin_lock_irq(&tmr->lock);
-	tmr->timeri = t;
+	if (tmr->timeri)
+		err = -EBUSY;
+	else
+		tmr->timeri = t;
 	spin_unlock_irq(&tmr->lock);
+	if (err < 0) {
+		snd_timer_close(t);
+		snd_timer_instance_free(t);
+		return err;
+	}
 	return 0;
 }

sound/core/timer.c+2−1

 		return;
 	if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
 		return;
+	event += 10; /* convert to SNDRV_TIMER_EVENT_MXXX */
 	list_for_each_entry(ts, &ti->slave_active_head, active_list)
 		if (ts->ccallback)
-			ts->ccallback(ts, event + 100, &tstamp, resolution);
+			ts->ccallback(ts, event, &tstamp, resolution);
 }
 /* start/continue a master timer */

sound/firewire/amdtp-stream.c+1−1

@@ -804,7 +804,7 @@ static void generate_pkt_descs(struct amdtp_stream s, struct pkt_desc descs, · 803 unmodified lines
804	static inline void cancel_stream(struct amdtp_stream *s)	804	static inline void cancel_stream(struct amdtp_stream *s)
805	{	805	{
806	s->packet_index = -1;	806	s->packet_index = -1;
807	if (current_work() == &s->period_work)	807	if (in_interrupt())
808	amdtp_stream_pcm_abort(s);	808	amdtp_stream_pcm_abort(s);
809	WRITE_ONCE(s->pcm_buffer_pointer, SNDRV_PCM_POS_XRUN);	809	WRITE_ONCE(s->pcm_buffer_pointer, SNDRV_PCM_POS_XRUN);
810	}	810	}

sound/hda/intel-dsp-config.c+4−0

 		.flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
 		.device = 0x51c8,
 	},
+	{
+		.flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
+		.device = 0x51cc,
+	},
 #endif
 };

sound/pci/hda/hda_codec.c+5−0

 #ifdef CONFIG_PM_SLEEP
 static int hda_codec_pm_prepare(struct device *dev)
 {
+	dev->power.power_state = PMSG_SUSPEND;
 	return pm_runtime_suspended(dev);
 }
 {
 	struct hda_codec *codec = dev_to_hda_codec(dev);
+	/* If no other pm-functions are called between prepare() and complete() */
+	if (dev->power.power_state.event == PM_EVENT_SUSPEND)
+		dev->power.power_state = PMSG_RESUME;
 	if (pm_runtime_suspended(dev) && (codec->jackpoll_interval ||
 	    hda_codec_need_resume(codec) || codec->forced_resume))
 		pm_request_resume(dev);

sound/pci/hda/hda_generic.c+1−0

@@ -3520,6 +3520,7 @@ static int cap_sw_put(struct snd_kcontrol *kcontrol, · 3519 unmodified lines
3520	static const struct snd_kcontrol_new cap_sw_temp = {	3520	static const struct snd_kcontrol_new cap_sw_temp = {
3521	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	3521	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3522	.name = "Capture Switch",	3522	.name = "Capture Switch",
		3523	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3523	.info = cap_sw_info,	3524	.info = cap_sw_info,
3524	.get = cap_sw_get,	3525	.get = cap_sw_get,
3525	.put = cap_sw_put,	3526	.put = cap_sw_put,

sound/pci/hda/hda_intel.c+3−0

 	/* Alderlake-P */
 	{ PCI_DEVICE(0x8086, 0x51c8),
 	  .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
+	/* Alderlake-M */
+	{ PCI_DEVICE(0x8086, 0x51cc),
+	  .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
 	/* Elkhart Lake */
 	{ PCI_DEVICE(0x8086, 0x4b55),
 	  .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},

sound/pci/hda/patch_cirrus.c+3−4

 		break;
 	case HDA_FIXUP_ACT_PROBE:
-		/* Set initial volume on Bullseye to -26 dB */
+		/* Set initial DMIC volume to -26 dB */
-		if (codec->fixup_id == CS8409_BULLSEYE)
+		snd_hda_codec_amp_init_stereo(codec, CS8409_CS42L42_DMIC_ADC_PIN_NID,
-			snd_hda_codec_amp_init_stereo(codec, CS8409_CS42L42_DMIC_ADC_PIN_NID,
+				HDA_INPUT, 0, 0xff, 0x19);
-					HDA_INPUT, 0, 0xff, 0x19);
 		snd_hda_gen_add_kctl(&spec->gen,
 			NULL, &cs8409_cs42l42_hp_volume_mixer);
 		snd_hda_gen_add_kctl(&spec->gen,

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

 	ALC285_FIXUP_HP_SPECTRE_X360,
 	ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
 	ALC623_FIXUP_LENOVO_THINKSTATION_P340,
+	ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
 };
 static const struct hda_fixup alc269_fixups[] = {
 		.chained = true,
 		.chain_id = ALC283_FIXUP_HEADSET_MIC,
 	},
+	[ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
+		.type = HDA_FIXUP_PINS,
+		.v.pins = (const struct hda_pintbl[]) {
+			{ 0x21, 0x03211030 }, /* Change the Headphone location to Left */
+			{ }
+		},
+		.chained = true,
+		.chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
+	},
 };
 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
 	SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
 	SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
+	SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
 	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
 	SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
 	SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
 	SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
+	SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
 	SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
 	SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
 	SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
 	SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
 	SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
 	SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
+	SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
+	SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
 	SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
 	SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
 	SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
+	SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
 	SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
 	SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
+	SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
 	SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
 	SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
 	SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
 	{.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
 	{.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
 	{.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
+	{.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
 	{}
 };
 #define ALC225_STANDARD_PINS \

sound/soc/codecs/rt5659.c+21−5

 	return 0;
 }
-static const struct snd_soc_dapm_widget rt5659_dapm_widgets[] = {
+static const struct snd_soc_dapm_widget rt5659_particular_dapm_widgets[] = {
 	SND_SOC_DAPM_SUPPLY("LDO2", RT5659_PWR_ANLG_3, RT5659_PWR_LDO2_BIT, 0,
 		NULL, 0),
-	SND_SOC_DAPM_SUPPLY("PLL", RT5659_PWR_ANLG_3, RT5659_PWR_PLL_BIT, 0,
+	SND_SOC_DAPM_SUPPLY("MICBIAS1", RT5659_PWR_ANLG_2, RT5659_PWR_MB1_BIT,
-		NULL, 0),
+		0, NULL, 0),
 	SND_SOC_DAPM_SUPPLY("Mic Det Power", RT5659_PWR_VOL,
 		RT5659_PWR_MIC_DET_BIT, 0, NULL, 0),
+};
+static const struct snd_soc_dapm_widget rt5659_dapm_widgets[] = {
+	SND_SOC_DAPM_SUPPLY("PLL", RT5659_PWR_ANLG_3, RT5659_PWR_PLL_BIT, 0,
+		NULL, 0),
 	SND_SOC_DAPM_SUPPLY("Mono Vref", RT5659_PWR_ANLG_1,
 		RT5659_PWR_VREF3_BIT, 0, NULL, 0),
 		RT5659_ADC_MONO_R_ASRC_SFT, 0, NULL, 0),
 	/* Input Side */
-	SND_SOC_DAPM_SUPPLY("MICBIAS1", RT5659_PWR_ANLG_2, RT5659_PWR_MB1_BIT,
-		0, NULL, 0),
 	SND_SOC_DAPM_SUPPLY("MICBIAS2", RT5659_PWR_ANLG_2, RT5659_PWR_MB2_BIT,
 		0, NULL, 0),
 	SND_SOC_DAPM_SUPPLY("MICBIAS3", RT5659_PWR_ANLG_2, RT5659_PWR_MB3_BIT,
 static int rt5659_probe(struct snd_soc_component *component)
 {
+	struct snd_soc_dapm_context *dapm =
+		snd_soc_component_get_dapm(component);
 	struct rt5659_priv *rt5659 = snd_soc_component_get_drvdata(component);
 	rt5659->component = component;
+	switch (rt5659->pdata.jd_src) {
+	case RT5659_JD_HDA_HEADER:
+		break;
+	default:
+		snd_soc_dapm_new_controls(dapm,
+			rt5659_particular_dapm_widgets,
+			ARRAY_SIZE(rt5659_particular_dapm_widgets));
+		break;
+	}
 	return 0;
 }

sound/soc/codecs/rt5682-sdw.c+2−1

@@ -462,7 +462,8 @@ static int rt5682_io_init(struct device dev, struct sdw_slave slave) · 461 unmodified lines
462		462
463	regmap_update_bits(rt5682->regmap, RT5682_CBJ_CTRL_2,	463	regmap_update_bits(rt5682->regmap, RT5682_CBJ_CTRL_2,
464	RT5682_EXT_JD_SRC, RT5682_EXT_JD_SRC_MANUAL);	464	RT5682_EXT_JD_SRC, RT5682_EXT_JD_SRC_MANUAL);
465	regmap_write(rt5682->regmap, RT5682_CBJ_CTRL_1, 0xd042);	465	regmap_write(rt5682->regmap, RT5682_CBJ_CTRL_1, 0xd142);
		466	regmap_update_bits(rt5682->regmap, RT5682_CBJ_CTRL_5, 0x0700, 0x0600);
466	regmap_update_bits(rt5682->regmap, RT5682_CBJ_CTRL_3,	467	regmap_update_bits(rt5682->regmap, RT5682_CBJ_CTRL_3,
467	RT5682_CBJ_IN_BUF_EN, RT5682_CBJ_IN_BUF_EN);	468	RT5682_CBJ_IN_BUF_EN, RT5682_CBJ_IN_BUF_EN);
468	regmap_update_bits(rt5682->regmap, RT5682_SAR_IL_CMD_1,	469	regmap_update_bits(rt5682->regmap, RT5682_SAR_IL_CMD_1,

sound/soc/codecs/tas2562.h+7−7

@@ -57,13 +57,13 @@ · 56 unmodified lines
57	#define TAS2562_TDM_CFG0_RAMPRATE_MASK BIT(5)	57	#define TAS2562_TDM_CFG0_RAMPRATE_MASK BIT(5)
58	#define TAS2562_TDM_CFG0_RAMPRATE_44_1 BIT(5)	58	#define TAS2562_TDM_CFG0_RAMPRATE_44_1 BIT(5)
59	#define TAS2562_TDM_CFG0_SAMPRATE_MASK GENMASK(3, 1)	59	#define TAS2562_TDM_CFG0_SAMPRATE_MASK GENMASK(3, 1)
60	#define TAS2562_TDM_CFG0_SAMPRATE_7305_8KHZ 0x0	60	#define TAS2562_TDM_CFG0_SAMPRATE_7305_8KHZ (0x0 << 1)
61	#define TAS2562_TDM_CFG0_SAMPRATE_14_7_16KHZ 0x1	61	#define TAS2562_TDM_CFG0_SAMPRATE_14_7_16KHZ (0x1 << 1)
62	#define TAS2562_TDM_CFG0_SAMPRATE_22_05_24KHZ 0x2	62	#define TAS2562_TDM_CFG0_SAMPRATE_22_05_24KHZ (0x2 << 1)
63	#define TAS2562_TDM_CFG0_SAMPRATE_29_4_32KHZ 0x3	63	#define TAS2562_TDM_CFG0_SAMPRATE_29_4_32KHZ (0x3 << 1)
64	#define TAS2562_TDM_CFG0_SAMPRATE_44_1_48KHZ 0x4	64	#define TAS2562_TDM_CFG0_SAMPRATE_44_1_48KHZ (0x4 << 1)
65	#define TAS2562_TDM_CFG0_SAMPRATE_88_2_96KHZ 0x5	65	#define TAS2562_TDM_CFG0_SAMPRATE_88_2_96KHZ (0x5 << 1)
66	#define TAS2562_TDM_CFG0_SAMPRATE_176_4_192KHZ 0x6	66	#define TAS2562_TDM_CFG0_SAMPRATE_176_4_192KHZ (0x6 << 1)
67		67
68	#define TAS2562_TDM_CFG2_RIGHT_JUSTIFY BIT(6)	68	#define TAS2562_TDM_CFG2_RIGHT_JUSTIFY BIT(6)
69		69

sound/soc/fsl/fsl-asoc-card.c+1−0

@@ -744,6 +744,7 @@ static int fsl_asoc_card_probe(struct platform_device *pdev) · 743 unmodified lines
744	/* Initialize sound card */	744	/* Initialize sound card */
745	priv->pdev = pdev;	745	priv->pdev = pdev;
746	priv->card.dev = &pdev->dev;	746	priv->card.dev = &pdev->dev;
		747	priv->card.owner = THIS_MODULE;
747	ret = snd_soc_of_parse_card_name(&priv->card, "model");	748	ret = snd_soc_of_parse_card_name(&priv->card, "model");
748	if (ret) {	749	if (ret) {
749	snprintf(priv->name, sizeof(priv->name), "%s-audio",	750	snprintf(priv->name, sizeof(priv->name), "%s-audio",

sound/soc/qcom/lpass-cpu.c+79−0

@@ -93,8 +93,30 @@ static void lpass_cpu_daiops_shutdown(struct snd_pcm_substream *substream, · 92 unmodified lines
93	struct snd_soc_dai *dai)	93	struct snd_soc_dai *dai)
94	{	94	{
95	struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);	95	struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);
		96	struct lpaif_i2sctl *i2sctl = drvdata->i2sctl;
		97	unsigned int id = dai->driver->id;
96		98
97	clk_disable_unprepare(drvdata->mi2s_osr_clk[dai->driver->id]);	99	clk_disable_unprepare(drvdata->mi2s_osr_clk[dai->driver->id]);
		100	/*
		101	* Ensure LRCLK is disabled even in device node validation.
		102	* Will not impact if disabled in lpass_cpu_daiops_trigger()
		103	* suspend.
		104	*/
		105	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		106	regmap_fields_write(i2sctl->spken, id, LPAIF_I2SCTL_SPKEN_DISABLE);
		107	else
		108	regmap_fields_write(i2sctl->micen, id, LPAIF_I2SCTL_MICEN_DISABLE);
		109
		110	/*
		111	* BCLK may not be enabled if lpass_cpu_daiops_prepare is called before
		112	* lpass_cpu_daiops_shutdown. It's paired with the clk_enable in
		113	* lpass_cpu_daiops_prepare.
		114	*/
		115	if (drvdata->mi2s_was_prepared[dai->driver->id]) {
		116	drvdata->mi2s_was_prepared[dai->driver->id] = false;
		117	clk_disable(drvdata->mi2s_bit_clk[dai->driver->id]);
		118	}
		119
98	clk_unprepare(drvdata->mi2s_bit_clk[dai->driver->id]);	120	clk_unprepare(drvdata->mi2s_bit_clk[dai->driver->id]);
99	}	121	}
100		122
@@ -275,6 +297,18 @@ static int lpass_cpu_daiops_trigger(struct snd_pcm_substream *substream, · 174 unmodified lines
275	case SNDRV_PCM_TRIGGER_START:	297	case SNDRV_PCM_TRIGGER_START:
276	case SNDRV_PCM_TRIGGER_RESUME:	298	case SNDRV_PCM_TRIGGER_RESUME:
277	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:	299	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		300	/*
		301	* Ensure lpass BCLK/LRCLK is enabled during
		302	* device resume as lpass_cpu_daiops_prepare() is not called
		303	* after the device resumes. We don't check mi2s_was_prepared before
		304	* enable/disable BCLK in trigger events because:
		305	* 1. These trigger events are paired, so the BCLK
		306	* enable_count is balanced.
		307	* 2. the BCLK can be shared (ex: headset and headset mic),
		308	* we need to increase the enable_count so that we don't
		309	* turn off the shared BCLK while other devices are using
		310	* it.
		311	*/
278	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {	312	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
279	ret = regmap_fields_write(i2sctl->spken, id,	313	ret = regmap_fields_write(i2sctl->spken, id,
280	LPAIF_I2SCTL_SPKEN_ENABLE);	314	LPAIF_I2SCTL_SPKEN_ENABLE);
@@ -296,6 +330,10 @@ static int lpass_cpu_daiops_trigger(struct snd_pcm_substream *substream, · 15 unmodified lines
296	case SNDRV_PCM_TRIGGER_STOP:	330	case SNDRV_PCM_TRIGGER_STOP:
297	case SNDRV_PCM_TRIGGER_SUSPEND:	331	case SNDRV_PCM_TRIGGER_SUSPEND:
298	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:	332	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
		333	/*
		334	* To ensure lpass BCLK/LRCLK is disabled during
		335	* device suspend.
		336	*/
299	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {	337	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
300	ret = regmap_fields_write(i2sctl->spken, id,	338	ret = regmap_fields_write(i2sctl->spken, id,
301	LPAIF_I2SCTL_SPKEN_DISABLE);	339	LPAIF_I2SCTL_SPKEN_DISABLE);
@@ -315,12 +353,53 @@ static int lpass_cpu_daiops_trigger(struct snd_pcm_substream *substream, · 13 unmodified lines
315	return ret;	353	return ret;
316	}	354	}
317		355
		356	static int lpass_cpu_daiops_prepare(struct snd_pcm_substream *substream,
		357	struct snd_soc_dai *dai)
		358	{
		359	struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);
		360	struct lpaif_i2sctl *i2sctl = drvdata->i2sctl;
		361	unsigned int id = dai->driver->id;
		362	int ret;
		363
		364	/*
		365	* Ensure lpass BCLK/LRCLK is enabled bit before playback/capture
		366	* data flow starts. This allows other codec to have some delay before
		367	* the data flow.
		368	* (ex: to drop start up pop noise before capture starts).
		369	*/
		370	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		371	ret = regmap_fields_write(i2sctl->spken, id, LPAIF_I2SCTL_SPKEN_ENABLE);
		372	else
		373	ret = regmap_fields_write(i2sctl->micen, id, LPAIF_I2SCTL_MICEN_ENABLE);
		374
		375	if (ret) {
		376	dev_err(dai->dev, "error writing to i2sctl reg: %d\n", ret);
		377	return ret;
		378	}
		379
		380	/*
		381	* Check mi2s_was_prepared before enabling BCLK as lpass_cpu_daiops_prepare can
		382	* be called multiple times. It's paired with the clk_disable in
		383	* lpass_cpu_daiops_shutdown.
		384	*/
		385	if (!drvdata->mi2s_was_prepared[dai->driver->id]) {
		386	ret = clk_enable(drvdata->mi2s_bit_clk[id]);
		387	if (ret) {
		388	dev_err(dai->dev, "error in enabling mi2s bit clk: %d\n", ret);
		389	return ret;
		390	}
		391	drvdata->mi2s_was_prepared[dai->driver->id] = true;
		392	}
		393	return 0;
		394	}
		395
318	const struct snd_soc_dai_ops asoc_qcom_lpass_cpu_dai_ops = {	396	const struct snd_soc_dai_ops asoc_qcom_lpass_cpu_dai_ops = {
319	.set_sysclk = lpass_cpu_daiops_set_sysclk,	397	.set_sysclk = lpass_cpu_daiops_set_sysclk,
320	.startup = lpass_cpu_daiops_startup,	398	.startup = lpass_cpu_daiops_startup,
321	.shutdown = lpass_cpu_daiops_shutdown,	399	.shutdown = lpass_cpu_daiops_shutdown,
322	.hw_params = lpass_cpu_daiops_hw_params,	400	.hw_params = lpass_cpu_daiops_hw_params,
323	.trigger = lpass_cpu_daiops_trigger,	401	.trigger = lpass_cpu_daiops_trigger,
		402	.prepare = lpass_cpu_daiops_prepare,
324	};	403	};
325	EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_dai_ops);	404	EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_dai_ops);
326		405

sound/soc/qcom/lpass.h+4−0

@@ -67,6 +67,10 @@ struct lpass_data { · 66 unmodified lines
67	/* MI2S SD lines to use for playback/capture */	67	/* MI2S SD lines to use for playback/capture */
68	unsigned int mi2s_playback_sd_mode[LPASS_MAX_MI2S_PORTS];	68	unsigned int mi2s_playback_sd_mode[LPASS_MAX_MI2S_PORTS];
69	unsigned int mi2s_capture_sd_mode[LPASS_MAX_MI2S_PORTS];	69	unsigned int mi2s_capture_sd_mode[LPASS_MAX_MI2S_PORTS];
		70
		71	/* The state of MI2S prepare dai_ops was called */
		72	bool mi2s_was_prepared[LPASS_MAX_MI2S_PORTS];
		73
70	int hdmi_port_enable;	74	int hdmi_port_enable;
71		75
72	/* low-power audio interface (LPAIF) registers */	76	/* low-power audio interface (LPAIF) registers */

sound/soc/soc-core.c+2−0

@@ -2225,6 +2225,8 @@ static char fmt_single_name(struct device dev, int *id) · 2224 unmodified lines
2225	return NULL;	2225	return NULL;
2226		2226
2227	name = devm_kstrdup(dev, devname, GFP_KERNEL);	2227	name = devm_kstrdup(dev, devname, GFP_KERNEL);
		2228	if (!name)
		2229	return NULL;
2228		2230
2229	/* are we a "%s.%d" name (platform and SPI components) */	2231	/* are we a "%s.%d" name (platform and SPI components) */
2230	found = strstr(name, dev->driver->name);	2232	found = strstr(name, dev->driver->name);

sound/soc/soc-topology.c+3−3

sound/soc/sof/pm.c+1−0

@@ -256,6 +256,7 @@ suspend: · 255 unmodified lines
256		256
257	/* reset FW state */	257	/* reset FW state */
258	sdev->fw_state = SOF_FW_BOOT_NOT_STARTED;	258	sdev->fw_state = SOF_FW_BOOT_NOT_STARTED;
		259	sdev->enabled_cores_mask = 0;
259		260
260	return ret;	261	return ret;
261	}	262	}

tools/arch/mips/include/uapi/asm/perf_regs.h+40−0

@@ -0,0 +1,40 @@
	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
	2	#ifndef _ASM_MIPS_PERF_REGS_H
	3	#define _ASM_MIPS_PERF_REGS_H
	4
	5	enum perf_event_mips_regs {
	6	PERF_REG_MIPS_PC,
	7	PERF_REG_MIPS_R1,
	8	PERF_REG_MIPS_R2,
	9	PERF_REG_MIPS_R3,
	10	PERF_REG_MIPS_R4,
	11	PERF_REG_MIPS_R5,
	12	PERF_REG_MIPS_R6,
	13	PERF_REG_MIPS_R7,
	14	PERF_REG_MIPS_R8,
	15	PERF_REG_MIPS_R9,
	16	PERF_REG_MIPS_R10,
	17	PERF_REG_MIPS_R11,
	18	PERF_REG_MIPS_R12,
	19	PERF_REG_MIPS_R13,
	20	PERF_REG_MIPS_R14,
	21	PERF_REG_MIPS_R15,
	22	PERF_REG_MIPS_R16,
	23	PERF_REG_MIPS_R17,
	24	PERF_REG_MIPS_R18,
	25	PERF_REG_MIPS_R19,
	26	PERF_REG_MIPS_R20,
	27	PERF_REG_MIPS_R21,
	28	PERF_REG_MIPS_R22,
	29	PERF_REG_MIPS_R23,
	30	PERF_REG_MIPS_R24,
	31	PERF_REG_MIPS_R25,
	32	PERF_REG_MIPS_R26,
	33	PERF_REG_MIPS_R27,
	34	PERF_REG_MIPS_R28,
	35	PERF_REG_MIPS_R29,
	36	PERF_REG_MIPS_R30,
	37	PERF_REG_MIPS_R31,
	38	PERF_REG_MIPS_MAX = PERF_REG_MIPS_R31 + 1,
	39	};
	40	#endif /* _ASM_MIPS_PERF_REGS_H */

tools/arch/x86/include/asm/disabled-features.h+2−5

 # define DISABLE_PTI		(1 << (X86_FEATURE_PTI & 31))
 #endif
-#ifdef CONFIG_IOMMU_SUPPORT
+/* Force disable because it's broken beyond repair */
-# define DISABLE_ENQCMD	0
+#define DISABLE_ENQCMD		(1 << (X86_FEATURE_ENQCMD & 31))
-#else
-# define DISABLE_ENQCMD (1 << (X86_FEATURE_ENQCMD & 31))
-#endif
 #ifdef CONFIG_X86_SGX
 # define DISABLE_SGX	0

tools/bootconfig/include/linux/bootconfig.h+4−0

@@ -4,4 +4,8 @@ · 3 unmodified lines
4		4
5	#include "../../../../include/linux/bootconfig.h"	5	#include "../../../../include/linux/bootconfig.h"
6		6
		7	#ifndef fallthrough
		8	# define fallthrough
		9	#endif
		10
7	#endif	11	#endif

tools/bootconfig/main.c+1−0

@@ -399,6 +399,7 @@ static int apply_xbc(const char path, const char xbc_path) · 398 unmodified lines
399	}	399	}
400	/* TODO: Ensure the @path is initramfs/initrd image */	400	/* TODO: Ensure the @path is initramfs/initrd image */
401	if (fstat(fd, &stat) < 0) {	401	if (fstat(fd, &stat) < 0) {
		402	ret = -errno;
402	pr_err("Failed to get the size of %s\n", path);	403	pr_err("Failed to get the size of %s\n", path);
403	goto out;	404	goto out;
404	}	405	}

tools/objtool/arch/x86/decode.c+4−0

@@ -747,6 +747,10 @@ int arch_rewrite_retpolines(struct objtool_file *file) · 746 unmodified lines
747		747
748	list_for_each_entry(insn, &file->retpoline_call_list, call_node) {	748	list_for_each_entry(insn, &file->retpoline_call_list, call_node) {
749		749
		750	if (insn->type != INSN_JUMP_DYNAMIC &&
		751	insn->type != INSN_CALL_DYNAMIC)
		752	continue;
		753
750	if (!strcmp(insn->sec->name, ".text.__x86.indirect_thunk"))	754	if (!strcmp(insn->sec->name, ".text.__x86.indirect_thunk"))
751	continue;	755	continue;
752		756

tools/objtool/elf.c+24−1

@@ -717,7 +717,7 @@ static int elf_add_string(struct elf elf, struct section strtab, char *str) · 716 unmodified lines
717		717
718	struct symbol elf_create_undef_symbol(struct elf elf, const char *name)	718	struct symbol elf_create_undef_symbol(struct elf elf, const char *name)
719	{	719	{
720	struct section *symtab;	720	struct section symtab, symtab_shndx;
721	struct symbol *sym;	721	struct symbol *sym;
722	Elf_Data *data;	722	Elf_Data *data;
723	Elf_Scn *s;	723	Elf_Scn *s;
@@ -769,6 +769,29 @@ struct symbol elf_create_undef_symbol(struct elf elf, const char *name) · 45 unmodified lines
769	symtab->len += data->d_size;	769	symtab->len += data->d_size;
770	symtab->changed = true;	770	symtab->changed = true;
771		771
		772	symtab_shndx = find_section_by_name(elf, ".symtab_shndx");
		773	if (symtab_shndx) {
		774	s = elf_getscn(elf->elf, symtab_shndx->idx);
		775	if (!s) {
		776	WARN_ELF("elf_getscn");
		777	return NULL;
		778	}
		779
		780	data = elf_newdata(s);
		781	if (!data) {
		782	WARN_ELF("elf_newdata");
		783	return NULL;
		784	}
		785
		786	data->d_buf = &sym->sym.st_size; /* conveniently 0 */
		787	data->d_size = sizeof(Elf32_Word);
		788	data->d_align = 4;
		789	data->d_type = ELF_T_WORD;
		790
		791	symtab_shndx->len += 4;
		792	symtab_shndx->changed = true;
		793	}
		794
772	sym->sec = find_section_by_index(elf, 0);	795	sym->sec = find_section_by_index(elf, 0);
773		796
774	elf_add_symbol(elf, sym);	797	elf_add_symbol(elf, sym);

tools/perf/Makefile.config+0−1

@@ -90,7 +90,6 @@ endif · 89 unmodified lines
90	ifeq ($(ARCH),mips)	90	ifeq ($(ARCH),mips)
91	NO_PERF_REGS := 0	91	NO_PERF_REGS := 0
92	CFLAGS += -I$(OUTPUT)arch/mips/include/generated	92	CFLAGS += -I$(OUTPUT)arch/mips/include/generated
93	CFLAGS += -I../../arch/mips/include/uapi -I../../arch/mips/include/generated/uapi
94	LIBUNWIND_LIBS = -lunwind -lunwind-mips	93	LIBUNWIND_LIBS = -lunwind -lunwind-mips
95	endif	94	endif
96		95

tools/perf/builtin-record.c+6−0

 		rec->no_buildid = true;
 	}
+	if (rec->opts.record_cgroup && !perf_can_record_cgroup()) {
+		pr_err("Kernel has no cgroup sampling support.\n");
+		err = -EINVAL;
+		goto out_opts;
+	}
 	if (rec->opts.kcore)
 		rec->data.is_dir = true;

tools/perf/check-headers.sh+1−0

@@ -39,6 +39,7 @@ arch/x86/lib/x86-opcode-map.txt · 38 unmodified lines
39	arch/x86/tools/gen-insn-attr-x86.awk	39	arch/x86/tools/gen-insn-attr-x86.awk
40	arch/arm/include/uapi/asm/perf_regs.h	40	arch/arm/include/uapi/asm/perf_regs.h
41	arch/arm64/include/uapi/asm/perf_regs.h	41	arch/arm64/include/uapi/asm/perf_regs.h
		42	arch/mips/include/uapi/asm/perf_regs.h
42	arch/powerpc/include/uapi/asm/perf_regs.h	43	arch/powerpc/include/uapi/asm/perf_regs.h
43	arch/s390/include/uapi/asm/perf_regs.h	44	arch/s390/include/uapi/asm/perf_regs.h
44	arch/x86/include/uapi/asm/perf_regs.h	45	arch/x86/include/uapi/asm/perf_regs.h

tools/perf/tests/attr/base-record+1−1

@@ -16,7 +16,7 @@ pinned=0 · 15 unmodified lines
16	exclusive=0	16	exclusive=0
17	exclude_user=0	17	exclude_user=0
18	exclude_kernel=0\|1	18	exclude_kernel=0\|1
19	exclude_hv=0	19	exclude_hv=0\|1
20	exclude_idle=0	20	exclude_idle=0
21	mmap=1	21	mmap=1
22	comm=1	22	comm=1

tools/perf/util/bpf_counter.c+4−2

@@ -521,9 +521,10 @@ static int bperf__load(struct evsel evsel, struct target target) · 520 unmodified lines
521		521
522	evsel->bperf_leader_link_fd = bpf_link_get_fd_by_id(entry.link_id);	522	evsel->bperf_leader_link_fd = bpf_link_get_fd_by_id(entry.link_id);
523	if (evsel->bperf_leader_link_fd < 0 &&	523	if (evsel->bperf_leader_link_fd < 0 &&
524	bperf_reload_leader_program(evsel, attr_map_fd, &entry))	524	bperf_reload_leader_program(evsel, attr_map_fd, &entry)) {
		525	err = -1;
525	goto out;	526	goto out;
526		527	}
527	/*	528	/*
528	* The bpf_link holds reference to the leader program, and the	529	* The bpf_link holds reference to the leader program, and the
529	* leader program holds reference to the maps. Therefore, if	530	* leader program holds reference to the maps. Therefore, if
@@ -550,6 +551,7 @@ static int bperf__load(struct evsel evsel, struct target target) · 20 unmodified lines
550	/* Step 2: load the follower skeleton */	551	/* Step 2: load the follower skeleton */
551	evsel->follower_skel = bperf_follower_bpf__open();	552	evsel->follower_skel = bperf_follower_bpf__open();
552	if (!evsel->follower_skel) {	553	if (!evsel->follower_skel) {
		554	err = -1;
553	pr_err("Failed to open follower skeleton\n");	555	pr_err("Failed to open follower skeleton\n");
554	goto out;	556	goto out;
555	}	557	}

tools/perf/util/dwarf-aux.c+6−2

 	if ((tag == DW_TAG_formal_parameter ||
 	     tag == DW_TAG_variable) &&
 	    die_compare_name(die_mem, fvp->name) &&
-	/* Does the DIE have location information or external instance? */
+	/*
+	 * Does the DIE have location information or const value
+	 * or external instance?
+	 */
 	    (dwarf_attr(die_mem, DW_AT_external, &attr) ||
-	     dwarf_attr(die_mem, DW_AT_location, &attr)))
+	     dwarf_attr(die_mem, DW_AT_location, &attr) ||
+	     dwarf_attr(die_mem, DW_AT_const_value, &attr)))
 		return DIE_FIND_CB_END;
 	if (dwarf_haspc(die_mem, fvp->addr))
 		return DIE_FIND_CB_CONTINUE;

tools/perf/util/env.c+1−0

@@ -144,6 +144,7 @@ static void perf_env__purge_bpf(struct perf_env *env) · 143 unmodified lines
144	node = rb_entry(next, struct bpf_prog_info_node, rb_node);	144	node = rb_entry(next, struct bpf_prog_info_node, rb_node);
145	next = rb_next(&node->rb_node);	145	next = rb_next(&node->rb_node);
146	rb_erase(&node->rb_node, root);	146	rb_erase(&node->rb_node, root);
		147	free(node->info_linear);
147	free(node);	148	free(node);
148	}	149	}
149		150

tools/perf/util/evsel.c+1−0

@@ -428,6 +428,7 @@ struct evsel evsel__clone(struct evsel orig) · 427 unmodified lines
428	evsel->auto_merge_stats = orig->auto_merge_stats;	428	evsel->auto_merge_stats = orig->auto_merge_stats;
429	evsel->collect_stat = orig->collect_stat;	429	evsel->collect_stat = orig->collect_stat;
430	evsel->weak_group = orig->weak_group;	430	evsel->weak_group = orig->weak_group;
		431	evsel->use_config_name = orig->use_config_name;
431		432
432	if (evsel__copy_config_terms(evsel, orig) < 0)	433	if (evsel__copy_config_terms(evsel, orig) < 0)
433	goto out_err;	434	goto out_err;

tools/perf/util/evsel.h+2−2

 		bool			collect_stat;
 		bool			weak_group;
 		bool			bpf_counter;
+		bool			use_config_name;
 		int			bpf_fd;
 		struct bpf_object	*bpf_obj;
+		struct list_head	config_terms;
 	};
 	/*
 	bool			merged_stat;
 	bool			reset_group;
 	bool			errored;
-	bool			use_config_name;
 	struct hashmap		*per_pkg_mask;
 	struct evsel		*leader;
-	struct list_head	config_terms;
 	int			err;
 	int			cpu_iter;
 	struct {

tools/perf/util/perf_api_probe.c+10−0

@@ -103,6 +103,11 @@ static void perf_probe_build_id(struct evsel *evsel) · 102 unmodified lines
103	evsel->core.attr.build_id = 1;	103	evsel->core.attr.build_id = 1;
104	}	104	}
105		105
		106	static void perf_probe_cgroup(struct evsel *evsel)
		107	{
		108	evsel->core.attr.cgroup = 1;
		109	}
		110
106	bool perf_can_sample_identifier(void)	111	bool perf_can_sample_identifier(void)
107	{	112	{
108	return perf_probe_api(perf_probe_sample_identifier);	113	return perf_probe_api(perf_probe_sample_identifier);
@@ -182,3 +187,8 @@ bool perf_can_record_build_id(void) · 73 unmodified lines
182	{	187	{
183	return perf_probe_api(perf_probe_build_id);	188	return perf_probe_api(perf_probe_build_id);
184	}	189	}
		190
		191	bool perf_can_record_cgroup(void)
		192	{
		193	return perf_probe_api(perf_probe_cgroup);
		194	}

tools/perf/util/perf_api_probe.h+1−0

@@ -12,5 +12,6 @@ bool perf_can_record_switch_events(void); · 11 unmodified lines
12	bool perf_can_record_text_poke_events(void);	12	bool perf_can_record_text_poke_events(void);
13	bool perf_can_sample_identifier(void);	13	bool perf_can_sample_identifier(void);
14	bool perf_can_record_build_id(void);	14	bool perf_can_record_build_id(void);
		15	bool perf_can_record_cgroup(void);
15		16
16	#endif // __PERF_API_PROBE_H	17	#endif // __PERF_API_PROBE_H

tools/perf/util/probe-finder.c+3−0

@@ -190,6 +190,9 @@ static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr, · 189 unmodified lines
190	immediate_value_is_supported()) {	190	immediate_value_is_supported()) {
191	Dwarf_Sword snum;	191	Dwarf_Sword snum;
192		192
		193	if (!tvar)
		194	return 0;
		195
193	dwarf_formsdata(&attr, &snum);	196	dwarf_formsdata(&attr, &snum);
194	ret = asprintf(&tvar->value, "\\%ld", (long)snum);	197	ret = asprintf(&tvar->value, "\\%ld", (long)snum);
195		198

tools/perf/util/session.c+1−0

@@ -1723,6 +1723,7 @@ int perf_session__peek_event(struct perf_session *session, off_t file_offset, · 1722 unmodified lines
1723	if (event->header.size < hdr_sz \|\| event->header.size > buf_sz)	1723	if (event->header.size < hdr_sz \|\| event->header.size > buf_sz)
1724	return -1;	1724	return -1;
1725		1725
		1726	buf += hdr_sz;
1726	rest = event->header.size - hdr_sz;	1727	rest = event->header.size - hdr_sz;
1727		1728
1728	if (readn(fd, buf, rest) != (ssize_t)rest)	1729	if (readn(fd, buf, rest) != (ssize_t)rest)

tools/perf/util/stat-display.c+3−5

 	char *config;
 	int ret = 0;
-	if (counter->uniquified_name ||
+	if (counter->uniquified_name || counter->use_config_name ||
 	    !counter->pmu_name || !strncmp(counter->name, counter->pmu_name,
 					   strlen(counter->pmu_name)))
 		return;
 		}
 	} else {
 		if (perf_pmu__has_hybrid()) {
-			if (!counter->use_config_name) {
+			ret = asprintf(&new_name, "%s/%s/",
-				ret = asprintf(&new_name, "%s/%s/",
+				       counter->pmu_name, counter->name);
-					       counter->pmu_name, counter->name);
-			}
 		} else {
 			ret = asprintf(&new_name, "%s [%s]",
 				       counter->name, counter->pmu_name);

tools/perf/util/symbol-elf.c+1−0

@@ -2412,6 +2412,7 @@ int cleanup_sdt_note_list(struct list_head *sdt_notes) · 2411 unmodified lines
2412		2412
2413	list_for_each_entry_safe(pos, tmp, sdt_notes, note_list) {	2413	list_for_each_entry_safe(pos, tmp, sdt_notes, note_list) {
2414	list_del_init(&pos->note_list);	2414	list_del_init(&pos->note_list);
		2415	zfree(&pos->args);
2415	zfree(&pos->name);	2416	zfree(&pos->name);
2416	zfree(&pos->provider);	2417	zfree(&pos->provider);
2417	free(pos);	2418	free(pos);

tools/testing/selftests/kvm/include/kvm_util.h+6−4

 	VM_MODE_P40V48_4K,
 	VM_MODE_P40V48_64K,
 	VM_MODE_PXXV48_4K,	/* For 48bits VA but ANY bits PA */
+	VM_MODE_P47V64_4K,
 	NUM_VM_MODES,
 };
 #elif defined(__s390x__)
-#define VM_MODE_DEFAULT			VM_MODE_P52V48_4K
+#define VM_MODE_DEFAULT			VM_MODE_P47V64_4K
 #define MIN_PAGE_SHIFT			12U
 #define ptes_per_page(page_size)	((page_size) / 16)
 					    uint32_t num_percpu_pages, void *guest_code,
 					    uint32_t vcpuids[]);
-/* Like vm_create_default_with_vcpus, but accepts mode as a parameter */
+/* Like vm_create_default_with_vcpus, but accepts mode and slot0 memory as a parameter */
 struct kvm_vm *vm_create_with_vcpus(enum vm_guest_mode mode, uint32_t nr_vcpus,
-				    uint64_t extra_mem_pages, uint32_t num_percpu_pages,
+				    uint64_t slot0_mem_pages, uint64_t extra_mem_pages,
-				    void *guest_code, uint32_t vcpuids[]);
+				    uint32_t num_percpu_pages, void *guest_code,
+				    uint32_t vcpuids[]);
 /*
  * Adds a vCPU with reasonable defaults (e.g. a stack)

tools/testing/selftests/kvm/kvm_page_table_test.c+1−1

@@ -268,7 +268,7 @@ static struct kvm_vm pre_init_before_test(enum vm_guest_mode mode, void arg) · 267 unmodified lines
268		268
269	/* Create a VM with enough guest pages */	269	/* Create a VM with enough guest pages */
270	guest_num_pages = test_mem_size / guest_page_size;	270	guest_num_pages = test_mem_size / guest_page_size;
271	vm = vm_create_with_vcpus(mode, nr_vcpus,	271	vm = vm_create_with_vcpus(mode, nr_vcpus, DEFAULT_GUEST_PHY_PAGES,
272	guest_num_pages, 0, guest_code, NULL);	272	guest_num_pages, 0, guest_code, NULL);
273		273
274	/* Align down GPA of the testing memslot */	274	/* Align down GPA of the testing memslot */

tools/testing/selftests/kvm/lib/kvm_util.c+43−9

 		[VM_MODE_P40V48_4K]	= "PA-bits:40,  VA-bits:48,  4K pages",
 		[VM_MODE_P40V48_64K]	= "PA-bits:40,  VA-bits:48, 64K pages",
 		[VM_MODE_PXXV48_4K]	= "PA-bits:ANY, VA-bits:48,  4K pages",
+		[VM_MODE_P47V64_4K]	= "PA-bits:47,  VA-bits:64,  4K pages",
 	};
 	_Static_assert(sizeof(strings)/sizeof(char *) == NUM_VM_MODES,
 		       "Missing new mode strings?");
 	{ 40, 48,  0x1000, 12 },
 	{ 40, 48, 0x10000, 16 },
 	{  0,  0,  0x1000, 12 },
+	{ 47, 64,  0x1000, 12 },
 };
 _Static_assert(sizeof(vm_guest_mode_params)/sizeof(struct vm_guest_mode_params) == NUM_VM_MODES,
 	       "Missing new mode params?");
 		TEST_FAIL("VM_MODE_PXXV48_4K not supported on non-x86 platforms");
 #endif
 		break;
+	case VM_MODE_P47V64_4K:
+		vm->pgtable_levels = 5;
+		break;
 	default:
 		TEST_FAIL("Unknown guest mode, mode: 0x%x", mode);
 	}
 	return vm;
 }
+/*
+ * VM Create with customized parameters
+ *
+ * Input Args:
+ *   mode - VM Mode (e.g. VM_MODE_P52V48_4K)
+ *   nr_vcpus - VCPU count
+ *   slot0_mem_pages - Slot0 physical memory size
+ *   extra_mem_pages - Non-slot0 physical memory total size
+ *   num_percpu_pages - Per-cpu physical memory pages
+ *   guest_code - Guest entry point
+ *   vcpuids - VCPU IDs
+ *
+ * Output Args: None
+ *
+ * Return:
+ *   Pointer to opaque structure that describes the created VM.
+ *
+ * Creates a VM with the mode specified by mode (e.g. VM_MODE_P52V48_4K),
+ * with customized slot0 memory size, at least 512 pages currently.
+ * extra_mem_pages is only used to calculate the maximum page table size,
+ * no real memory allocation for non-slot0 memory in this function.
+ */
 struct kvm_vm *vm_create_with_vcpus(enum vm_guest_mode mode, uint32_t nr_vcpus,
-				    uint64_t extra_mem_pages, uint32_t num_percpu_pages,
+				    uint64_t slot0_mem_pages, uint64_t extra_mem_pages,
-				    void *guest_code, uint32_t vcpuids[])
+				    uint32_t num_percpu_pages, void *guest_code,
+				    uint32_t vcpuids[])
 {
+	uint64_t vcpu_pages, extra_pg_pages, pages;
+	struct kvm_vm *vm;
+	int i;
+	/* Force slot0 memory size not small than DEFAULT_GUEST_PHY_PAGES */
+	if (slot0_mem_pages < DEFAULT_GUEST_PHY_PAGES)
+		slot0_mem_pages = DEFAULT_GUEST_PHY_PAGES;
 	/* The maximum page table size for a memory region will be when the
 	 * smallest pages are used. Considering each page contains x page
 	 * table descriptors, the total extra size for page tables (for extra
 	 * N pages) will be: N/x+N/x^2+N/x^3+... which is definitely smaller
 	 * than N/x*2.
 	 */
-	uint64_t vcpu_pages = (DEFAULT_STACK_PGS + num_percpu_pages) * nr_vcpus;
+	vcpu_pages = (DEFAULT_STACK_PGS + num_percpu_pages) * nr_vcpus;
-	uint64_t extra_pg_pages = (extra_mem_pages + vcpu_pages) / PTES_PER_MIN_PAGE * 2;
+	extra_pg_pages = (slot0_mem_pages + extra_mem_pages + vcpu_pages) / PTES_PER_MIN_PAGE * 2;
-	uint64_t pages = DEFAULT_GUEST_PHY_PAGES + extra_mem_pages + vcpu_pages + extra_pg_pages;
+	pages = slot0_mem_pages + vcpu_pages + extra_pg_pages;
-	struct kvm_vm *vm;
-	int i;
 	TEST_ASSERT(nr_vcpus <= kvm_check_cap(KVM_CAP_MAX_VCPUS),
 		    "nr_vcpus = %d too large for host, max-vcpus = %d",
 					    uint32_t num_percpu_pages, void *guest_code,
 					    uint32_t vcpuids[])
 {
-	return vm_create_with_vcpus(VM_MODE_DEFAULT, nr_vcpus, extra_mem_pages,
+	return vm_create_with_vcpus(VM_MODE_DEFAULT, nr_vcpus, DEFAULT_GUEST_PHY_PAGES,
-				    num_percpu_pages, guest_code, vcpuids);
+				    extra_mem_pages, num_percpu_pages, guest_code, vcpuids);
 }
 struct kvm_vm *vm_create_default(uint32_t vcpuid, uint64_t extra_mem_pages,

tools/testing/selftests/kvm/lib/perf_test_util.c+1−1

@@ -69,7 +69,7 @@ struct kvm_vm *perf_test_create_vm(enum vm_guest_mode mode, int vcpus, · 68 unmodified lines
69	TEST_ASSERT(vcpu_memory_bytes % perf_test_args.guest_page_size == 0,	69	TEST_ASSERT(vcpu_memory_bytes % perf_test_args.guest_page_size == 0,
70	"Guest memory size is not guest page size aligned.");	70	"Guest memory size is not guest page size aligned.");
71		71
72	vm = vm_create_with_vcpus(mode, vcpus,	72	vm = vm_create_with_vcpus(mode, vcpus, DEFAULT_GUEST_PHY_PAGES,
73	(vcpus * vcpu_memory_bytes) / perf_test_args.guest_page_size,	73	(vcpus * vcpu_memory_bytes) / perf_test_args.guest_page_size,
74	0, guest_code, NULL);	74	0, guest_code, NULL);
75		75

tools/testing/selftests/kvm/memslot_perf_test.c+1−1

@@ -267,7 +267,7 @@ static bool prepare_vm(struct vm_data data, int nslots, uint64_t maxslots, · 266 unmodified lines
267	data->hva_slots = malloc(sizeof(data->hva_slots) data->nslots);	267	data->hva_slots = malloc(sizeof(data->hva_slots) data->nslots);
268	TEST_ASSERT(data->hva_slots, "malloc() fail");	268	TEST_ASSERT(data->hva_slots, "malloc() fail");
269		269
270	data->vm = vm_create_default(VCPU_ID, 1024, guest_code);	270	data->vm = vm_create_default(VCPU_ID, mempages, guest_code);
271		271
272	pr_info_v("Adding slots 1..%i, each slot with %"PRIu64" pages + %"PRIu64" extra pages last\n",	272	pr_info_v("Adding slots 1..%i, each slot with %"PRIu64" pages + %"PRIu64" extra pages last\n",
273	max_mem_slots - 1, data->pages_per_slot, rempages);	273	max_mem_slots - 1, data->pages_per_slot, rempages);

tools/testing/selftests/net/mptcp/mptcp_connect.sh+9−4

 	local stat_ackrx_now_l=$(get_mib_counter "${listener_ns}" "MPTcpExtMPCapableACKRX")
 	local stat_cookietx_now=$(get_mib_counter "${listener_ns}" "TcpExtSyncookiesSent")
 	local stat_cookierx_now=$(get_mib_counter "${listener_ns}" "TcpExtSyncookiesRecv")
+	local stat_ooo_now=$(get_mib_counter "${listener_ns}" "TcpExtTCPOFOQueue")
 	expect_synrx=$((stat_synrx_last_l))
 	expect_ackrx=$((stat_ackrx_last_l))
 			"${stat_synrx_now_l}" "${expect_synrx}" 1>&2
 		retc=1
 	fi
-	if [ ${stat_ackrx_now_l} -lt ${expect_ackrx} ]; then
+	if [ ${stat_ackrx_now_l} -lt ${expect_ackrx} -a ${stat_ooo_now} -eq 0 ]; then
-		printf "[ FAIL ] lower MPC ACK rx (%d) than expected (%d)\n" \
+		if [ ${stat_ooo_now} -eq 0 ]; then
-			"${stat_ackrx_now_l}" "${expect_ackrx}" 1>&2
+			printf "[ FAIL ] lower MPC ACK rx (%d) than expected (%d)\n" \
-		rets=1
+				"${stat_ackrx_now_l}" "${expect_ackrx}" 1>&2
+			rets=1
+		else
+			printf "[ Note ] fallback due to TCP OoO"
+		fi
 	fi
 	if [ $retc -eq 0 ] && [ $rets -eq 0 ]; then

tools/testing/selftests/proc/.gitignore+1−0

@@ -10,6 +10,7 @@ · 9 unmodified lines
10	/proc-self-map-files-002	10	/proc-self-map-files-002
11	/proc-self-syscall	11	/proc-self-syscall
12	/proc-self-wchan	12	/proc-self-wchan
		13	/proc-subset-pid
13	/proc-uptime-001	14	/proc-uptime-001
14	/proc-uptime-002	15	/proc-uptime-002
15	/read	16	/read

tools/testing/selftests/wireguard/netns.sh+1−0

@@ -363,6 +363,7 @@ ip1 -6 rule add table main suppress_prefixlength 0 · 362 unmodified lines
363	ip1 -4 route add default dev wg0 table 51820	363	ip1 -4 route add default dev wg0 table 51820
364	ip1 -4 rule add not fwmark 51820 table 51820	364	ip1 -4 rule add not fwmark 51820 table 51820
365	ip1 -4 rule add table main suppress_prefixlength 0	365	ip1 -4 rule add table main suppress_prefixlength 0
		366	n1 bash -c 'printf 0 > /proc/sys/net/ipv4/conf/vethc/rp_filter'
366	# Flood the pings instead of sending just one, to trigger routing table reference counting bugs.	367	# Flood the pings instead of sending just one, to trigger routing table reference counting bugs.
367	n1 ping -W 1 -c 100 -f 192.168.99.7	368	n1 ping -W 1 -c 100 -f 192.168.99.7
368	n1 ping -W 1 -c 100 -f abab::1111	369	n1 ping -W 1 -c 100 -f abab::1111

tools/testing/selftests/wireguard/qemu/kernel.config+0−1

@@ -19,7 +19,6 @@ CONFIG_NETFILTER_XTABLES=y · 18 unmodified lines
19	CONFIG_NETFILTER_XT_NAT=y	19	CONFIG_NETFILTER_XT_NAT=y
20	CONFIG_NETFILTER_XT_MATCH_LENGTH=y	20	CONFIG_NETFILTER_XT_MATCH_LENGTH=y
21	CONFIG_NETFILTER_XT_MARK=y	21	CONFIG_NETFILTER_XT_MARK=y
22	CONFIG_NF_CONNTRACK_IPV4=y
23	CONFIG_NF_NAT_IPV4=y	22	CONFIG_NF_NAT_IPV4=y
24	CONFIG_IP_NF_IPTABLES=y	23	CONFIG_IP_NF_IPTABLES=y
25	CONFIG_IP_NF_FILTER=y	24	CONFIG_IP_NF_FILTER=y

@@ -1901,7 +1901,7 @@ static void stream_caps_new_ver(struct snd_soc_tplg_stream_caps *dest, · 1900 unmodified lines
1901	* @src: older version of pcm as a source	1901	* @src: older version of pcm as a source
1902	* @pcm: latest version of pcm created from the source	1902	* @pcm: latest version of pcm created from the source
1903	*	1903	*
1904	* Support from vesion 4. User should free the returned pcm manually.	1904	* Support from version 4. User should free the returned pcm manually.
1905	*/	1905	*/
1906	static int pcm_new_ver(struct soc_tplg *tplg,	1906	static int pcm_new_ver(struct soc_tplg *tplg,
1907	struct snd_soc_tplg_pcm *src,	1907	struct snd_soc_tplg_pcm *src,
@@ -2089,7 +2089,7 @@ static void set_link_hw_format(struct snd_soc_dai_link *link, · 181 unmodified lines
2089	* @src: old version of phyical link config as a source	2089	* @src: old version of phyical link config as a source
2090	* @link: latest version of physical link config created from the source	2090	* @link: latest version of physical link config created from the source
2091	*	2091	*
2092	* Support from vesion 4. User need free the returned link config manually.	2092	* Support from version 4. User need free the returned link config manually.
2093	*/	2093	*/
2094	static int link_new_ver(struct soc_tplg *tplg,	2094	static int link_new_ver(struct soc_tplg *tplg,
2095	struct snd_soc_tplg_link_config *src,	2095	struct snd_soc_tplg_link_config *src,
@@ -2400,7 +2400,7 @@ static int soc_tplg_dai_elems_load(struct soc_tplg *tplg, · 304 unmodified lines
2400	* @src: old version of manifest as a source	2400	* @src: old version of manifest as a source
2401	* @manifest: latest version of manifest created from the source	2401	* @manifest: latest version of manifest created from the source
2402	*	2402	*
2403	* Support from vesion 4. Users need free the returned manifest manually.	2403	* Support from version 4. Users need free the returned manifest manually.
2404	*/	2404	*/
2405	static int manifest_new_ver(struct soc_tplg *tplg,	2405	static int manifest_new_ver(struct soc_tplg *tplg,
2406	struct snd_soc_tplg_manifest *src,	2406	struct snd_soc_tplg_manifest *src,