lael-labs/linux

.mailmap+1−0

@@ -99,6 +99,7 @@ Jacob Shin <Jacob.Shin@amd.com> · 98 unmodified lines
99	Jaegeuk Kim <jaegeuk@kernel.org> <jaegeuk@google.com>	99	Jaegeuk Kim <jaegeuk@kernel.org> <jaegeuk@google.com>
100	Jaegeuk Kim <jaegeuk@kernel.org> <jaegeuk@motorola.com>	100	Jaegeuk Kim <jaegeuk@kernel.org> <jaegeuk@motorola.com>
101	Jaegeuk Kim <jaegeuk@kernel.org> <jaegeuk.kim@samsung.com>	101	Jaegeuk Kim <jaegeuk@kernel.org> <jaegeuk.kim@samsung.com>
		102	Jakub Kicinski <kuba@kernel.org> <jakub.kicinski@netronome.com>
102	James Bottomley <jejb@mulgrave.(none)>	103	James Bottomley <jejb@mulgrave.(none)>
103	James Bottomley <jejb@titanic.il.steeleye.com>	104	James Bottomley <jejb@titanic.il.steeleye.com>
104	James E Wilson <wilson@specifix.com>	105	James E Wilson <wilson@specifix.com>

Documentation/ABI/stable/sysfs-driver-mlxreg-io+11−2

 		The files are read only.
-What:		/sys/devices/platform/mlxplat/mlxreg-io/hwmon/hwmon*/jtag_enable
+What:		/sys/devices/platform/mlxplat/mlxreg-io/hwmon/hwmon*/cpld3_version
 Date:		November 2018
 KernelVersion:	5.0
 Contact:	Vadim Pasternak <vadimpmellanox.com>
 Description:	These files show with which CPLD versions have been burned
-		on LED board.
+		on LED or Gearbox board.
 		The files are read only.
 		The files are read only.
+What:		/sys/devices/platform/mlxplat/mlxreg-io/hwmon/hwmon*/cpld4_version
+Date:		November 2018
+KernelVersion:	5.0
+Contact:	Vadim Pasternak <vadimpmellanox.com>
+Description:	These files show with which CPLD versions have been burned
+		on LED board.
+		The files are read only.
 Date:		June 2019
 KernelVersion:	5.3
 Contact:	Vadim Pasternak <vadimpmellanox.com>

Documentation/admin-guide/devices.txt+1−1

@@ -319,7 +319,7 @@ · 318 unmodified lines
319	182 = /dev/perfctr Performance-monitoring counters	319	182 = /dev/perfctr Performance-monitoring counters
320	183 = /dev/hwrng Generic random number generator	320	183 = /dev/hwrng Generic random number generator
321	184 = /dev/cpu/microcode CPU microcode update interface	321	184 = /dev/cpu/microcode CPU microcode update interface
322	186 = /dev/atomicps Atomic shapshot of process state data	322	186 = /dev/atomicps Atomic snapshot of process state data
323	187 = /dev/irnet IrNET device	323	187 = /dev/irnet IrNET device
324	188 = /dev/smbusbios SMBus BIOS	324	188 = /dev/smbusbios SMBus BIOS
325	189 = /dev/ussp_ctl User space serial port control	325	189 = /dev/ussp_ctl User space serial port control

Documentation/media/v4l-drivers/meye.rst+1−1

@@ -95,7 +95,7 @@ so all video4linux tools (like xawtv) should work with this driver. · 94 unmodified lines
95		95
96	Besides the video4linux interface, the driver has a private interface	96	Besides the video4linux interface, the driver has a private interface
97	for accessing the Motion Eye extended parameters (camera sharpness,	97	for accessing the Motion Eye extended parameters (camera sharpness,
98	agc, video framerate), the shapshot and the MJPEG capture facilities.	98	agc, video framerate), the snapshot and the MJPEG capture facilities.
99		99
100	This interface consists of several ioctls (prototypes and structures	100	This interface consists of several ioctls (prototypes and structures
101	can be found in include/linux/meye.h):	101	can be found in include/linux/meye.h):

Documentation/process/embargoed-hardware-issues.rst+1−1

@@ -255,7 +255,7 @@ an involved disclosed party. The current ambassadors list: · 254 unmodified lines
255	Red Hat Josh Poimboeuf <jpoimboe@redhat.com>	255	Red Hat Josh Poimboeuf <jpoimboe@redhat.com>
256	SUSE Jiri Kosina <jkosina@suse.cz>	256	SUSE Jiri Kosina <jkosina@suse.cz>
257		257
258	Amazon	258	Amazon Peter Bowen <pzb@amzn.com>
259	Google Kees Cook <keescook@chromium.org>	259	Google Kees Cook <keescook@chromium.org>
260	============= ========================================================	260	============= ========================================================
261		261

MAINTAINERS+10−10

@@ -720,7 +720,7 @@ F: Documentation/devicetree/bindings/i2c/i2c-altera.txt · 719 unmodified lines
720	F: drivers/i2c/busses/i2c-altera.c	720	F: drivers/i2c/busses/i2c-altera.c
721		721
722	ALTERA MAILBOX DRIVER	722	ALTERA MAILBOX DRIVER
723	M: Ley Foon Tan <lftan@altera.com>	723	M: Ley Foon Tan <ley.foon.tan@intel.com>
724	L: nios2-dev@lists.rocketboards.org (moderated for non-subscribers)	724	L: nios2-dev@lists.rocketboards.org (moderated for non-subscribers)
725	S: Maintained	725	S: Maintained
726	F: drivers/mailbox/mailbox-altera.c	726	F: drivers/mailbox/mailbox-altera.c
@@ -1407,7 +1407,7 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc.git · 680 unmodified lines
1407		1407
1408	ARM/ACTIONS SEMI ARCHITECTURE	1408	ARM/ACTIONS SEMI ARCHITECTURE
1409	M: Andreas Färber <afaerber@suse.de>	1409	M: Andreas Färber <afaerber@suse.de>
1410	R: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>	1410	M: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
1411	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)	1411	L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
1412	S: Maintained	1412	S: Maintained
1413	N: owl	1413	N: owl
@@ -3150,7 +3150,7 @@ S: Maintained · 1736 unmodified lines
3150	F: arch/mips/net/	3150	F: arch/mips/net/
3151		3151
3152	BPF JIT for NFP NICs	3152	BPF JIT for NFP NICs
3153	M: Jakub Kicinski <jakub.kicinski@netronome.com>	3153	M: Jakub Kicinski <kuba@kernel.org>
3154	L: netdev@vger.kernel.org	3154	L: netdev@vger.kernel.org
3155	L: bpf@vger.kernel.org	3155	L: bpf@vger.kernel.org
3156	S: Supported	3156	S: Supported
@@ -11431,7 +11431,7 @@ F: include/uapi/linux/netrom.h · 8274 unmodified lines
11431	F: net/netrom/	11431	F: net/netrom/
11432		11432
11433	NETRONOME ETHERNET DRIVERS	11433	NETRONOME ETHERNET DRIVERS
11434	M: Jakub Kicinski <jakub.kicinski@netronome.com>	11434	M: Jakub Kicinski <kuba@kernel.org>
11435	L: oss-drivers@netronome.com	11435	L: oss-drivers@netronome.com
11436	S: Maintained	11436	S: Maintained
11437	F: drivers/net/ethernet/netronome/	11437	F: drivers/net/ethernet/netronome/
@@ -11591,7 +11591,7 @@ M: Boris Pismenny <borisp@mellanox.com> · 153 unmodified lines
11591	M: Aviad Yehezkel <aviadye@mellanox.com>	11591	M: Aviad Yehezkel <aviadye@mellanox.com>
11592	M: John Fastabend <john.fastabend@gmail.com>	11592	M: John Fastabend <john.fastabend@gmail.com>
11593	M: Daniel Borkmann <daniel@iogearbox.net>	11593	M: Daniel Borkmann <daniel@iogearbox.net>
11594	M: Jakub Kicinski <jakub.kicinski@netronome.com>	11594	M: Jakub Kicinski <kuba@kernel.org>
11595	L: netdev@vger.kernel.org	11595	L: netdev@vger.kernel.org
11596	S: Maintained	11596	S: Maintained
11597	F: net/tls/*	11597	F: net/tls/*
@@ -11603,7 +11603,7 @@ L: linux-wireless@vger.kernel.org · 5 unmodified lines
11603	Q: http://patchwork.kernel.org/project/linux-wireless/list/	11603	Q: http://patchwork.kernel.org/project/linux-wireless/list/
11604		11604
11605	NETDEVSIM	11605	NETDEVSIM
11606	M: Jakub Kicinski <jakub.kicinski@netronome.com>	11606	M: Jakub Kicinski <kuba@kernel.org>
11607	S: Maintained	11607	S: Maintained
11608	F: drivers/net/netdevsim/*	11608	F: drivers/net/netdevsim/*
11609		11609
@@ -11680,7 +11680,7 @@ F: Documentation/scsi/NinjaSCSI.txt · 70 unmodified lines
11680	F: drivers/scsi/nsp32*	11680	F: drivers/scsi/nsp32*
11681		11681
11682	NIOS2 ARCHITECTURE	11682	NIOS2 ARCHITECTURE
11683	M: Ley Foon Tan <lftan@altera.com>	11683	M: Ley Foon Tan <ley.foon.tan@intel.com>
11684	L: nios2-dev@lists.rocketboards.org (moderated for non-subscribers)	11684	L: nios2-dev@lists.rocketboards.org (moderated for non-subscribers)
11685	T: git git://git.kernel.org/pub/scm/linux/kernel/git/lftan/nios2.git	11685	T: git git://git.kernel.org/pub/scm/linux/kernel/git/lftan/nios2.git
11686	S: Maintained	11686	S: Maintained
@@ -12564,7 +12564,7 @@ F: Documentation/devicetree/bindings/pci/aardvark-pci.txt · 877 unmodified lines
12564	F: drivers/pci/controller/pci-aardvark.c	12564	F: drivers/pci/controller/pci-aardvark.c
12565		12565
12566	PCI DRIVER FOR ALTERA PCIE IP	12566	PCI DRIVER FOR ALTERA PCIE IP
12567	M: Ley Foon Tan <lftan@altera.com>	12567	M: Ley Foon Tan <ley.foon.tan@intel.com>
12568	L: rfi@lists.rocketboards.org (moderated for non-subscribers)	12568	L: rfi@lists.rocketboards.org (moderated for non-subscribers)
12569	L: linux-pci@vger.kernel.org	12569	L: linux-pci@vger.kernel.org
12570	S: Supported	12570	S: Supported
@@ -12743,7 +12743,7 @@ S: Supported · 172 unmodified lines
12743	F: Documentation/PCI/pci-error-recovery.rst	12743	F: Documentation/PCI/pci-error-recovery.rst
12744		12744
12745	PCI MSI DRIVER FOR ALTERA MSI IP	12745	PCI MSI DRIVER FOR ALTERA MSI IP
12746	M: Ley Foon Tan <lftan@altera.com>	12746	M: Ley Foon Tan <ley.foon.tan@intel.com>
12747	L: rfi@lists.rocketboards.org (moderated for non-subscribers)	12747	L: rfi@lists.rocketboards.org (moderated for non-subscribers)
12748	L: linux-pci@vger.kernel.org	12748	L: linux-pci@vger.kernel.org
12749	S: Supported	12749	S: Supported
@@ -18043,7 +18043,7 @@ XDP (eXpress Data Path) · 5293 unmodified lines
18043	M: Alexei Starovoitov <ast@kernel.org>	18043	M: Alexei Starovoitov <ast@kernel.org>
18044	M: Daniel Borkmann <daniel@iogearbox.net>	18044	M: Daniel Borkmann <daniel@iogearbox.net>
18045	M: David S. Miller <davem@davemloft.net>	18045	M: David S. Miller <davem@davemloft.net>
18046	M: Jakub Kicinski <jakub.kicinski@netronome.com>	18046	M: Jakub Kicinski <kuba@kernel.org>
18047	M: Jesper Dangaard Brouer <hawk@kernel.org>	18047	M: Jesper Dangaard Brouer <hawk@kernel.org>
18048	M: John Fastabend <john.fastabend@gmail.com>	18048	M: John Fastabend <john.fastabend@gmail.com>
18049	L: netdev@vger.kernel.org	18049	L: netdev@vger.kernel.org

Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 5	3	PATCHLEVEL = 5
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc6	5	EXTRAVERSION = -rc7
6	NAME = Kleptomaniac Octopus	6	NAME = Kleptomaniac Octopus
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION

arch/arm/boot/dts/am571x-idk.dts+1−5

 &pcie1_rc {
 	status = "okay";
-	gpios = <&gpio3 23 GPIO_ACTIVE_HIGH>;
+	gpios = <&gpio5 18 GPIO_ACTIVE_HIGH>;
-};
-&pcie1_ep {
-	gpios = <&gpio3 23 GPIO_ACTIVE_HIGH>;
 };
 &mmc1 {

arch/arm/boot/dts/am572x-idk-common.dtsi+0−4

 	gpios = <&gpio3 23 GPIO_ACTIVE_HIGH>;
 };
-&pcie1_ep {
-	gpios = <&gpio3 23 GPIO_ACTIVE_HIGH>;
-};
 &mailbox5 {
 	status = "okay";
 	mbox_ipu1_ipc3x: mbox_ipu1_ipc3x {

arch/arm/boot/dts/am57xx-beagle-x15-common.dtsi+21−4

@@ -29,6 +29,27 @@ · 28 unmodified lines
29	reg = <0x0 0x80000000 0x0 0x80000000>;	29	reg = <0x0 0x80000000 0x0 0x80000000>;
30	};	30	};
31		31
		32	main_12v0: fixedregulator-main_12v0 {
		33	/* main supply */
		34	compatible = "regulator-fixed";
		35	regulator-name = "main_12v0";
		36	regulator-min-microvolt = <12000000>;
		37	regulator-max-microvolt = <12000000>;
		38	regulator-always-on;
		39	regulator-boot-on;
		40	};
		41
		42	evm_5v0: fixedregulator-evm_5v0 {
		43	/* Output of TPS54531D */
		44	compatible = "regulator-fixed";
		45	regulator-name = "evm_5v0";
		46	regulator-min-microvolt = <5000000>;
		47	regulator-max-microvolt = <5000000>;
		48	vin-supply = <&main_12v0>;
		49	regulator-always-on;
		50	regulator-boot-on;
		51	};
		52
32	vdd_3v3: fixedregulator-vdd_3v3 {	53	vdd_3v3: fixedregulator-vdd_3v3 {
33	compatible = "regulator-fixed";	54	compatible = "regulator-fixed";
34	regulator-name = "vdd_3v3";	55	regulator-name = "vdd_3v3";
@@ -547,10 +568,6 @@ · 512 unmodified lines
547	gpios = <&gpio2 8 GPIO_ACTIVE_LOW>;	568	gpios = <&gpio2 8 GPIO_ACTIVE_LOW>;
548	};	569	};
549		570
550	&pcie1_ep {
551	gpios = <&gpio2 8 GPIO_ACTIVE_LOW>;
552	};
553
554	&mcasp3 {	571	&mcasp3 {
555	#sound-dai-cells = <0>;	572	#sound-dai-cells = <0>;
556	assigned-clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP3_CLKCTRL 24>;	573	assigned-clocks = <&l4per2_clkctrl DRA7_L4PER2_MCASP3_CLKCTRL 24>;

arch/arm/boot/dts/aspeed-bmc-ibm-rainier.dts+2−367

@@ -258,9 +258,9 @@ · 257 unmodified lines
258	};	258	};
259	};	259	};
260		260
261	pca0: pca9552@60 {	261	pca0: pca9552@61 {
262	compatible = "nxp,pca9552";	262	compatible = "nxp,pca9552";
263	reg = <0x60>;	263	reg = <0x61>;
264	#address-cells = <1>;	264	#address-cells = <1>;
265	#size-cells = <0>;	265	#size-cells = <0>;
266		266
@@ -519,371 +519,6 @@ · 252 unmodified lines
519	status = "okay";	519	status = "okay";
520	};	520	};
521		521
522	&i2c13 {
523	status = "okay";
524	};
525
526	&i2c14 {
527	status = "okay";
528	};
529
530	&i2c15 {
531	status = "okay";
532	};
533
534	&i2c0 {
535	status = "okay";
536	};
537
538	&i2c1 {
539	status = "okay";
540	};
541
542	&i2c2 {
543	status = "okay";
544	};
545
546	&i2c3 {
547	status = "okay";
548
549	power-supply@68 {
550	compatible = "ibm,cffps2";
551	reg = <0x68>;
552	};
553
554	power-supply@69 {
555	compatible = "ibm,cffps2";
556	reg = <0x69>;
557	};
558
559	power-supply@6a {
560	compatible = "ibm,cffps2";
561	reg = <0x6a>;
562	};
563
564	power-supply@6b {
565	compatible = "ibm,cffps2";
566	reg = <0x6b>;
567	};
568	};
569
570	&i2c4 {
571	status = "okay";
572
573	tmp275@48 {
574	compatible = "ti,tmp275";
575	reg = <0x48>;
576	};
577
578	tmp275@49 {
579	compatible = "ti,tmp275";
580	reg = <0x49>;
581	};
582
583	tmp275@4a {
584	compatible = "ti,tmp275";
585	reg = <0x4a>;
586	};
587	};
588
589	&i2c5 {
590	status = "okay";
591
592	tmp275@48 {
593	compatible = "ti,tmp275";
594	reg = <0x48>;
595	};
596
597	tmp275@49 {
598	compatible = "ti,tmp275";
599	reg = <0x49>;
600	};
601	};
602
603	&i2c6 {
604	status = "okay";
605
606	tmp275@48 {
607	compatible = "ti,tmp275";
608	reg = <0x48>;
609	};
610
611	tmp275@4a {
612	compatible = "ti,tmp275";
613	reg = <0x4a>;
614	};
615
616	tmp275@4b {
617	compatible = "ti,tmp275";
618	reg = <0x4b>;
619	};
620	};
621
622	&i2c7 {
623	status = "okay";
624
625	si7021-a20@20 {
626	compatible = "silabs,si7020";
627	reg = <0x20>;
628	};
629
630	tmp275@48 {
631	compatible = "ti,tmp275";
632	reg = <0x48>;
633	};
634
635	max31785@52 {
636	compatible = "maxim,max31785a";
637	reg = <0x52>;
638	#address-cells = <1>;
639	#size-cells = <0>;
640
641	fan@0 {
642	compatible = "pmbus-fan";
643	reg = <0>;
644	tach-pulses = <2>;
645	};
646
647	fan@1 {
648	compatible = "pmbus-fan";
649	reg = <1>;
650	tach-pulses = <2>;
651	};
652
653	fan@2 {
654	compatible = "pmbus-fan";
655	reg = <2>;
656	tach-pulses = <2>;
657	};
658
659	fan@3 {
660	compatible = "pmbus-fan";
661	reg = <3>;
662	tach-pulses = <2>;
663	};
664	};
665
666	pca0: pca9552@60 {
667	compatible = "nxp,pca9552";
668	reg = <0x60>;
669	#address-cells = <1>;
670	#size-cells = <0>;
671
672	gpio-controller;
673	#gpio-cells = <2>;
674
675	gpio@0 {
676	reg = <0>;
677	};
678
679	gpio@1 {
680	reg = <1>;
681	};
682
683	gpio@2 {
684	reg = <2>;
685	};
686
687	gpio@3 {
688	reg = <3>;
689	};
690
691	gpio@4 {
692	reg = <4>;
693	};
694
695	gpio@5 {
696	reg = <5>;
697	};
698
699	gpio@6 {
700	reg = <6>;
701	};
702
703	gpio@7 {
704	reg = <7>;
705	};
706
707	gpio@8 {
708	reg = <8>;
709	};
710
711	gpio@9 {
712	reg = <9>;
713	};
714
715	gpio@10 {
716	reg = <10>;
717	};
718
719	gpio@11 {
720	reg = <11>;
721	};
722
723	gpio@12 {
724	reg = <12>;
725	};
726
727	gpio@13 {
728	reg = <13>;
729	};
730
731	gpio@14 {
732	reg = <14>;
733	};
734
735	gpio@15 {
736	reg = <15>;
737	};
738	};
739
740	dps: dps310@76 {
741	compatible = "infineon,dps310";
742	reg = <0x76>;
743	#io-channel-cells = <0>;
744	};
745	};
746
747	&i2c8 {
748	status = "okay";
749
750	ucd90320@b {
751	compatible = "ti,ucd90160";
752	reg = <0x0b>;
753	};
754
755	ucd90320@c {
756	compatible = "ti,ucd90160";
757	reg = <0x0c>;
758	};
759
760	ucd90320@11 {
761	compatible = "ti,ucd90160";
762	reg = <0x11>;
763	};
764
765	rtc@32 {
766	compatible = "epson,rx8900";
767	reg = <0x32>;
768	};
769
770	tmp275@48 {
771	compatible = "ti,tmp275";
772	reg = <0x48>;
773	};
774
775	tmp275@4a {
776	compatible = "ti,tmp275";
777	reg = <0x4a>;
778	};
779	};
780
781	&i2c9 {
782	status = "okay";
783
784	ir35221@42 {
785	compatible = "infineon,ir35221";
786	reg = <0x42>;
787	};
788
789	ir35221@43 {
790	compatible = "infineon,ir35221";
791	reg = <0x43>;
792	};
793
794	ir35221@44 {
795	compatible = "infineon,ir35221";
796	reg = <0x44>;
797	};
798
799	tmp423a@4c {
800	compatible = "ti,tmp423";
801	reg = <0x4c>;
802	};
803
804	tmp423b@4d {
805	compatible = "ti,tmp423";
806	reg = <0x4d>;
807	};
808
809	ir35221@72 {
810	compatible = "infineon,ir35221";
811	reg = <0x72>;
812	};
813
814	ir35221@73 {
815	compatible = "infineon,ir35221";
816	reg = <0x73>;
817	};
818
819	ir35221@74 {
820	compatible = "infineon,ir35221";
821	reg = <0x74>;
822	};
823	};
824
825	&i2c10 {
826	status = "okay";
827
828	ir35221@42 {
829	compatible = "infineon,ir35221";
830	reg = <0x42>;
831	};
832
833	ir35221@43 {
834	compatible = "infineon,ir35221";
835	reg = <0x43>;
836	};
837
838	ir35221@44 {
839	compatible = "infineon,ir35221";
840	reg = <0x44>;
841	};
842
843	tmp423a@4c {
844	compatible = "ti,tmp423";
845	reg = <0x4c>;
846	};
847
848	tmp423b@4d {
849	compatible = "ti,tmp423";
850	reg = <0x4d>;
851	};
852
853	ir35221@72 {
854	compatible = "infineon,ir35221";
855	reg = <0x72>;
856	};
857
858	ir35221@73 {
859	compatible = "infineon,ir35221";
860	reg = <0x73>;
861	};
862
863	ir35221@74 {
864	compatible = "infineon,ir35221";
865	reg = <0x74>;
866	};
867	};
868
869	&i2c11 {
870	status = "okay";
871
872	tmp275@48 {
873	compatible = "ti,tmp275";
874	reg = <0x48>;
875	};
876
877	tmp275@49 {
878	compatible = "ti,tmp275";
879	reg = <0x49>;
880	};
881	};
882
883	&i2c12 {
884	status = "okay";
885	};
886
887	&i2c13 {	522	&i2c13 {
888	status = "okay";	523	status = "okay";
889		524

arch/arm/boot/dts/aspeed-bmc-opp-tacoma.dts+5−398

@@ -122,37 +122,6 @@ · 121 unmodified lines
122	};	122	};
123	};	123	};
124		124
125	&fmc {
126	status = "okay";
127	flash@0 {
128	status = "okay";
129	m25p,fast-read;
130	label = "bmc";
131	spi-max-frequency = <50000000>;
132	#include "openbmc-flash-layout-128.dtsi"
133	};
134
135	flash@1 {
136	status = "okay";
137	m25p,fast-read;
138	label = "alt-bmc";
139	spi-max-frequency = <50000000>;
140	};
141	};
142
143	&spi1 {
144	status = "okay";
145	pinctrl-names = "default";
146	pinctrl-0 = <&pinctrl_spi1_default>;
147
148	flash@0 {
149	status = "okay";
150	m25p,fast-read;
151	label = "pnor";
152	spi-max-frequency = <100000000>;
153	};
154	};
155
156	&mac2 {	125	&mac2 {
157	status = "okay";	126	status = "okay";
158	pinctrl-names = "default";	127	pinctrl-names = "default";
@@ -165,6 +134,11 @@ · 6 unmodified lines
165		134
166	&emmc {	135	&emmc {
167	status = "okay";	136	status = "okay";
		137	};
		138
		139	&fsim0 {
		140	status = "okay";
		141
168	#address-cells = <2>;	142	#address-cells = <2>;
169	#size-cells = <0>;	143	#size-cells = <0>;
170		144
@@ -820,373 +794,6 @@ · 649 unmodified lines
820	status = "okay";	794	status = "okay";
821	};	795	};
822		796
823	&i2c0 {
824	status = "okay";
825	};
826
827	&i2c1 {
828	status = "okay";
829	};
830
831	&i2c2 {
832	status = "okay";
833	};
834
835	&i2c3 {
836	status = "okay";
837
838	bmp: bmp280@77 {
839	compatible = "bosch,bmp280";
840	reg = <0x77>;
841	#io-channel-cells = <1>;
842	};
843
844	max31785@52 {
845	compatible = "maxim,max31785a";
846	reg = <0x52>;
847	#address-cells = <1>;
848	#size-cells = <0>;
849
850	fan@0 {
851	compatible = "pmbus-fan";
852	reg = <0>;
853	tach-pulses = <2>;
854	maxim,fan-rotor-input = "tach";
855	maxim,fan-pwm-freq = <25000>;
856	maxim,fan-dual-tach;
857	maxim,fan-no-watchdog;
858	maxim,fan-no-fault-ramp;
859	maxim,fan-ramp = <2>;
860	maxim,fan-fault-pin-mon;
861	};
862
863	fan@1 {
864	compatible = "pmbus-fan";
865	reg = <1>;
866	tach-pulses = <2>;
867	maxim,fan-rotor-input = "tach";
868	maxim,fan-pwm-freq = <25000>;
869	maxim,fan-dual-tach;
870	maxim,fan-no-watchdog;
871	maxim,fan-no-fault-ramp;
872	maxim,fan-ramp = <2>;
873	maxim,fan-fault-pin-mon;
874	};
875
876	fan@2 {
877	compatible = "pmbus-fan";
878	reg = <2>;
879	tach-pulses = <2>;
880	maxim,fan-rotor-input = "tach";
881	maxim,fan-pwm-freq = <25000>;
882	maxim,fan-dual-tach;
883	maxim,fan-no-watchdog;
884	maxim,fan-no-fault-ramp;
885	maxim,fan-ramp = <2>;
886	maxim,fan-fault-pin-mon;
887	};
888
889	fan@3 {
890	compatible = "pmbus-fan";
891	reg = <3>;
892	tach-pulses = <2>;
893	maxim,fan-rotor-input = "tach";
894	maxim,fan-pwm-freq = <25000>;
895	maxim,fan-dual-tach;
896	maxim,fan-no-watchdog;
897	maxim,fan-no-fault-ramp;
898	maxim,fan-ramp = <2>;
899	maxim,fan-fault-pin-mon;
900	};
901	};
902
903	dps: dps310@76 {
904	compatible = "infineon,dps310";
905	reg = <0x76>;
906	#io-channel-cells = <0>;
907	};
908
909	pca0: pca9552@60 {
910	compatible = "nxp,pca9552";
911	reg = <0x60>;
912	#address-cells = <1>;
913	#size-cells = <0>;
914
915	gpio-controller;
916	#gpio-cells = <2>;
917
918	gpio@0 {
919	reg = <0>;
920	type = <PCA955X_TYPE_GPIO>;
921	};
922
923	gpio@1 {
924	reg = <1>;
925	type = <PCA955X_TYPE_GPIO>;
926	};
927
928	gpio@2 {
929	reg = <2>;
930	type = <PCA955X_TYPE_GPIO>;
931	};
932
933	gpio@3 {
934	reg = <3>;
935	type = <PCA955X_TYPE_GPIO>;
936	};
937
938	gpio@4 {
939	reg = <4>;
940	type = <PCA955X_TYPE_GPIO>;
941	};
942
943	gpio@5 {
944	reg = <5>;
945	type = <PCA955X_TYPE_GPIO>;
946	};
947
948	gpio@6 {
949	reg = <6>;
950	type = <PCA955X_TYPE_GPIO>;
951	};
952
953	gpio@7 {
954	reg = <7>;
955	type = <PCA955X_TYPE_GPIO>;
956	};
957
958	gpio@8 {
959	reg = <8>;
960	type = <PCA955X_TYPE_GPIO>;
961	};
962
963	gpio@9 {
964	reg = <9>;
965	type = <PCA955X_TYPE_GPIO>;
966	};
967
968	gpio@10 {
969	reg = <10>;
970	type = <PCA955X_TYPE_GPIO>;
971	};
972
973	gpio@11 {
974	reg = <11>;
975	type = <PCA955X_TYPE_GPIO>;
976	};
977
978	gpio@12 {
979	reg = <12>;
980	type = <PCA955X_TYPE_GPIO>;
981	};
982
983	gpio@13 {
984	reg = <13>;
985	type = <PCA955X_TYPE_GPIO>;
986	};
987
988	gpio@14 {
989	reg = <14>;
990	type = <PCA955X_TYPE_GPIO>;
991	};
992
993	gpio@15 {
994	reg = <15>;
995	type = <PCA955X_TYPE_GPIO>;
996	};
997	};
998
999	power-supply@68 {
1000	compatible = "ibm,cffps1";
1001	reg = <0x68>;
1002	};
1003
1004	power-supply@69 {
1005	compatible = "ibm,cffps1";
1006	reg = <0x69>;
1007	};
1008	};
1009
1010	&i2c4 {
1011	status = "okay";
1012
1013	tmp423a@4c {
1014	compatible = "ti,tmp423";
1015	reg = <0x4c>;
1016	};
1017
1018	ir35221@70 {
1019	compatible = "infineon,ir35221";
1020	reg = <0x70>;
1021	};
1022
1023	ir35221@71 {
1024	compatible = "infineon,ir35221";
1025	reg = <0x71>;
1026	};
1027	};
1028
1029	&i2c5 {
1030	status = "okay";
1031
1032	tmp423a@4c {
1033	compatible = "ti,tmp423";
1034	reg = <0x4c>;
1035	};
1036
1037	ir35221@70 {
1038	compatible = "infineon,ir35221";
1039	reg = <0x70>;
1040	};
1041
1042	ir35221@71 {
1043	compatible = "infineon,ir35221";
1044	reg = <0x71>;
1045	};
1046	};
1047
1048	&i2c7 {
1049	status = "okay";
1050	};
1051
1052	&i2c9 {
1053	status = "okay";
1054
1055	tmp275@4a {
1056	compatible = "ti,tmp275";
1057	reg = <0x4a>;
1058	};
1059	};
1060
1061	&i2c10 {
1062	status = "okay";
1063	};
1064
1065	&i2c11 {
1066	status = "okay";
1067
1068	pca9552: pca9552@60 {
1069	compatible = "nxp,pca9552";
1070	reg = <0x60>;
1071	#address-cells = <1>;
1072	#size-cells = <0>;
1073	gpio-controller;
1074	#gpio-cells = <2>;
1075
1076	gpio-line-names = "PS_SMBUS_RESET_N", "APSS_RESET_N",
1077	"GPU0_TH_OVERT_N_BUFF", "GPU1_TH_OVERT_N_BUFF",
1078	"GPU2_TH_OVERT_N_BUFF", "GPU3_TH_OVERT_N_BUFF",
1079	"GPU4_TH_OVERT_N_BUFF", "GPU5_TH_OVERT_N_BUFF",
1080	"GPU0_PWR_GOOD_BUFF", "GPU1_PWR_GOOD_BUFF",
1081	"GPU2_PWR_GOOD_BUFF", "GPU3_PWR_GOOD_BUFF",
1082	"GPU4_PWR_GOOD_BUFF", "GPU5_PWR_GOOD_BUFF",
1083	"12V_BREAKER_FLT_N", "THROTTLE_UNLATCHED_N";
1084
1085	gpio@0 {
1086	reg = <0>;
1087	type = <PCA955X_TYPE_GPIO>;
1088	};
1089
1090	gpio@1 {
1091	reg = <1>;
1092	type = <PCA955X_TYPE_GPIO>;
1093	};
1094
1095	gpio@2 {
1096	reg = <2>;
1097	type = <PCA955X_TYPE_GPIO>;
1098	};
1099
1100	gpio@3 {
1101	reg = <3>;
1102	type = <PCA955X_TYPE_GPIO>;
1103	};
1104
1105	gpio@4 {
1106	reg = <4>;
1107	type = <PCA955X_TYPE_GPIO>;
1108	};
1109
1110	gpio@5 {
1111	reg = <5>;
1112	type = <PCA955X_TYPE_GPIO>;
1113	};
1114
1115	gpio@6 {
1116	reg = <6>;
1117	type = <PCA955X_TYPE_GPIO>;
1118	};
1119
1120	gpio@7 {
1121	reg = <7>;
1122	type = <PCA955X_TYPE_GPIO>;
1123	};
1124
1125	gpio@8 {
1126	reg = <8>;
1127	type = <PCA955X_TYPE_GPIO>;
1128	};
1129
1130	gpio@9 {
1131	reg = <9>;
1132	type = <PCA955X_TYPE_GPIO>;
1133	};
1134
1135	gpio@10 {
1136	reg = <10>;
1137	type = <PCA955X_TYPE_GPIO>;
1138	};
1139
1140	gpio@11 {
1141	reg = <11>;
1142	type = <PCA955X_TYPE_GPIO>;
1143	};
1144
1145	gpio@12 {
1146	reg = <12>;
1147	type = <PCA955X_TYPE_GPIO>;
1148	};
1149
1150	gpio@13 {
1151	reg = <13>;
1152	type = <PCA955X_TYPE_GPIO>;
1153	};
1154
1155	gpio@14 {
1156	reg = <14>;
1157	type = <PCA955X_TYPE_GPIO>;
1158	};
1159
1160	gpio@15 {
1161	reg = <15>;
1162	type = <PCA955X_TYPE_GPIO>;
1163	};
1164	};
1165
1166	rtc@32 {
1167	compatible = "epson,rx8900";
1168	reg = <0x32>;
1169	};
1170
1171	eeprom@51 {
1172	compatible = "atmel,24c64";
1173	reg = <0x51>;
1174	};
1175
1176	ucd90160@64 {
1177	compatible = "ti,ucd90160";
1178	reg = <0x64>;
1179	};
1180	};
1181
1182	&i2c12 {
1183	status = "okay";
1184	};
1185
1186	&i2c13 {
1187	status = "okay";
1188	};
1189
1190	&pinctrl {	797	&pinctrl {
1191	/* Hog these as no driver is probed for the entire LPC block */	798	/* Hog these as no driver is probed for the entire LPC block */
1192	pinctrl-names = "default";	799	pinctrl-names = "default";

arch/arm/boot/dts/aspeed-g6.dtsi+19−20

 				spi-max-frequency = <50000000>;
 				status = "disabled";
 			};
-			fsim0: fsi@1e79b000 {
-				compatible = "aspeed,ast2600-fsi-master", "fsi-master";
-				reg = <0x1e79b000 0x94>;
-				interrupts = <GIC_SPI 100 IRQ_TYPE_LEVEL_HIGH>;
-				pinctrl-names = "default";
-				pinctrl-0 = <&pinctrl_fsi1_default>;
-				clocks = <&syscon ASPEED_CLK_GATE_FSICLK>;
-				status = "disabled";
-			};
-			fsim1: fsi@1e79b100 {
-				compatible = "aspeed,ast2600-fsi-master", "fsi-master";
-				reg = <0x1e79b100 0x94>;
-				interrupts = <GIC_SPI 101 IRQ_TYPE_LEVEL_HIGH>;
-				pinctrl-names = "default";
-				pinctrl-0 = <&pinctrl_fsi2_default>;
-				clocks = <&syscon ASPEED_CLK_GATE_FSICLK>;
-				status = "disabled";
-			};
 		};
 		mdio0: mdio@1e650000 {
 				ranges = <0 0x1e78a000 0x1000>;
 			};
+			fsim0: fsi@1e79b000 {
+				compatible = "aspeed,ast2600-fsi-master", "fsi-master";
+				reg = <0x1e79b000 0x94>;
+				interrupts = <GIC_SPI 100 IRQ_TYPE_LEVEL_HIGH>;
+				pinctrl-names = "default";
+				pinctrl-0 = <&pinctrl_fsi1_default>;
+				clocks = <&syscon ASPEED_CLK_GATE_FSICLK>;
+				status = "disabled";
+			};
+			fsim1: fsi@1e79b100 {
+				compatible = "aspeed,ast2600-fsi-master", "fsi-master";
+				reg = <0x1e79b100 0x94>;
+				interrupts = <GIC_SPI 101 IRQ_TYPE_LEVEL_HIGH>;
+				pinctrl-names = "default";
+				pinctrl-0 = <&pinctrl_fsi2_default>;
+				clocks = <&syscon ASPEED_CLK_GATE_FSICLK>;
+				status = "disabled";
+			};
 		};
 	};
 };

arch/arm/boot/dts/imx6dl-icore-mipi.dts+1−1

@@ -8,7 +8,7 @@ · 7 unmodified lines
8	/dts-v1/;	8	/dts-v1/;
9		9
10	#include "imx6dl.dtsi"	10	#include "imx6dl.dtsi"
11	#include "imx6qdl-icore.dtsi"	11	#include "imx6qdl-icore-1.5.dtsi"
12		12
13	/ {	13	/ {
14	model = "Engicam i.CoreM6 DualLite/Solo MIPI Starter Kit";	14	model = "Engicam i.CoreM6 DualLite/Solo MIPI Starter Kit";

arch/arm/boot/dts/imx6q-dhcom-pdk2.dts+1−1

@@ -63,7 +63,7 @@ · 62 unmodified lines
63	#sound-dai-cells = <0>;	63	#sound-dai-cells = <0>;
64	clocks = <&clk_ext_audio_codec>;	64	clocks = <&clk_ext_audio_codec>;
65	VDDA-supply = <&reg_3p3v>;	65	VDDA-supply = <&reg_3p3v>;
66	VDDIO-supply = <&reg_3p3v>;	66	VDDIO-supply = <&sw2_reg>;
67	};	67	};
68	};	68	};
69		69

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

@@ -204,7 +204,7 @@ · 203 unmodified lines
204	};	204	};
205		205
206	rtc@56 {	206	rtc@56 {
207	compatible = "rv3029c2";	207	compatible = "microcrystal,rv3029";
208	pinctrl-names = "default";	208	pinctrl-names = "default";
209	pinctrl-0 = <&pinctrl_rtc_hw300>;	209	pinctrl-0 = <&pinctrl_rtc_hw300>;
210	reg = <0x56>;	210	reg = <0x56>;

arch/arm/boot/dts/imx6qdl-sabresd.dtsi+0−4

 	vin-supply = <&vgen5_reg>;
 };
-&reg_vdd3p0 {
-	vin-supply = <&sw2_reg>;
-};
 &reg_vdd2p5 {
 	vin-supply = <&vgen5_reg>;
 };

arch/arm/boot/dts/imx6sl-evk.dts+0−4

 	vin-supply = <&sw2_reg>;
 };
-&reg_vdd3p0 {
-	vin-supply = <&sw2_reg>;
-};
 &reg_vdd2p5 {
 	vin-supply = <&sw2_reg>;
 };

arch/arm/boot/dts/imx6sll-evk.dts+0−4

 	status = "okay";
 };
-&reg_3p0 {
-	vin-supply = <&sw2_reg>;
-};
 &snvs_poweroff {
 	status = "okay";
 };

arch/arm/boot/dts/imx6sx-sdb-reva.dts+0−4

 	vin-supply = <&vgen6_reg>;
 };
-&reg_vdd3p0 {
-	vin-supply = <&sw2_reg>;
-};
 &reg_vdd2p5 {
 	vin-supply = <&vgen6_reg>;
 };

arch/arm/boot/dts/imx6sx-sdb.dts+0−4

 	vin-supply = <&vgen6_reg>;
 };
-&reg_vdd3p0 {
-	vin-supply = <&sw2_reg>;
-};
 &reg_vdd2p5 {
 	vin-supply = <&vgen6_reg>;
 };

arch/arm/boot/dts/imx7s-colibri.dtsi+4−0

@@ -49,3 +49,7 @@ · 48 unmodified lines
49	reg = <0x80000000 0x10000000>;	49	reg = <0x80000000 0x10000000>;
50	};	50	};
51	};	51	};
		52
		53	&gpmi {
		54	status = "okay";
		55	};

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

@@ -37,10 +37,10 @@ · 36 unmodified lines
37	#address-cells = <1>;	37	#address-cells = <1>;
38	#size-cells = <0>;	38	#size-cells = <0>;
39		39
40	cpu0: cpu@0 {	40	cpu0: cpu@f00 {
41	compatible = "arm,cortex-a7";	41	compatible = "arm,cortex-a7";
42	device_type = "cpu";	42	device_type = "cpu";
43	reg = <0>;	43	reg = <0xf00>;
44	};	44	};
45	};	45	};
46		46

arch/arm/boot/dts/meson8.dtsi+1−1

@@ -253,7 +253,7 @@ · 252 unmodified lines
253	&aobus {	253	&aobus {
254	pmu: pmu@e0 {	254	pmu: pmu@e0 {
255	compatible = "amlogic,meson8-pmu", "syscon";	255	compatible = "amlogic,meson8-pmu", "syscon";
256	reg = <0xe0 0x8>;	256	reg = <0xe0 0x18>;
257	};	257	};
258		258
259	pinctrl_aobus: pinctrl@84 {	259	pinctrl_aobus: pinctrl@84 {

arch/arm/boot/dts/mmp3.dtsi+6−6

@@ -356,7 +356,7 @@ · 355 unmodified lines
356		356
357	twsi1: i2c@d4011000 {	357	twsi1: i2c@d4011000 {
358	compatible = "mrvl,mmp-twsi";	358	compatible = "mrvl,mmp-twsi";
359	reg = <0xd4011000 0x1000>;	359	reg = <0xd4011000 0x70>;
360	interrupts = <GIC_SPI 7 IRQ_TYPE_LEVEL_HIGH>;	360	interrupts = <GIC_SPI 7 IRQ_TYPE_LEVEL_HIGH>;
361	clocks = <&soc_clocks MMP2_CLK_TWSI0>;	361	clocks = <&soc_clocks MMP2_CLK_TWSI0>;
362	resets = <&soc_clocks MMP2_CLK_TWSI0>;	362	resets = <&soc_clocks MMP2_CLK_TWSI0>;
@@ -368,7 +368,7 @@ · 5 unmodified lines
368		368
369	twsi2: i2c@d4031000 {	369	twsi2: i2c@d4031000 {
370	compatible = "mrvl,mmp-twsi";	370	compatible = "mrvl,mmp-twsi";
371	reg = <0xd4031000 0x1000>;	371	reg = <0xd4031000 0x70>;
372	interrupt-parent = <&twsi_mux>;	372	interrupt-parent = <&twsi_mux>;
373	interrupts = <0>;	373	interrupts = <0>;
374	clocks = <&soc_clocks MMP2_CLK_TWSI1>;	374	clocks = <&soc_clocks MMP2_CLK_TWSI1>;
@@ -380,7 +380,7 @@ · 5 unmodified lines
380		380
381	twsi3: i2c@d4032000 {	381	twsi3: i2c@d4032000 {
382	compatible = "mrvl,mmp-twsi";	382	compatible = "mrvl,mmp-twsi";
383	reg = <0xd4032000 0x1000>;	383	reg = <0xd4032000 0x70>;
384	interrupt-parent = <&twsi_mux>;	384	interrupt-parent = <&twsi_mux>;
385	interrupts = <1>;	385	interrupts = <1>;
386	clocks = <&soc_clocks MMP2_CLK_TWSI2>;	386	clocks = <&soc_clocks MMP2_CLK_TWSI2>;
@@ -392,7 +392,7 @@ · 5 unmodified lines
392		392
393	twsi4: i2c@d4033000 {	393	twsi4: i2c@d4033000 {
394	compatible = "mrvl,mmp-twsi";	394	compatible = "mrvl,mmp-twsi";
395	reg = <0xd4033000 0x1000>;	395	reg = <0xd4033000 0x70>;
396	interrupt-parent = <&twsi_mux>;	396	interrupt-parent = <&twsi_mux>;
397	interrupts = <2>;	397	interrupts = <2>;
398	clocks = <&soc_clocks MMP2_CLK_TWSI3>;	398	clocks = <&soc_clocks MMP2_CLK_TWSI3>;
@@ -405,7 +405,7 @@ · 6 unmodified lines
405		405
406	twsi5: i2c@d4033800 {	406	twsi5: i2c@d4033800 {
407	compatible = "mrvl,mmp-twsi";	407	compatible = "mrvl,mmp-twsi";
408	reg = <0xd4033800 0x1000>;	408	reg = <0xd4033800 0x70>;
409	interrupt-parent = <&twsi_mux>;	409	interrupt-parent = <&twsi_mux>;
410	interrupts = <3>;	410	interrupts = <3>;
411	clocks = <&soc_clocks MMP2_CLK_TWSI4>;	411	clocks = <&soc_clocks MMP2_CLK_TWSI4>;
@@ -417,7 +417,7 @@ · 5 unmodified lines
417		417
418	twsi6: i2c@d4034000 {	418	twsi6: i2c@d4034000 {
419	compatible = "mrvl,mmp-twsi";	419	compatible = "mrvl,mmp-twsi";
420	reg = <0xd4034000 0x1000>;	420	reg = <0xd4034000 0x70>;
421	interrupt-parent = <&twsi_mux>;	421	interrupt-parent = <&twsi_mux>;
422	interrupts = <4>;	422	interrupts = <4>;
423	clocks = <&soc_clocks MMP2_CLK_TWSI5>;	423	clocks = <&soc_clocks MMP2_CLK_TWSI5>;

arch/arm/boot/dts/sun8i-a83t-cubietruck-plus.dts+1−1

@@ -101,7 +101,7 @@ · 100 unmodified lines
101	initial-mode = <1>; /* initialize in HUB mode */	101	initial-mode = <1>; /* initialize in HUB mode */
102	disabled-ports = <1>;	102	disabled-ports = <1>;
103	intn-gpios = <&pio 7 5 GPIO_ACTIVE_HIGH>; /* PH5 */	103	intn-gpios = <&pio 7 5 GPIO_ACTIVE_HIGH>; /* PH5 */
104	reset-gpios = <&pio 4 16 GPIO_ACTIVE_HIGH>; /* PE16 */	104	reset-gpios = <&pio 4 16 GPIO_ACTIVE_LOW>; /* PE16 */
105	connect-gpios = <&pio 4 17 GPIO_ACTIVE_HIGH>; /* PE17 */	105	connect-gpios = <&pio 4 17 GPIO_ACTIVE_HIGH>; /* PE17 */
106	refclk-frequency = <19200000>;	106	refclk-frequency = <19200000>;
107	};	107	};

arch/arm/mach-davinci/Kconfig+1−0

@@ -9,6 +9,7 @@ menuconfig ARCH_DAVINCI · 8 unmodified lines
9	select PM_GENERIC_DOMAINS if PM	9	select PM_GENERIC_DOMAINS if PM
10	select PM_GENERIC_DOMAINS_OF if PM && OF	10	select PM_GENERIC_DOMAINS_OF if PM && OF
11	select REGMAP_MMIO	11	select REGMAP_MMIO
		12	select RESET_CONTROLLER
12	select HAVE_IDE	13	select HAVE_IDE
13	select PINCTRL_SINGLE	14	select PINCTRL_SINGLE
14		15

arch/arm/mach-mmp/time.c+1−1

@@ -207,7 +207,7 @@ static int __init mmp_dt_init_timer(struct device_node *np) · 206 unmodified lines
207	ret = clk_prepare_enable(clk);	207	ret = clk_prepare_enable(clk);
208	if (ret)	208	if (ret)
209	return ret;	209	return ret;
210	rate = clk_get_rate(clk) / 2;	210	rate = clk_get_rate(clk);
211	} else if (cpu_is_pj4()) {	211	} else if (cpu_is_pj4()) {
212	rate = 6500000;	212	rate = 6500000;
213	} else {	213	} else {

arch/arm/mach-omap2/Kconfig+2−1

 	bool
 	select ARCH_HAS_BANDGAP
 	select ARCH_HAS_HOLES_MEMORYMODEL
+	select ARCH_HAS_RESET_CONTROLLER
 	select ARCH_OMAP
 	select CLKSRC_MMIO
 	select GENERIC_IRQ_CHIP
 	select OMAP_DM_TIMER
 	select OMAP_GPMC
 	select PINCTRL
+	select RESET_CONTROLLER
 	select SOC_BUS
 	select TI_SYSC
 	select OMAP_IRQCHIP
 	select CLKSRC_TI_32K
-	select ARCH_HAS_RESET_CONTROLLER
 	help
 	  Systems based on OMAP2, OMAP3, OMAP4 or OMAP5

arch/arm/mach-omap2/pdata-quirks.c+5−1

 static struct clockdomain *ti_sysc_find_one_clockdomain(struct clk *clk)
 {
+	struct clk_hw *hw = __clk_get_hw(clk);
 	struct clockdomain *clkdm = NULL;
 	struct clk_hw_omap *hwclk;
-	hwclk = to_clk_hw_omap(__clk_get_hw(clk));
+	hwclk = to_clk_hw_omap(hw);
+	if (!omap2_clk_is_hw_omap(hw))
+		return NULL;
 	if (hwclk && hwclk->clkdm_name)
 		clkdm = clkdm_lookup(hwclk->clkdm_name);

arch/arm64/boot/dts/allwinner/sun50i-a64-olinuxino-emmc.dts+1−1

@@ -15,7 +15,7 @@ · 14 unmodified lines
15	pinctrl-names = "default";	15	pinctrl-names = "default";
16	pinctrl-0 = <&mmc2_pins>;	16	pinctrl-0 = <&mmc2_pins>;
17	vmmc-supply = <&reg_dcdc1>;	17	vmmc-supply = <&reg_dcdc1>;
18	vqmmc-supply = <&reg_dcdc1>;	18	vqmmc-supply = <&reg_eldo1>;
19	bus-width = <8>;	19	bus-width = <8>;
20	non-removable;	20	non-removable;
21	cap-mmc-hw-reset;	21	cap-mmc-hw-reset;

arch/arm64/boot/dts/allwinner/sun50i-a64-olinuxino.dts+1−1

@@ -140,7 +140,7 @@ · 139 unmodified lines
140	&mmc1 {	140	&mmc1 {
141	pinctrl-names = "default";	141	pinctrl-names = "default";
142	pinctrl-0 = <&mmc1_pins>;	142	pinctrl-0 = <&mmc1_pins>;
143	vmmc-supply = <&reg_aldo2>;	143	vmmc-supply = <&reg_dcdc1>;
144	vqmmc-supply = <&reg_dldo4>;	144	vqmmc-supply = <&reg_dldo4>;
145	mmc-pwrseq = <&wifi_pwrseq>;	145	mmc-pwrseq = <&wifi_pwrseq>;
146	bus-width = <4>;	146	bus-width = <4>;

arch/arm64/boot/dts/altera/socfpga_stratix10.dtsi+4−4

@@ -61,10 +61,10 @@ · 60 unmodified lines
61		61
62	pmu {	62	pmu {
63	compatible = "arm,armv8-pmuv3";	63	compatible = "arm,armv8-pmuv3";
64	interrupts = <0 120 8>,	64	interrupts = <0 170 4>,
65	<0 121 8>,	65	<0 171 4>,
66	<0 122 8>,	66	<0 172 4>,
67	<0 123 8>;	67	<0 173 4>;
68	interrupt-affinity = <&cpu0>,	68	interrupt-affinity = <&cpu0>,
69	<&cpu1>,	69	<&cpu1>,
70	<&cpu2>,	70	<&cpu2>,

arch/arm64/boot/dts/amlogic/meson-sm1-sei610.dts+26−2

 	};
 	gpio-keys {
-		compatible = "gpio-keys-polled";
+		compatible = "gpio-keys";
-		poll-interval = <100>;
 		key1 {
 			label = "A";
 			linux,code = <BTN_0>;
 			gpios = <&gpio GPIOH_6 GPIO_ACTIVE_LOW>;
+			interrupt-parent = <&gpio_intc>;
+			interrupts = <34 IRQ_TYPE_EDGE_BOTH>;
 		};
 		key2 {
 			label = "B";
 			linux,code = <BTN_1>;
 			gpios = <&gpio GPIOH_7 GPIO_ACTIVE_LOW>;
+			interrupt-parent = <&gpio_intc>;
+			interrupts = <35 IRQ_TYPE_EDGE_BOTH>;
 		};
 		key3 {
 			label = "C";
 			linux,code = <BTN_2>;
 			gpios = <&gpio_ao GPIOAO_2 GPIO_ACTIVE_LOW>;
+			interrupt-parent = <&gpio_intc>;
+			interrupts = <2 IRQ_TYPE_EDGE_BOTH>;
+		};
+		mic_mute {
+			label = "MicMute";
+			linux,code = <SW_MUTE_DEVICE>;
+			linux,input-type = <EV_SW>;
+			gpios = <&gpio_ao GPIOE_2 GPIO_ACTIVE_LOW>;
+			interrupt-parent = <&gpio_intc>;
+			interrupts = <99 IRQ_TYPE_EDGE_BOTH>;
+		};
+		power_key {
+			label = "PowerKey";
+			linux,code = <KEY_POWER>;
+			gpios = <&gpio_ao GPIOAO_3 GPIO_ACTIVE_LOW>;
+			interrupt-parent = <&gpio_intc>;
+			interrupts = <3 IRQ_TYPE_EDGE_BOTH>;
 		};
 	};
 	bluetooth {
 		compatible = "brcm,bcm43438-bt";
+		interrupt-parent = <&gpio_intc>;
+		interrupts = <95 IRQ_TYPE_LEVEL_HIGH>;
 		shutdown-gpios = <&gpio GPIOX_17 GPIO_ACTIVE_HIGH>;
 		max-speed = <2000000>;
 		clocks = <&wifi32k>;

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

@@ -175,7 +175,7 @@ · 174 unmodified lines
175	dcfg: syscon@1e00000 {	175	dcfg: syscon@1e00000 {
176	compatible = "fsl,ls1028a-dcfg", "syscon";	176	compatible = "fsl,ls1028a-dcfg", "syscon";
177	reg = <0x0 0x1e00000 0x0 0x10000>;	177	reg = <0x0 0x1e00000 0x0 0x10000>;
178	big-endian;	178	little-endian;
179	};	179	};
180		180
181	rst: syscon@1e60000 {	181	rst: syscon@1e60000 {

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

@@ -740,7 +740,7 @@ · 739 unmodified lines
740	reg = <0x30bd0000 0x10000>;	740	reg = <0x30bd0000 0x10000>;
741	interrupts = <GIC_SPI 2 IRQ_TYPE_LEVEL_HIGH>;	741	interrupts = <GIC_SPI 2 IRQ_TYPE_LEVEL_HIGH>;
742	clocks = <&clk IMX8MM_CLK_SDMA1_ROOT>,	742	clocks = <&clk IMX8MM_CLK_SDMA1_ROOT>,
743	<&clk IMX8MM_CLK_SDMA1_ROOT>;	743	<&clk IMX8MM_CLK_AHB>;
744	clock-names = "ipg", "ahb";	744	clock-names = "ipg", "ahb";
745	#dma-cells = <3>;	745	#dma-cells = <3>;
746	fsl,sdma-ram-script-name = "imx/sdma/sdma-imx7d.bin";	746	fsl,sdma-ram-script-name = "imx/sdma/sdma-imx7d.bin";

arch/arm64/boot/dts/freescale/imx8mq-librem5-devkit.dts+1−1

@@ -421,7 +421,7 @@ · 420 unmodified lines
421	pinctrl-names = "default";	421	pinctrl-names = "default";
422	pinctrl-0 = <&pinctrl_imu>;	422	pinctrl-0 = <&pinctrl_imu>;
423	interrupt-parent = <&gpio3>;	423	interrupt-parent = <&gpio3>;
424	interrupts = <19 IRQ_TYPE_LEVEL_LOW>;	424	interrupts = <19 IRQ_TYPE_LEVEL_HIGH>;
425	vdd-supply = <&reg_3v3_p>;	425	vdd-supply = <&reg_3v3_p>;
426	vddio-supply = <&reg_3v3_p>;	426	vddio-supply = <&reg_3v3_p>;
427	};	427	};

arch/arm64/boot/dts/intel/socfpga_agilex.dtsi+4−4

@@ -60,10 +60,10 @@ · 59 unmodified lines
60		60
61	pmu {	61	pmu {
62	compatible = "arm,armv8-pmuv3";	62	compatible = "arm,armv8-pmuv3";
63	interrupts = <0 120 8>,	63	interrupts = <0 170 4>,
64	<0 121 8>,	64	<0 171 4>,
65	<0 122 8>,	65	<0 172 4>,
66	<0 123 8>;	66	<0 173 4>;
67	interrupt-affinity = <&cpu0>,	67	interrupt-affinity = <&cpu0>,
68	<&cpu1>,	68	<&cpu1>,
69	<&cpu2>,	69	<&cpu2>,

arch/arm64/boot/dts/rockchip/rk3328-a1.dts+2−1

@@ -49,7 +49,8 @@ · 48 unmodified lines
49		49
50	ir-receiver {	50	ir-receiver {
51	compatible = "gpio-ir-receiver";	51	compatible = "gpio-ir-receiver";
52	gpios = <&gpio2 RK_PA2 GPIO_ACTIVE_HIGH>;	52	gpios = <&gpio2 RK_PA2 GPIO_ACTIVE_LOW>;
		53	linux,rc-map-name = "rc-beelink-gs1";
53	};	54	};
54	};	55	};
55		56

arch/nds32/include/asm/cacheflush.h+7−4

 #define PG_dcache_dirty PG_arch_1
 void flush_icache_range(unsigned long start, unsigned long end);
+#define flush_icache_range flush_icache_range
 void flush_icache_page(struct vm_area_struct *vma, struct page *page);
+#define flush_icache_page flush_icache_page
 #ifdef CONFIG_CPU_CACHE_ALIASING
 void flush_cache_mm(struct mm_struct *mm);
 void flush_cache_dup_mm(struct mm_struct *mm);
 #define flush_dcache_mmap_unlock(mapping) xa_unlock_irq(&(mapping)->i_pages)
 #else
-#include <asm-generic/cacheflush.h>
-#undef flush_icache_range
-#undef flush_icache_page
-#undef flush_icache_user_range
 void flush_icache_user_range(struct vm_area_struct *vma, struct page *page,
 	                     unsigned long addr, int len);
+#define flush_icache_user_range flush_icache_user_range
+#include <asm-generic/cacheflush.h>
 #endif
 #endif /* __NDS32_CACHEFLUSH_H__ */

arch/nds32/include/asm/pgtable.h+1−1

@@ -195,7 +195,7 @@ extern void paging_init(void); · 194 unmodified lines
195	#define pte_unmap(pte) do { } while (0)	195	#define pte_unmap(pte) do { } while (0)
196	#define pte_unmap_nested(pte) do { } while (0)	196	#define pte_unmap_nested(pte) do { } while (0)
197		197
198	#define pmd_off_k(address) pmd_offset(pgd_offset_k(address), address)	198	#define pmd_off_k(address) pmd_offset(pud_offset(p4d_offset(pgd_offset_k(address), (address)), (address)), (address))
199		199
200	#define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)	200	#define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
201	/*	201	/*

arch/parisc/kernel/drivers.c+2−2

@@ -889,8 +889,8 @@ static void print_parisc_device(struct parisc_device *dev) · 888 unmodified lines
889	static int count;	889	static int count;
890		890
891	print_pa_hwpath(dev, hw_path);	891	print_pa_hwpath(dev, hw_path);
892	pr_info("%d. %s at 0x%px [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }",	892	pr_info("%d. %s at %pap [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }",
893	++count, dev->name, (void*) dev->hpa.start, hw_path, dev->id.hw_type,	893	++count, dev->name, &(dev->hpa.start), hw_path, dev->id.hw_type,
894	dev->id.hversion_rev, dev->id.hversion, dev->id.sversion);	894	dev->id.hversion_rev, dev->id.hversion, dev->id.sversion);
895		895
896	if (dev->num_addrs) {	896	if (dev->num_addrs) {

arch/parisc/mm/init.c+1−1

@@ -401,7 +401,7 @@ static void __init map_pages(unsigned long start_vaddr, · 400 unmodified lines
401	pmd = (pmd_t *) __pa(pmd);	401	pmd = (pmd_t *) __pa(pmd);
402	}	402	}
403		403
404	pgd_populate(NULL, pg_dir, __va(pmd));	404	pud_populate(NULL, (pud_t *)pg_dir, __va(pmd));
405	#endif	405	#endif
406	pg_dir++;	406	pg_dir++;
407		407

arch/riscv/include/asm/asm-prototypes.h+4−0

@@ -5,4 +5,8 @@ · 4 unmodified lines
5	#include <linux/ftrace.h>	5	#include <linux/ftrace.h>
6	#include <asm-generic/asm-prototypes.h>	6	#include <asm-generic/asm-prototypes.h>
7		7
		8	long long __lshrti3(long long a, int b);
		9	long long __ashrti3(long long a, int b);
		10	long long __ashlti3(long long a, int b);
		11
8	#endif /* _ASM_RISCV_PROTOTYPES_H */	12	#endif /* _ASM_RISCV_PROTOTYPES_H */

arch/riscv/kernel/head.S+10−6

 #ifdef CONFIG_SMP
 	li t0, CONFIG_NR_CPUS
-	bgeu a0, t0, .Lsecondary_park
+	blt a0, t0, .Lgood_cores
+	tail .Lsecondary_park
+.Lgood_cores:
 #endif
 	/* Pick one hart to run the main boot sequence */
 	tail smp_callin
 #endif
-.align 2
-.Lsecondary_park:
-	/* We lack SMP support or have too many harts, so park this hart */
-	wfi
-	j .Lsecondary_park
 END(_start)
 #ifdef CONFIG_RISCV_M_MODE
 END(reset_regs)
 #endif /* CONFIG_RISCV_M_MODE */
+.section ".text", "ax",@progbits
+.align 2
+.Lsecondary_park:
+	/* We lack SMP support or have too many harts, so park this hart */
+	wfi
+	j .Lsecondary_park
 __PAGE_ALIGNED_BSS
 	/* Empty zero page */
 	.balign PAGE_SIZE

arch/riscv/kernel/vdso/Makefile+2−1

@@ -58,7 +58,8 @@ quiet_cmd_vdsold = VDSOLD $@ · 57 unmodified lines
58	cmd_vdsold = $(CC) $(KBUILD_CFLAGS) $(call cc-option, -no-pie) -nostdlib -nostartfiles $(SYSCFLAGS_$(@F)) \	58	cmd_vdsold = $(CC) $(KBUILD_CFLAGS) $(call cc-option, -no-pie) -nostdlib -nostartfiles $(SYSCFLAGS_$(@F)) \
59	-Wl,-T,$(filter-out FORCE,$^) -o $@.tmp && \	59	-Wl,-T,$(filter-out FORCE,$^) -o $@.tmp && \
60	$(CROSS_COMPILE)objcopy \	60	$(CROSS_COMPILE)objcopy \
61	$(patsubst %, -G __vdso_%, $(vdso-syms)) $@.tmp $@	61	$(patsubst %, -G __vdso_%, $(vdso-syms)) $@.tmp $@ && \
		62	rm $@.tmp
62		63
63	# install commands for the unstripped file	64	# install commands for the unstripped file
64	quiet_cmd_vdso_install = INSTALL $@	65	quiet_cmd_vdso_install = INSTALL $@

arch/riscv/lib/tishift.S+57−18

@@ -4,34 +4,73 @@ · 3 unmodified lines
4	*/	4	*/
5		5
6	#include <linux/linkage.h>	6	#include <linux/linkage.h>
		7	#include <asm-generic/export.h>
7		8
8	ENTRY(__lshrti3)	9	SYM_FUNC_START(__lshrti3)
9	beqz a2, .L1	10	beqz a2, .L1
10	li a5,64	11	li a5,64
11	sub a5,a5,a2	12	sub a5,a5,a2
12	addi sp,sp,-16
13	sext.w a4,a5	13	sext.w a4,a5
14	blez a5, .L2	14	blez a5, .L2
15	sext.w a2,a2	15	sext.w a2,a2
16	sll a4,a1,a4
17	srl a0,a0,a2	16	srl a0,a0,a2
18	srl a1,a1,a2	17	sll a4,a1,a4
		18	srl a2,a1,a2
19	or a0,a0,a4	19	or a0,a0,a4
20	sd a1,8(sp)	20	mv a1,a2
21	sd a0,0(sp)
22	ld a0,0(sp)
23	ld a1,8(sp)
24	addi sp,sp,16
25	ret
26	.L1:	21	.L1:
27	ret	22	ret
28	.L2:	23	.L2:
29	negw a4,a4	24	negw a0,a4
30	srl a1,a1,a4	25	li a2,0
31	sd a1,0(sp)	26	srl a0,a1,a0
32	sd zero,8(sp)	27	mv a1,a2
33	ld a0,0(sp)	28	ret
34	ld a1,8(sp)	29	SYM_FUNC_END(__lshrti3)
35	addi sp,sp,16	30	EXPORT_SYMBOL(__lshrti3)
		31
		32	SYM_FUNC_START(__ashrti3)
		33	beqz a2, .L3
		34	li a5,64
		35	sub a5,a5,a2
		36	sext.w a4,a5
		37	blez a5, .L4
		38	sext.w a2,a2
		39	srl a0,a0,a2
		40	sll a4,a1,a4
		41	sra a2,a1,a2
		42	or a0,a0,a4
		43	mv a1,a2
		44	.L3:
		45	ret
		46	.L4:
		47	negw a0,a4
		48	srai a2,a1,0x3f
		49	sra a0,a1,a0
		50	mv a1,a2
		51	ret
		52	SYM_FUNC_END(__ashrti3)
		53	EXPORT_SYMBOL(__ashrti3)
		54
		55	SYM_FUNC_START(__ashlti3)
		56	beqz a2, .L5
		57	li a5,64
		58	sub a5,a5,a2
		59	sext.w a4,a5
		60	blez a5, .L6
		61	sext.w a2,a2
		62	sll a1,a1,a2
		63	srl a4,a0,a4
		64	sll a2,a0,a2
		65	or a1,a1,a4
		66	mv a0,a2
		67	.L5:
		68	ret
		69	.L6:
		70	negw a1,a4
		71	li a2,0
		72	sll a1,a0,a1
		73	mv a0,a2
36	ret	74	ret
37	ENDPROC(__lshrti3)	75	SYM_FUNC_END(__ashlti3)
		76	EXPORT_SYMBOL(__ashlti3)

arch/s390/kernel/setup.c+1−1

@@ -1052,7 +1052,7 @@ static void __init log_component_list(void) · 1051 unmodified lines
1052		1052
1053	if (!early_ipl_comp_list_addr)	1053	if (!early_ipl_comp_list_addr)
1054	return;	1054	return;
1055	if (ipl_block.hdr.flags & IPL_PL_FLAG_IPLSR)	1055	if (ipl_block.hdr.flags & IPL_PL_FLAG_SIPL)
1056	pr_info("Linux is running with Secure-IPL enabled\n");	1056	pr_info("Linux is running with Secure-IPL enabled\n");
1057	else	1057	else
1058	pr_info("Linux is running with Secure-IPL disabled\n");	1058	pr_info("Linux is running with Secure-IPL disabled\n");

arch/x86/boot/compressed/head_64.S+5−0

 	leal	efi32_config(%ebp), %eax
 	movl	%eax, efi_config(%ebp)
+	/* Disable paging */
+	movl	%cr0, %eax
+	btrl	$X86_CR0_PG_BIT, %eax
+	movl	%eax, %cr0
 	jmp	startup_32
 SYM_FUNC_END(efi32_stub_entry)
 #endif

arch/x86/events/intel/uncore_snb.c+6−0

 #define PCI_DEVICE_ID_INTEL_SKL_HQ_IMC		0x1910
 #define PCI_DEVICE_ID_INTEL_SKL_SD_IMC		0x190f
 #define PCI_DEVICE_ID_INTEL_SKL_SQ_IMC		0x191f
+#define PCI_DEVICE_ID_INTEL_SKL_E3_IMC		0x1918
 #define PCI_DEVICE_ID_INTEL_KBL_Y_IMC		0x590c
 #define PCI_DEVICE_ID_INTEL_KBL_U_IMC		0x5904
 #define PCI_DEVICE_ID_INTEL_KBL_UQ_IMC		0x5914
 		PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SKL_SQ_IMC),
 		.driver_data = UNCORE_PCI_DEV_DATA(SNB_PCI_UNCORE_IMC, 0),
 	},
+	{ /* IMC */
+		PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SKL_E3_IMC),
+		.driver_data = UNCORE_PCI_DEV_DATA(SNB_PCI_UNCORE_IMC, 0),
+	},
 	{ /* IMC */
 		PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_KBL_Y_IMC),
 		.driver_data = UNCORE_PCI_DEV_DATA(SNB_PCI_UNCORE_IMC, 0),
 	IMC_DEV(SKL_HQ_IMC, &skl_uncore_pci_driver),  /* 6th Gen Core H Quad Core */
 	IMC_DEV(SKL_SD_IMC, &skl_uncore_pci_driver),  /* 6th Gen Core S Dual Core */
 	IMC_DEV(SKL_SQ_IMC, &skl_uncore_pci_driver),  /* 6th Gen Core S Quad Core */
+	IMC_DEV(SKL_E3_IMC, &skl_uncore_pci_driver),  /* Xeon E3 V5 Gen Core processor */
 	IMC_DEV(KBL_Y_IMC, &skl_uncore_pci_driver),  /* 7th Gen Core Y */
 	IMC_DEV(KBL_U_IMC, &skl_uncore_pci_driver),  /* 7th Gen Core U */
 	IMC_DEV(KBL_UQ_IMC, &skl_uncore_pci_driver),  /* 7th Gen Core U Quad Core */

arch/x86/events/intel/uncore_snbep.c+1−24

 #define SNR_M2M_PCI_PMON_BOX_CTL		0x438
 #define SNR_M2M_PCI_PMON_UMASK_EXT		0xff
-/* SNR PCIE3 */
-#define SNR_PCIE3_PCI_PMON_CTL0			0x508
-#define SNR_PCIE3_PCI_PMON_CTR0			0x4e8
-#define SNR_PCIE3_PCI_PMON_BOX_CTL		0x4e4
 /* SNR IMC */
 #define SNR_IMC_MMIO_PMON_FIXED_CTL		0x54
 #define SNR_IMC_MMIO_PMON_FIXED_CTR		0x38
 	.format_group	= &snr_m2m_uncore_format_group,
 };
-static struct intel_uncore_type snr_uncore_pcie3 = {
-	.name		= "pcie3",
-	.num_counters	= 4,
-	.num_boxes	= 1,
-	.perf_ctr_bits	= 48,
-	.perf_ctr	= SNR_PCIE3_PCI_PMON_CTR0,
-	.event_ctl	= SNR_PCIE3_PCI_PMON_CTL0,
-	.event_mask	= SNBEP_PMON_RAW_EVENT_MASK,
-	.box_ctl	= SNR_PCIE3_PCI_PMON_BOX_CTL,
-	.ops		= &ivbep_uncore_pci_ops,
-	.format_group	= &ivbep_uncore_format_group,
-};
 enum {
 	SNR_PCI_UNCORE_M2M,
-	SNR_PCI_UNCORE_PCIE3,
 };
 static struct intel_uncore_type *snr_pci_uncores[] = {
 	[SNR_PCI_UNCORE_M2M]		= &snr_uncore_m2m,
-	[SNR_PCI_UNCORE_PCIE3]		= &snr_uncore_pcie3,
 	NULL,
 };
 		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x344a),
 		.driver_data = UNCORE_PCI_DEV_FULL_DATA(12, 0, SNR_PCI_UNCORE_M2M, 0),
 	},
-	{ /* PCIe3 */
-		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x334a),
-		.driver_data = UNCORE_PCI_DEV_FULL_DATA(4, 0, SNR_PCI_UNCORE_PCIE3, 0),
-	},
 	{ /* end: all zeroes */ }
 };
 	INTEL_UNCORE_EVENT_DESC(write,		"event=0xff,umask=0x21"),
 	INTEL_UNCORE_EVENT_DESC(write.scale,	"3.814697266e-6"),
 	INTEL_UNCORE_EVENT_DESC(write.unit,	"MiB"),
+	{ /* end: all zeroes */ },
 };
 static struct intel_uncore_ops snr_uncore_imc_freerunning_ops = {

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

@@ -615,9 +615,9 @@ static void early_detect_mem_encrypt(struct cpuinfo_x86 *c) · 614 unmodified lines
615	return;	615	return;
616		616
617	clear_all:	617	clear_all:
618	clear_cpu_cap(c, X86_FEATURE_SME);	618	setup_clear_cpu_cap(X86_FEATURE_SME);
619	clear_sev:	619	clear_sev:
620	clear_cpu_cap(c, X86_FEATURE_SEV);	620	setup_clear_cpu_cap(X86_FEATURE_SEV);
621	}	621	}
622	}	622	}
623		623

arch/x86/kernel/cpu/mce/therm_throt.c+5−4

 {
 	struct thermal_state *state = &per_cpu(thermal_state, cpu);
 	struct device *dev = get_cpu_device(cpu);
+	u32 l;
 	state->package_throttle.level = PACKAGE_LEVEL;
 	state->core_throttle.level = CORE_LEVEL;
 	INIT_DELAYED_WORK(&state->package_throttle.therm_work, throttle_active_work);
 	INIT_DELAYED_WORK(&state->core_throttle.therm_work, throttle_active_work);
+	/* Unmask the thermal vector after the above workqueues are initialized. */
+	l = apic_read(APIC_LVTTHMR);
+	apic_write(APIC_LVTTHMR, l & ~APIC_LVT_MASKED);
 	return thermal_throttle_add_dev(dev, cpu);
 }
 	rdmsr(MSR_IA32_MISC_ENABLE, l, h);
 	wrmsr(MSR_IA32_MISC_ENABLE, l | MSR_IA32_MISC_ENABLE_TM1, h);
-	/* Unmask the thermal vector: */
-	l = apic_read(APIC_LVTTHMR);
-	apic_write(APIC_LVTTHMR, l & ~APIC_LVT_MASKED);
 	pr_info_once("CPU0: Thermal monitoring enabled (%s)\n",
 		      tm2 ? "TM2" : "TM1");

arch/x86/kernel/cpu/resctrl/core.c+1−1

@@ -618,7 +618,7 @@ static void domain_remove_cpu(int cpu, struct rdt_resource *r) · 617 unmodified lines
618	if (static_branch_unlikely(&rdt_mon_enable_key))	618	if (static_branch_unlikely(&rdt_mon_enable_key))
619	rmdir_mondata_subdir_allrdtgrp(r, d->id);	619	rmdir_mondata_subdir_allrdtgrp(r, d->id);
620	list_del(&d->list);	620	list_del(&d->list);
621	if (is_mbm_enabled())	621	if (r->mon_capable && is_mbm_enabled())
622	cancel_delayed_work(&d->mbm_over);	622	cancel_delayed_work(&d->mbm_over);
623	if (is_llc_occupancy_enabled() && has_busy_rmid(r, d)) {	623	if (is_llc_occupancy_enabled() && has_busy_rmid(r, d)) {
624	/*	624	/*

arch/x86/kernel/cpu/resctrl/rdtgroup.c+3−3

 	struct rdt_domain *d;
 	int cpu;
-	if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL))
-		return -ENOMEM;
 	if (level == RDT_RESOURCE_L3)
 		update = l3_qos_cfg_update;
 	else if (level == RDT_RESOURCE_L2)
 	else
 		return -EINVAL;
+	if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL))
+		return -ENOMEM;
 	r_l = &rdt_resources_all[level];
 	list_for_each_entry(d, &r_l->domains, list) {
 		/* Pick one CPU from each domain instance to update MSR */

block/blk-merge.c+7−2

@@ -164,8 +164,13 @@ static inline unsigned get_max_segment_size(const struct request_queue *q, · 163 unmodified lines
164	unsigned long mask = queue_segment_boundary(q);	164	unsigned long mask = queue_segment_boundary(q);
165		165
166	offset = mask & (page_to_phys(start_page) + offset);	166	offset = mask & (page_to_phys(start_page) + offset);
167	return min_t(unsigned long, mask - offset + 1,	167
168	queue_max_segment_size(q));	168	/*
		169	* overflow may be triggered in case of zero page physical address
		170	* on 32bit arch, use queue's max segment size when that happens.
		171	*/
		172	return min_not_zero(mask - offset + 1,
		173	(unsigned long)queue_max_segment_size(q));
169	}	174	}
170		175
171	/**	176	/**

block/blk-settings.c+1−1

@@ -328,7 +328,7 @@ EXPORT_SYMBOL(blk_queue_max_segment_size); · 327 unmodified lines
328	* storage device can address. The default of 512 covers most	328	* storage device can address. The default of 512 covers most
329	* hardware.	329	* hardware.
330	**/	330	**/
331	void blk_queue_logical_block_size(struct request_queue *q, unsigned short size)	331	void blk_queue_logical_block_size(struct request_queue *q, unsigned int size)
332	{	332	{
333	q->limits.logical_block_size = size;	333	q->limits.logical_block_size = size;
334		334

drivers/base/firmware_loader/builtin/Makefile+1−1

@@ -17,7 +17,7 @@ PROGBITS = $(if $(CONFIG_ARM),%,@)progbits · 16 unmodified lines
17	filechk_fwbin = \	17	filechk_fwbin = \
18	echo "/* Generated by $(src)/Makefile */" ;\	18	echo "/* Generated by $(src)/Makefile */" ;\
19	echo " .section .rodata" ;\	19	echo " .section .rodata" ;\
20	echo " .p2align $(ASM_ALIGN)" ;\	20	echo " .p2align 4" ;\
21	echo "_fw_$(FWSTR)_bin:" ;\	21	echo "_fw_$(FWSTR)_bin:" ;\
22	echo " .incbin \"$(fwdir)/$(FWNAME)\"" ;\	22	echo " .incbin \"$(fwdir)/$(FWNAME)\"" ;\
23	echo "_fw_end:" ;\	23	echo "_fw_end:" ;\

drivers/block/null_blk_zoned.c+3−1

 		return BLK_STS_IOERR;
 	case BLK_ZONE_COND_EMPTY:
 	case BLK_ZONE_COND_IMP_OPEN:
+	case BLK_ZONE_COND_EXP_OPEN:
+	case BLK_ZONE_COND_CLOSED:
 		/* Writes must be at the write pointer position */
 		if (sector != zone->wp)
 			return BLK_STS_IOERR;
-		if (zone->cond == BLK_ZONE_COND_EMPTY)
+		if (zone->cond != BLK_ZONE_COND_EXP_OPEN)
 			zone->cond = BLK_ZONE_COND_IMP_OPEN;
 		zone->wp += nr_sectors;

drivers/bus/ti-sysc.c+8−2

 		return -EINVAL;
 	}
+	/* Always add a slot for main clocks fck and ick even if unused */
+	if (!nr_fck)
+		ddata->nr_clocks++;
+	if (!nr_ick)
+		ddata->nr_clocks++;
 	ddata->clocks = devm_kcalloc(ddata->dev,
 				     ddata->nr_clocks, sizeof(*ddata->clocks),
 				     GFP_KERNEL);
 	struct clk *clock;
 	int i, error;
-	if (!ddata->clocks)
+	if (!ddata->clocks || ddata->nr_clocks < SYSC_OPTFCK0 + 1)
 		return 0;
 	for (i = SYSC_OPTFCK0; i < SYSC_MAX_CLOCKS; i++) {
 	struct clk *clock;
 	int i;
-	if (!ddata->clocks)
+	if (!ddata->clocks || ddata->nr_clocks < SYSC_OPTFCK0 + 1)
 		return;
 	for (i = SYSC_OPTFCK0; i < SYSC_MAX_CLOCKS; i++) {

drivers/clk/clk.c+8−2

 	if (core->flags & CLK_IS_CRITICAL) {
 		unsigned long flags;
-		clk_core_prepare(core);
+		ret = clk_core_prepare(core);
+		if (ret)
+			goto out;
 		flags = clk_enable_lock();
-		clk_core_enable(core);
+		ret = clk_core_enable(core);
 		clk_enable_unlock(flags);
+		if (ret) {
+			clk_core_unprepare(core);
+			goto out;
+		}
 	}
 	clk_core_reparent_orphans_nolock();

drivers/clk/mmp/clk-of-mmp2.c+1−1

@@ -134,7 +134,7 @@ static DEFINE_SPINLOCK(ssp3_lock); · 133 unmodified lines
134	static const char *ssp_parent_names[] = {"vctcxo_4", "vctcxo_2", "vctcxo", "pll1_16"};	134	static const char *ssp_parent_names[] = {"vctcxo_4", "vctcxo_2", "vctcxo", "pll1_16"};
135		135
136	static DEFINE_SPINLOCK(timer_lock);	136	static DEFINE_SPINLOCK(timer_lock);
137	static const char *timer_parent_names[] = {"clk32", "vctcxo_2", "vctcxo_4", "vctcxo"};	137	static const char *timer_parent_names[] = {"clk32", "vctcxo_4", "vctcxo_2", "vctcxo"};
138		138
139	static DEFINE_SPINLOCK(reset_lock);	139	static DEFINE_SPINLOCK(reset_lock);
140		140

drivers/clk/qcom/gcc-sdm845.c+7−0

 		.name = "hlos1_vote_aggre_noc_mmu_audio_tbu_gdsc",
 	},
 	.pwrsts = PWRSTS_OFF_ON,
+	.flags = VOTABLE,
 };
 static struct gdsc hlos1_vote_aggre_noc_mmu_pcie_tbu_gdsc = {
 		.name = "hlos1_vote_aggre_noc_mmu_pcie_tbu_gdsc",
 	},
 	.pwrsts = PWRSTS_OFF_ON,
+	.flags = VOTABLE,
 };
 static struct gdsc hlos1_vote_aggre_noc_mmu_tbu1_gdsc = {
 		.name = "hlos1_vote_aggre_noc_mmu_tbu1_gdsc",
 	},
 	.pwrsts = PWRSTS_OFF_ON,
+	.flags = VOTABLE,
 };
 static struct gdsc hlos1_vote_aggre_noc_mmu_tbu2_gdsc = {
 		.name = "hlos1_vote_aggre_noc_mmu_tbu2_gdsc",
 	},
 	.pwrsts = PWRSTS_OFF_ON,
+	.flags = VOTABLE,
 };
 static struct gdsc hlos1_vote_mmnoc_mmu_tbu_hf0_gdsc = {
 		.name = "hlos1_vote_mmnoc_mmu_tbu_hf0_gdsc",
 	},
 	.pwrsts = PWRSTS_OFF_ON,
+	.flags = VOTABLE,
 };
 static struct gdsc hlos1_vote_mmnoc_mmu_tbu_hf1_gdsc = {
 		.name = "hlos1_vote_mmnoc_mmu_tbu_hf1_gdsc",
 	},
 	.pwrsts = PWRSTS_OFF_ON,
+	.flags = VOTABLE,
 };
 static struct gdsc hlos1_vote_mmnoc_mmu_tbu_sf_gdsc = {
 		.name = "hlos1_vote_mmnoc_mmu_tbu_sf_gdsc",
 	},
 	.pwrsts = PWRSTS_OFF_ON,
+	.flags = VOTABLE,
 };
 static struct clk_regmap *gcc_sdm845_clocks[] = {

drivers/clk/samsung/clk-exynos5420.c+8−0

 #include <linux/clk-provider.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
+#include <linux/clk.h>
 #include "clk.h"
 #include "clk-cpu.h"
 				     exynos5x_subcmus);
 	}
+	/*
+	 * Keep top part of G3D clock path enabled permanently to ensure
+	 * that the internal busses get their clock regardless of the
+	 * main G3D clock enablement status.
+	 */
+	clk_prepare_enable(__clk_lookup("mout_sw_aclk_g3d"));
 	samsung_clk_of_add_provider(np, ctx);
 }

drivers/clk/sunxi-ng/ccu-sun50i-h6-r.c+3−13

  */
 static const char * const ar100_r_apb2_parents[] = { "osc24M", "osc32k",
-					     "pll-periph0", "iosc" };
+						     "iosc", "pll-periph0" };
 static const struct ccu_mux_var_prediv ar100_r_apb2_predivs[] = {
-	{ .index = 2, .shift = 0, .width = 5 },
+	{ .index = 3, .shift = 0, .width = 5 },
 };
 static struct ccu_div ar100_clk = {
 static CLK_FIXED_FACTOR_HW(r_ahb_clk, "r-ahb", &ar100_clk.common.hw, 1, 1, 0);
-static struct ccu_div r_apb1_clk = {
+static SUNXI_CCU_M(r_apb1_clk, "r-apb1", "r-ahb", 0x00c, 0, 2, 0);
-	.div		= _SUNXI_CCU_DIV(0, 2),
-	.common		= {
-		.reg		= 0x00c,
-		.hw.init	= CLK_HW_INIT("r-apb1",
-					      "r-ahb",
-					      &ccu_div_ops,
-					      0),
-	},
-};
 static struct ccu_div r_apb2_clk = {
 	.div		= _SUNXI_CCU_DIV_FLAGS(8, 2, CLK_DIVIDER_POWER_OF_TWO),

drivers/clk/sunxi-ng/ccu-sun8i-r.c+3−18

 static CLK_FIXED_FACTOR_HW(ahb0_clk, "ahb0", &ar100_clk.common.hw, 1, 1, 0);
-static struct ccu_div apb0_clk = {
+static SUNXI_CCU_M(apb0_clk, "apb0", "ahb0", 0x0c, 0, 2, 0);
-	.div		= _SUNXI_CCU_DIV_FLAGS(0, 2, CLK_DIVIDER_POWER_OF_TWO),
-	.common		= {
-		.reg		= 0x0c,
-		.hw.init	= CLK_HW_INIT_HW("apb0",
-						 &ahb0_clk.hw,
-						 &ccu_div_ops,
-						 0),
-	},
-};
-static SUNXI_CCU_M(a83t_apb0_clk, "apb0", "ahb0", 0x0c, 0, 2, 0);
 /*
  * Define the parent as an array that can be reused to save space
 static struct ccu_common *sun8i_a83t_r_ccu_clks[] = {
 	&ar100_clk.common,
-	&a83t_apb0_clk.common,
+	&apb0_clk.common,
 	&apb0_pio_clk.common,
 	&apb0_ir_clk.common,
 	&apb0_timer_clk.common,
 	.hws	= {
 		[CLK_AR100]		= &ar100_clk.common.hw,
 		[CLK_AHB0]		= &ahb0_clk.hw,
-		[CLK_APB0]		= &a83t_apb0_clk.common.hw,
+		[CLK_APB0]		= &apb0_clk.common.hw,
 		[CLK_APB0_PIO]		= &apb0_pio_clk.common.hw,
 		[CLK_APB0_IR]		= &apb0_ir_clk.common.hw,
 		[CLK_APB0_TIMER]	= &apb0_timer_clk.common.hw,
 static void __init sun8i_a83t_r_ccu_setup(struct device_node *node)
 {
-	/* Fix apb0 bus gate parents here */
-	apb0_gate_parent[0] = &a83t_apb0_clk.common.hw;
 	sunxi_r_ccu_init(node, &sun8i_a83t_r_ccu_desc);
 }
 CLK_OF_DECLARE(sun8i_a83t_r_ccu, "allwinner,sun8i-a83t-r-ccu",

drivers/clk/sunxi-ng/ccu-sun8i-r40.c+4−2

 		.reg		= 0x1f0,
 		.features	= CCU_FEATURE_FIXED_PREDIV,
 		.hw.init	= CLK_HW_INIT_PARENTS("outa", out_parents,
-						      &ccu_mp_ops, 0),
+						      &ccu_mp_ops,
+						      CLK_SET_RATE_PARENT),
 	}
 };
 		.reg		= 0x1f4,
 		.features	= CCU_FEATURE_FIXED_PREDIV,
 		.hw.init	= CLK_HW_INIT_PARENTS("outb", out_parents,
-						      &ccu_mp_ops, 0),
+						      &ccu_mp_ops,
+						      CLK_SET_RATE_PARENT),
 	}
 };

drivers/clk/sunxi-ng/ccu-sun8i-v3s.c+2−2

@@ -618,7 +618,7 @@ static struct clk_hw_onecell_data sun8i_v3s_hw_clks = { · 617 unmodified lines
618	[CLK_MBUS] = &mbus_clk.common.hw,	618	[CLK_MBUS] = &mbus_clk.common.hw,
619	[CLK_MIPI_CSI] = &mipi_csi_clk.common.hw,	619	[CLK_MIPI_CSI] = &mipi_csi_clk.common.hw,
620	},	620	},
621	.num = CLK_NUMBER,	621	.num = CLK_PLL_DDR1 + 1,
622	};	622	};
623		623
624	static struct clk_hw_onecell_data sun8i_v3_hw_clks = {	624	static struct clk_hw_onecell_data sun8i_v3_hw_clks = {
@@ -700,7 +700,7 @@ static struct clk_hw_onecell_data sun8i_v3_hw_clks = { · 75 unmodified lines
700	[CLK_MBUS] = &mbus_clk.common.hw,	700	[CLK_MBUS] = &mbus_clk.common.hw,
701	[CLK_MIPI_CSI] = &mipi_csi_clk.common.hw,	701	[CLK_MIPI_CSI] = &mipi_csi_clk.common.hw,
702	},	702	},
703	.num = CLK_NUMBER,	703	.num = CLK_I2S0 + 1,
704	};	704	};
705		705
706	static struct ccu_reset_map sun8i_v3s_ccu_resets[] = {	706	static struct ccu_reset_map sun8i_v3s_ccu_resets[] = {

drivers/clk/sunxi-ng/ccu-sun8i-v3s.h+0−2

@@ -51,6 +51,4 @@ · 50 unmodified lines
51		51
52	#define CLK_PLL_DDR1 74	52	#define CLK_PLL_DDR1 74
53		53
54	#define CLK_NUMBER (CLK_I2S0 + 1)
55
56	#endif /* _CCU_SUN8I_H3_H_ */	54	#endif /* _CCU_SUN8I_H3_H_ */

drivers/clk/tegra/clk.c+3−1

@@ -231,8 +231,10 @@ struct clk ** __init tegra_clk_init(void __iomem *regs, int num, int banks) · 230 unmodified lines
231	periph_banks = banks;	231	periph_banks = banks;
232		232
233	clks = kcalloc(num, sizeof(struct clk *), GFP_KERNEL);	233	clks = kcalloc(num, sizeof(struct clk *), GFP_KERNEL);
234	if (!clks)	234	if (!clks) {
235	kfree(periph_clk_enb_refcnt);	235	kfree(periph_clk_enb_refcnt);
		236	return NULL;
		237	}
236		238
237	clk_num = num;	239	clk_num = num;
238		240

drivers/clk/ti/clk-dra7-atl.c+0−1

@@ -233,7 +233,6 @@ static int of_dra7_atl_clk_probe(struct platform_device *pdev) · 232 unmodified lines
233	cinfo->iobase = of_iomap(node, 0);	233	cinfo->iobase = of_iomap(node, 0);
234	cinfo->dev = &pdev->dev;	234	cinfo->dev = &pdev->dev;
235	pm_runtime_enable(cinfo->dev);	235	pm_runtime_enable(cinfo->dev);
236	pm_runtime_irq_safe(cinfo->dev);
237		236
238	pm_runtime_get_sync(cinfo->dev);	237	pm_runtime_get_sync(cinfo->dev);
239	atl_write(cinfo, DRA7_ATL_PCLKMUX_REG(0), DRA7_ATL_PCLKMUX);	238	atl_write(cinfo, DRA7_ATL_PCLKMUX_REG(0), DRA7_ATL_PCLKMUX);

drivers/cpuidle/governors/teo.c+1−1

@@ -198,7 +198,7 @@ static void teo_update(struct cpuidle_driver drv, struct cpuidle_device dev) · 197 unmodified lines
198	* pattern detection.	198	* pattern detection.
199	*/	199	*/
200	cpu_data->intervals[cpu_data->interval_idx++] = measured_ns;	200	cpu_data->intervals[cpu_data->interval_idx++] = measured_ns;
201	if (cpu_data->interval_idx > INTERVALS)	201	if (cpu_data->interval_idx >= INTERVALS)
202	cpu_data->interval_idx = 0;	202	cpu_data->interval_idx = 0;
203	}	203	}
204		204

drivers/crypto/hisilicon/sec2/sec.h+3−3

@@ -40,7 +40,7 @@ struct sec_req { · 39 unmodified lines
40	int req_id;	40	int req_id;
41		41
42	/* Status of the SEC request */	42	/* Status of the SEC request */
43	int fake_busy;	43	atomic_t fake_busy;
44	};	44	};
45		45
46	/**	46	/**
@@ -132,8 +132,8 @@ struct sec_debug_file { · 85 unmodified lines
132	};	132	};
133		133
134	struct sec_dfx {	134	struct sec_dfx {
135	u64 send_cnt;	135	atomic64_t send_cnt;
136	u64 recv_cnt;	136	atomic64_t recv_cnt;
137	};	137	};
138		138
139	struct sec_debug {	139	struct sec_debug {

drivers/crypto/hisilicon/sec2/sec_crypto.c+6−6

@@ -120,7 +120,7 @@ static void sec_req_cb(struct hisi_qp qp, void resp) · 119 unmodified lines
120	return;	120	return;
121	}	121	}
122		122
123	__sync_add_and_fetch(&req->ctx->sec->debug.dfx.recv_cnt, 1);	123	atomic64_inc(&req->ctx->sec->debug.dfx.recv_cnt);
124		124
125	req->ctx->req_op->buf_unmap(req->ctx, req);	125	req->ctx->req_op->buf_unmap(req->ctx, req);
126		126
@@ -135,13 +135,13 @@ static int sec_bd_send(struct sec_ctx ctx, struct sec_req req) · 8 unmodified lines
135	mutex_lock(&qp_ctx->req_lock);	135	mutex_lock(&qp_ctx->req_lock);
136	ret = hisi_qp_send(qp_ctx->qp, &req->sec_sqe);	136	ret = hisi_qp_send(qp_ctx->qp, &req->sec_sqe);
137	mutex_unlock(&qp_ctx->req_lock);	137	mutex_unlock(&qp_ctx->req_lock);
138	__sync_add_and_fetch(&ctx->sec->debug.dfx.send_cnt, 1);	138	atomic64_inc(&ctx->sec->debug.dfx.send_cnt);
139		139
140	if (ret == -EBUSY)	140	if (ret == -EBUSY)
141	return -ENOBUFS;	141	return -ENOBUFS;
142		142
143	if (!ret) {	143	if (!ret) {
144	if (req->fake_busy)	144	if (atomic_read(&req->fake_busy))
145	ret = -EBUSY;	145	ret = -EBUSY;
146	else	146	else
147	ret = -EINPROGRESS;	147	ret = -EINPROGRESS;
@@ -641,7 +641,7 @@ static void sec_skcipher_callback(struct sec_ctx ctx, struct sec_req req) · 493 unmodified lines
641	if (ctx->c_ctx.c_mode == SEC_CMODE_CBC && req->c_req.encrypt)	641	if (ctx->c_ctx.c_mode == SEC_CMODE_CBC && req->c_req.encrypt)
642	sec_update_iv(req);	642	sec_update_iv(req);
643		643
644	if (__sync_bool_compare_and_swap(&req->fake_busy, 1, 0))	644	if (atomic_cmpxchg(&req->fake_busy, 1, 0) != 1)
645	sk_req->base.complete(&sk_req->base, -EINPROGRESS);	645	sk_req->base.complete(&sk_req->base, -EINPROGRESS);
646		646
647	sk_req->base.complete(&sk_req->base, req->err_type);	647	sk_req->base.complete(&sk_req->base, req->err_type);
@@ -672,9 +672,9 @@ static int sec_request_init(struct sec_ctx ctx, struct sec_req req) · 24 unmodified lines
672	}	672	}
673		673
674	if (ctx->fake_req_limit <= atomic_inc_return(&qp_ctx->pending_reqs))	674	if (ctx->fake_req_limit <= atomic_inc_return(&qp_ctx->pending_reqs))
675	req->fake_busy = 1;	675	atomic_set(&req->fake_busy, 1);
676	else	676	else
677	req->fake_busy = 0;	677	atomic_set(&req->fake_busy, 0);
678		678
679	ret = ctx->req_op->get_res(ctx, req);	679	ret = ctx->req_op->get_res(ctx, req);
680	if (ret) {	680	if (ret) {

drivers/crypto/hisilicon/sec2/sec_main.c+12−2

 	.write = sec_debug_write,
 };
+static int debugfs_atomic64_t_get(void *data, u64 *val)
+{
+        *val = atomic64_read((atomic64_t *)data);
+        return 0;
+}
+DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic64_t_ro, debugfs_atomic64_t_get, NULL,
+                        "%lld\n");
 static int sec_core_debug_init(struct sec_dev *sec)
 {
 	struct hisi_qm *qm = &sec->qm;
 	debugfs_create_regset32("regs", 0444, tmp_d, regset);
-	debugfs_create_u64("send_cnt", 0444, tmp_d, &dfx->send_cnt);
+	debugfs_create_file("send_cnt", 0444, tmp_d, &dfx->send_cnt,
+			    &fops_atomic64_t_ro);
-	debugfs_create_u64("recv_cnt", 0444, tmp_d, &dfx->recv_cnt);
+	debugfs_create_file("recv_cnt", 0444, tmp_d, &dfx->recv_cnt,
+			    &fops_atomic64_t_ro);
 	return 0;
 }

drivers/firmware/efi/earlycon.c+7−9

 static const struct font_desc *font;
 static u32 efi_x, efi_y;
 static u64 fb_base;
-static pgprot_t fb_prot;
+static bool fb_wb;
 static void *efi_fb;
 /*
 	if (!earlycon_console || !(earlycon_console->flags & CON_ENABLED))
 		return 0;
-	if (pgprot_val(fb_prot) == pgprot_val(PAGE_KERNEL))
+	efi_fb = memremap(fb_base, screen_info.lfb_size,
-		efi_fb = memremap(fb_base, screen_info.lfb_size, MEMREMAP_WB);
+			  fb_wb ? MEMREMAP_WB : MEMREMAP_WC);
-	else
-		efi_fb = memremap(fb_base, screen_info.lfb_size, MEMREMAP_WC);
 	return efi_fb ? 0 : -ENOMEM;
 }
 static __ref void *efi_earlycon_map(unsigned long start, unsigned long len)
 {
+	pgprot_t fb_prot;
 	if (efi_fb)
 		return efi_fb + start;
+	fb_prot = fb_wb ? PAGE_KERNEL : pgprot_writecombine(PAGE_KERNEL);
 	return early_memremap_prot(fb_base + start, len, pgprot_val(fb_prot));
 }
 	if (screen_info.capabilities & VIDEO_CAPABILITY_64BIT_BASE)
 		fb_base |= (u64)screen_info.ext_lfb_base << 32;
-	if (opt && !strcmp(opt, "ram"))
+	fb_wb = opt && !strcmp(opt, "ram");
-		fb_prot = PAGE_KERNEL;
-	else
-		fb_prot = pgprot_writecombine(PAGE_KERNEL);
 	si = &screen_info;
 	xres = si->lfb_width;

drivers/firmware/efi/libstub/random.c+3−3

@@ -33,7 +33,7 @@ efi_status_t efi_get_random_bytes(efi_system_table_t *sys_table_arg, · 32 unmodified lines
33	{	33	{
34	efi_guid_t rng_proto = EFI_RNG_PROTOCOL_GUID;	34	efi_guid_t rng_proto = EFI_RNG_PROTOCOL_GUID;
35	efi_status_t status;	35	efi_status_t status;
36	struct efi_rng_protocol *rng;	36	struct efi_rng_protocol *rng = NULL;
37		37
38	status = efi_call_early(locate_protocol, &rng_proto, NULL,	38	status = efi_call_early(locate_protocol, &rng_proto, NULL,
39	(void **)&rng);	39	(void **)&rng);
@@ -162,8 +162,8 @@ efi_status_t efi_random_get_seed(efi_system_table_t *sys_table_arg) · 122 unmodified lines
162	efi_guid_t rng_proto = EFI_RNG_PROTOCOL_GUID;	162	efi_guid_t rng_proto = EFI_RNG_PROTOCOL_GUID;
163	efi_guid_t rng_algo_raw = EFI_RNG_ALGORITHM_RAW;	163	efi_guid_t rng_algo_raw = EFI_RNG_ALGORITHM_RAW;
164	efi_guid_t rng_table_guid = LINUX_EFI_RANDOM_SEED_TABLE_GUID;	164	efi_guid_t rng_table_guid = LINUX_EFI_RANDOM_SEED_TABLE_GUID;
165	struct efi_rng_protocol *rng;	165	struct efi_rng_protocol *rng = NULL;
166	struct linux_efi_random_seed *seed;	166	struct linux_efi_random_seed *seed = NULL;
167	efi_status_t status;	167	efi_status_t status;
168		168
169	status = efi_call_early(locate_protocol, &rng_proto, NULL,	169	status = efi_call_early(locate_protocol, &rng_proto, NULL,

drivers/gpio/Kconfig+0−1

@@ -573,7 +573,6 @@ config GPIO_THUNDERX · 572 unmodified lines
573	tristate "Cavium ThunderX/OCTEON-TX GPIO"	573	tristate "Cavium ThunderX/OCTEON-TX GPIO"
574	depends on ARCH_THUNDER \|\| (64BIT && COMPILE_TEST)	574	depends on ARCH_THUNDER \|\| (64BIT && COMPILE_TEST)
575	depends on PCI_MSI	575	depends on PCI_MSI
576	select GPIOLIB_IRQCHIP
577	select IRQ_DOMAIN_HIERARCHY	576	select IRQ_DOMAIN_HIERARCHY
578	select IRQ_FASTEOI_HIERARCHY_HANDLERS	577	select IRQ_FASTEOI_HIERARCHY_HANDLERS
579	help	578	help

drivers/gpio/gpio-thunderx.c+107−56

 struct thunderx_gpio {
 	struct gpio_chip	chip;
 	u8 __iomem		*register_base;
+	struct irq_domain	*irqd;
 	struct msix_entry	*msix_entries;	/* per line MSI-X */
 	struct thunderx_line	*line_entries;	/* per line irq info */
 	raw_spinlock_t		lock;
 	}
 }
-static void thunderx_gpio_irq_ack(struct irq_data *d)
+static void thunderx_gpio_irq_ack(struct irq_data *data)
 {
-	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
 	writeq(GPIO_INTR_INTR,
-	       txgpio->register_base + intr_reg(irqd_to_hwirq(d)));
+	       txline->txgpio->register_base + intr_reg(txline->line));
 }
-static void thunderx_gpio_irq_mask(struct irq_data *d)
+static void thunderx_gpio_irq_mask(struct irq_data *data)
 {
-	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
 	writeq(GPIO_INTR_ENA_W1C,
-	       txgpio->register_base + intr_reg(irqd_to_hwirq(d)));
+	       txline->txgpio->register_base + intr_reg(txline->line));
 }
-static void thunderx_gpio_irq_mask_ack(struct irq_data *d)
+static void thunderx_gpio_irq_mask_ack(struct irq_data *data)
 {
-	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
 	writeq(GPIO_INTR_ENA_W1C | GPIO_INTR_INTR,
-	       txgpio->register_base + intr_reg(irqd_to_hwirq(d)));
+	       txline->txgpio->register_base + intr_reg(txline->line));
 }
-static void thunderx_gpio_irq_unmask(struct irq_data *d)
+static void thunderx_gpio_irq_unmask(struct irq_data *data)
 {
-	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
 	writeq(GPIO_INTR_ENA_W1S,
-	       txgpio->register_base + intr_reg(irqd_to_hwirq(d)));
+	       txline->txgpio->register_base + intr_reg(txline->line));
 }
-static int thunderx_gpio_irq_set_type(struct irq_data *d,
+static int thunderx_gpio_irq_set_type(struct irq_data *data,
 				      unsigned int flow_type)
 {
-	struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
+	struct thunderx_gpio *txgpio = txline->txgpio;
-	struct thunderx_line *txline =
-		&txgpio->line_entries[irqd_to_hwirq(d)];
 	u64 bit_cfg;
-	irqd_set_trigger_type(d, flow_type);
+	irqd_set_trigger_type(data, flow_type);
 	bit_cfg = txline->fil_bits | GPIO_BIT_CFG_INT_EN;
 	if (flow_type & IRQ_TYPE_EDGE_BOTH) {
-		irq_set_handler_locked(d, handle_fasteoi_ack_irq);
+		irq_set_handler_locked(data, handle_fasteoi_ack_irq);
 		bit_cfg |= GPIO_BIT_CFG_INT_TYPE;
 	} else {
-		irq_set_handler_locked(d, handle_fasteoi_mask_irq);
+		irq_set_handler_locked(data, handle_fasteoi_mask_irq);
 	}
 	raw_spin_lock(&txgpio->lock);
 	irq_chip_disable_parent(data);
 }
+static int thunderx_gpio_irq_request_resources(struct irq_data *data)
+{
+	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
+	struct thunderx_gpio *txgpio = txline->txgpio;
+	int r;
+	r = gpiochip_lock_as_irq(&txgpio->chip, txline->line);
+	if (r)
+		return r;
+	r = irq_chip_request_resources_parent(data);
+	if (r)
+		gpiochip_unlock_as_irq(&txgpio->chip, txline->line);
+	return r;
+}
+static void thunderx_gpio_irq_release_resources(struct irq_data *data)
+{
+	struct thunderx_line *txline = irq_data_get_irq_chip_data(data);
+	struct thunderx_gpio *txgpio = txline->txgpio;
+	irq_chip_release_resources_parent(data);
+	gpiochip_unlock_as_irq(&txgpio->chip, txline->line);
+}
 /*
  * Interrupts are chained from underlying MSI-X vectors.  We have
  * these irq_chip functions to be able to handle level triggering
 	.irq_unmask		= thunderx_gpio_irq_unmask,
 	.irq_eoi		= irq_chip_eoi_parent,
 	.irq_set_affinity	= irq_chip_set_affinity_parent,
+	.irq_request_resources	= thunderx_gpio_irq_request_resources,
+	.irq_release_resources	= thunderx_gpio_irq_release_resources,
 	.irq_set_type		= thunderx_gpio_irq_set_type,
 	.flags			= IRQCHIP_SET_TYPE_MASKED
 };
-static int thunderx_gpio_child_to_parent_hwirq(struct gpio_chip *gc,
+static int thunderx_gpio_irq_translate(struct irq_domain *d,
-					       unsigned int child,
+				       struct irq_fwspec *fwspec,
-					       unsigned int child_type,
+				       irq_hw_number_t *hwirq,
-					       unsigned int *parent,
+				       unsigned int *type)
-					       unsigned int *parent_type)
 {
-	struct thunderx_gpio *txgpio = gpiochip_get_data(gc);
+	struct thunderx_gpio *txgpio = d->host_data;
-	*parent = txgpio->base_msi + (2 * child);
+	if (WARN_ON(fwspec->param_count < 2))
-	*parent_type = IRQ_TYPE_LEVEL_HIGH;
+		return -EINVAL;
+	if (fwspec->param[0] >= txgpio->chip.ngpio)
+		return -EINVAL;
+	*hwirq = fwspec->param[0];
+	*type = fwspec->param[1] & IRQ_TYPE_SENSE_MASK;
 	return 0;
 }
+static int thunderx_gpio_irq_alloc(struct irq_domain *d, unsigned int virq,
+				   unsigned int nr_irqs, void *arg)
+{
+	struct thunderx_line *txline = arg;
+	return irq_domain_set_hwirq_and_chip(d, virq, txline->line,
+					     &thunderx_gpio_irq_chip, txline);
+}
+static const struct irq_domain_ops thunderx_gpio_irqd_ops = {
+	.alloc		= thunderx_gpio_irq_alloc,
+	.translate	= thunderx_gpio_irq_translate
+};
+static int thunderx_gpio_to_irq(struct gpio_chip *chip, unsigned int offset)
+{
+	struct thunderx_gpio *txgpio = gpiochip_get_data(chip);
+	return irq_find_mapping(txgpio->irqd, offset);
+}
 static int thunderx_gpio_probe(struct pci_dev *pdev,
 			       const struct pci_device_id *id)
 {
 	struct device *dev = &pdev->dev;
 	struct thunderx_gpio *txgpio;
 	struct gpio_chip *chip;
-	struct gpio_irq_chip *girq;
 	int ngpio, i;
 	int err = 0;
 	}
 	txgpio->msix_entries = devm_kcalloc(dev,
-					    ngpio, sizeof(struct msix_entry),
+					  ngpio, sizeof(struct msix_entry),
-					    GFP_KERNEL);
+					  GFP_KERNEL);
 	if (!txgpio->msix_entries) {
 		err = -ENOMEM;
 		goto out;
 	if (err < 0)
 		goto out;
+	/*
+	 * Push GPIO specific irqdomain on hierarchy created as a side
+	 * effect of the pci_enable_msix()
+	 */
+	txgpio->irqd = irq_domain_create_hierarchy(irq_get_irq_data(txgpio->msix_entries[0].vector)->domain,
+						   0, 0, of_node_to_fwnode(dev->of_node),
+						   &thunderx_gpio_irqd_ops, txgpio);
+	if (!txgpio->irqd) {
+		err = -ENOMEM;
+		goto out;
+	}
+	/* Push on irq_data and the domain for each line. */
+	for (i = 0; i < ngpio; i++) {
+		err = irq_domain_push_irq(txgpio->irqd,
+					  txgpio->msix_entries[i].vector,
+					  &txgpio->line_entries[i]);
+		if (err < 0)
+			dev_err(dev, "irq_domain_push_irq: %d\n", err);
+	}
 	chip->label = KBUILD_MODNAME;
 	chip->parent = dev;
 	chip->owner = THIS_MODULE;
 	chip->set = thunderx_gpio_set;
 	chip->set_multiple = thunderx_gpio_set_multiple;
 	chip->set_config = thunderx_gpio_set_config;
-	girq = &chip->irq;
+	chip->to_irq = thunderx_gpio_to_irq;
-	girq->chip = &thunderx_gpio_irq_chip;
-	girq->fwnode = of_node_to_fwnode(dev->of_node);
-	girq->parent_domain =
-		irq_get_irq_data(txgpio->msix_entries[0].vector)->domain;
-	girq->child_to_parent_hwirq = thunderx_gpio_child_to_parent_hwirq;
-	girq->handler = handle_bad_irq;
-	girq->default_type = IRQ_TYPE_NONE;
 	err = devm_gpiochip_add_data(dev, chip, txgpio);
 	if (err)
 		goto out;
-	/* Push on irq_data and the domain for each line. */
-	for (i = 0; i < ngpio; i++) {
-		err = irq_domain_push_irq(chip->irq.domain,
-					  txgpio->msix_entries[i].vector,
-					  chip);
-		if (err < 0)
-			dev_err(dev, "irq_domain_push_irq: %d\n", err);
-	}
 	dev_info(dev, "ThunderX GPIO: %d lines with base %d.\n",
 		 ngpio, chip->base);
 	return 0;
 	struct thunderx_gpio *txgpio = pci_get_drvdata(pdev);
 	for (i = 0; i < txgpio->chip.ngpio; i++)
-		irq_domain_pop_irq(txgpio->chip.irq.domain,
+		irq_domain_pop_irq(txgpio->irqd,
 				   txgpio->msix_entries[i].vector);
-	irq_domain_remove(txgpio->chip.irq.domain);
+	irq_domain_remove(txgpio->irqd);
 	pci_set_drvdata(pdev, NULL);
 }

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

@@ -254,7 +254,7 @@ static const struct soc15_reg_golden golden_settings_sdma_4_3[] = { · 253 unmodified lines
254	SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_RLC0_RB_WPTR_POLL_CNTL, 0xfffffff7, 0x00403000),	254	SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_RLC0_RB_WPTR_POLL_CNTL, 0xfffffff7, 0x00403000),
255	SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_RLC1_RB_WPTR_POLL_CNTL, 0xfffffff7, 0x00403000),	255	SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_RLC1_RB_WPTR_POLL_CNTL, 0xfffffff7, 0x00403000),
256	SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_PAGE, 0x000003ff, 0x000003c0),	256	SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_PAGE, 0x000003ff, 0x000003c0),
257	SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_WATERMK, 0xfc000000, 0x00000000)	257	SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_WATERMK, 0xfc000000, 0x03fbe1fe)
258	};	258	};
259		259
260	static u32 sdma_v4_0_get_reg_offset(struct amdgpu_device *adev,	260	static u32 sdma_v4_0_get_reg_offset(struct amdgpu_device *adev,

drivers/gpu/drm/amd/display/dc/core/dc_link.c+1−1

 		}
 		case SIGNAL_TYPE_EDP: {
-			read_current_link_settings_on_detect(link);
 			detect_edp_sink_caps(link);
+			read_current_link_settings_on_detect(link);
 			sink_caps.transaction_type = DDC_TRANSACTION_TYPE_I2C_OVER_AUX;
 			sink_caps.signal = SIGNAL_TYPE_EDP;
 			break;

drivers/gpu/drm/drm_dp_mst_topology.c+36−3

 		    txmsg->state == DRM_DP_SIDEBAND_TX_SENT) {
 			mstb->tx_slots[txmsg->seqno] = NULL;
 		}
+		mgr->is_waiting_for_dwn_reply = false;
 	}
 out:
 	if (unlikely(ret == -EIO) && drm_debug_enabled(DRM_UT_DP)) {
 	}
 	mutex_unlock(&mgr->qlock);
+	drm_dp_mst_kick_tx(mgr);
 	return ret;
 }
 {
 	struct drm_dp_mst_topology_mgr *mgr = mstb->mgr;
 	struct drm_dp_mst_port *port;
-	int old_ddps, ret;
+	int old_ddps, old_input, ret, i;
 	u8 new_pdt;
 	bool dowork = false, create_connector = false;
 	}
 	old_ddps = port->ddps;
+	old_input = port->input;
 	port->input = conn_stat->input_port;
 	port->mcs = conn_stat->message_capability_status;
 	port->ldps = conn_stat->legacy_device_plug_status;
 		dowork = false;
 	}
+	if (!old_input && old_ddps != port->ddps && !port->ddps) {
+		for (i = 0; i < mgr->max_payloads; i++) {
+			struct drm_dp_vcpi *vcpi = mgr->proposed_vcpis[i];
+			struct drm_dp_mst_port *port_validated;
+			if (!vcpi)
+				continue;
+			port_validated =
+				container_of(vcpi, struct drm_dp_mst_port, vcpi);
+			port_validated =
+				drm_dp_mst_topology_get_port_validated(mgr, port_validated);
+			if (!port_validated) {
+				mutex_lock(&mgr->payload_lock);
+				vcpi->num_slots = 0;
+				mutex_unlock(&mgr->payload_lock);
+			} else {
+				drm_dp_mst_topology_put_port(port_validated);
+			}
+		}
+	}
 	if (port->connector)
 		drm_modeset_unlock(&mgr->base.lock);
 	else if (create_connector)
 	ret = process_single_tx_qlock(mgr, txmsg, false);
 	if (ret == 1) {
 		/* txmsg is sent it should be in the slots now */
+		mgr->is_waiting_for_dwn_reply = true;
 		list_del(&txmsg->next);
 	} else if (ret) {
 		DRM_DEBUG_KMS("failed to send msg in q %d\n", ret);
+		mgr->is_waiting_for_dwn_reply = false;
 		list_del(&txmsg->next);
 		if (txmsg->seqno != -1)
 			txmsg->dst->tx_slots[txmsg->seqno] = NULL;
 		drm_dp_mst_dump_sideband_msg_tx(&p, txmsg);
 	}
-	if (list_is_singular(&mgr->tx_msg_downq))
+	if (list_is_singular(&mgr->tx_msg_downq) &&
+	    !mgr->is_waiting_for_dwn_reply)
 		process_single_down_tx_qlock(mgr);
 	mutex_unlock(&mgr->qlock);
 }
 	mutex_lock(&mgr->qlock);
 	txmsg->state = DRM_DP_SIDEBAND_TX_RX;
 	mstb->tx_slots[slot] = NULL;
+	mgr->is_waiting_for_dwn_reply = false;
 	mutex_unlock(&mgr->qlock);
 	wake_up_all(&mgr->tx_waitq);
 no_msg:
 	drm_dp_mst_topology_put_mstb(mstb);
 clear_down_rep_recv:
+	mutex_lock(&mgr->qlock);
+	mgr->is_waiting_for_dwn_reply = false;
+	mutex_unlock(&mgr->qlock);
 	memset(&mgr->down_rep_recv, 0, sizeof(struct drm_dp_sideband_msg_rx));
 	return 0;
 	struct drm_dp_mst_topology_mgr *mgr = container_of(work, struct drm_dp_mst_topology_mgr, tx_work);
 	mutex_lock(&mgr->qlock);
-	if (!list_empty(&mgr->tx_msg_downq))
+	if (!list_empty(&mgr->tx_msg_downq) && !mgr->is_waiting_for_dwn_reply)
 		process_single_down_tx_qlock(mgr);
 	mutex_unlock(&mgr->qlock);
 }

drivers/gpu/drm/i915/gt/intel_context.c+37−3

 	if (err)
 		return err;
+	err = i915_active_acquire(&vma->active);
+	if (err)
+		goto err_unpin;
 	/*
 	 * And mark it as a globally pinned object to let the shrinker know
 	 * it cannot reclaim the object until we release it.
 	vma->obj->mm.dirty = true;
 	return 0;
+err_unpin:
+	i915_vma_unpin(vma);
+	return err;
 }
 static void __context_unpin_state(struct i915_vma *vma)
 {
 	i915_vma_make_shrinkable(vma);
+	i915_active_release(&vma->active);
 	__i915_vma_unpin(vma);
 }
+static int __ring_active(struct intel_ring *ring)
+{
+	int err;
+	err = i915_active_acquire(&ring->vma->active);
+	if (err)
+		return err;
+	err = intel_ring_pin(ring);
+	if (err)
+		goto err_active;
+	return 0;
+err_active:
+	i915_active_release(&ring->vma->active);
+	return err;
+}
+static void __ring_retire(struct intel_ring *ring)
+{
+	intel_ring_unpin(ring);
+	i915_active_release(&ring->vma->active);
+}
 __i915_active_call
 static void __intel_context_retire(struct i915_active *active)
 {
 		__context_unpin_state(ce->state);
 	intel_timeline_unpin(ce->timeline);
-	intel_ring_unpin(ce->ring);
+	__ring_retire(ce->ring);
 	intel_context_put(ce);
 }
 	intel_context_get(ce);
-	err = intel_ring_pin(ce->ring);
+	err = __ring_active(ce->ring);
 	if (err)
 		goto err_put;
 err_timeline:
 	intel_timeline_unpin(ce->timeline);
 err_ring:
-	intel_ring_unpin(ce->ring);
+	__ring_retire(ce->ring);
 err_put:
 	intel_context_put(ce);
 	return err;

drivers/gpu/drm/i915/gt/intel_lrc.c+8−0

@@ -2664,6 +2664,14 @@ static u32 gen9_init_indirectctx_bb(struct intel_engine_cs engine, u32 *batch) · 2663 unmodified lines
2664	/* WaFlushCoherentL3CacheLinesAtContextSwitch:skl,bxt,glk */	2664	/* WaFlushCoherentL3CacheLinesAtContextSwitch:skl,bxt,glk */
2665	batch = gen8_emit_flush_coherentl3_wa(engine, batch);	2665	batch = gen8_emit_flush_coherentl3_wa(engine, batch);
2666		2666
		2667	/* WaClearSlmSpaceAtContextSwitch:skl,bxt,kbl,glk,cfl */
		2668	batch = gen8_emit_pipe_control(batch,
		2669	PIPE_CONTROL_FLUSH_L3 \|
		2670	PIPE_CONTROL_STORE_DATA_INDEX \|
		2671	PIPE_CONTROL_CS_STALL \|
		2672	PIPE_CONTROL_QW_WRITE,
		2673	LRC_PPHWSP_SCRATCH_ADDR);
		2674
2667	batch = emit_lri(batch, lri, ARRAY_SIZE(lri));	2675	batch = emit_lri(batch, lri, ARRAY_SIZE(lri));
2668		2676
2669	/* WaMediaPoolStateCmdInWABB:bxt,glk */	2677	/* WaMediaPoolStateCmdInWABB:bxt,glk */

drivers/gpu/drm/i915/i915_gem_gtt.c+2−5

 static void ggtt_restore_mappings(struct i915_ggtt *ggtt)
 {
-	struct i915_vma *vma, *vn;
+	struct i915_vma *vma;
 	bool flush = false;
 	int open;
 	open = atomic_xchg(&ggtt->vm.open, 0);
 	/* clflush objects bound into the GGTT and rebind them. */
-	list_for_each_entry_safe(vma, vn, &ggtt->vm.bound_list, vm_link) {
+	list_for_each_entry(vma, &ggtt->vm.bound_list, vm_link) {
 		struct drm_i915_gem_object *obj = vma->obj;
 		if (!i915_vma_is_bound(vma, I915_VMA_GLOBAL_BIND))
 			continue;
-		if (!__i915_vma_unbind(vma))
-			continue;
 		clear_bit(I915_VMA_GLOBAL_BIND_BIT, __i915_vma_flags(vma));
 		WARN_ON(i915_vma_bind(vma,
 				      obj ? obj->cache_level : 0,

drivers/gpu/drm/i915/i915_pmu.c+8−3

 	hrtimer_init(&pmu->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 	pmu->timer.function = i915_sample;
-	if (!is_igp(i915))
+	if (!is_igp(i915)) {
 		pmu->name = kasprintf(GFP_KERNEL,
-				      "i915-%s",
+				      "i915_%s",
 				      dev_name(i915->drm.dev));
-	else
+		if (pmu->name) {
+			/* tools/perf reserves colons as special. */
+			strreplace((char *)pmu->name, ':', '_');
+		}
+	} else {
 		pmu->name = "i915";
+	}
 	if (!pmu->name)
 		goto err;

drivers/gpu/drm/i915/selftests/i915_random.h+1−0

@@ -25,6 +25,7 @@ · 24 unmodified lines
25	#ifndef __I915_SELFTESTS_RANDOM_H__	25	#ifndef __I915_SELFTESTS_RANDOM_H__
26	#define __I915_SELFTESTS_RANDOM_H__	26	#define __I915_SELFTESTS_RANDOM_H__
27		27
		28	#include <linux/math64.h>
28	#include <linux/random.h>	29	#include <linux/random.h>
29		30
30	#include "../i915_selftest.h"	31	#include "../i915_selftest.h"

drivers/gpu/drm/rockchip/cdn-dp-core.h+1−1

@@ -95,7 +95,7 @@ struct cdn_dp_device { · 94 unmodified lines
95	struct cdn_dp_port *port[MAX_PHY];	95	struct cdn_dp_port *port[MAX_PHY];
96	u8 ports;	96	u8 ports;
97	u8 max_lanes;	97	u8 max_lanes;
98	u8 max_rate;	98	unsigned int max_rate;
99	u8 lanes;	99	u8 lanes;
100	int active_port;	100	int active_port;
101		101

drivers/gpu/drm/virtio/virtgpu_plane.c+1−0

@@ -232,6 +232,7 @@ static void virtio_gpu_cursor_plane_update(struct drm_plane *plane, · 231 unmodified lines
232	if (!objs)	232	if (!objs)
233	return;	233	return;
234	virtio_gpu_array_add_obj(objs, vgfb->base.obj[0]);	234	virtio_gpu_array_add_obj(objs, vgfb->base.obj[0]);
		235	virtio_gpu_array_lock_resv(objs);
235	virtio_gpu_cmd_transfer_to_host_2d	236	virtio_gpu_cmd_transfer_to_host_2d
236	(vgdev, 0,	237	(vgdev, 0,
237	plane->state->crtc_w,	238	plane->state->crtc_w,

drivers/hwtracing/coresight/coresight-etm4x.c+6−7

 	drvdata->trcid = coresight_get_trace_id(drvdata->cpu);
 }
-#ifdef CONFIG_CPU_PM
 static int etm4_cpu_save(struct etmv4_drvdata *drvdata)
 {
 	int i, ret = 0;
 static int etm4_cpu_pm_register(void)
 {
-	return cpu_pm_register_notifier(&etm4_cpu_pm_nb);
+	if (IS_ENABLED(CONFIG_CPU_PM))
+		return cpu_pm_register_notifier(&etm4_cpu_pm_nb);
+	return 0;
 }
 static void etm4_cpu_pm_unregister(void)
 {
-	cpu_pm_unregister_notifier(&etm4_cpu_pm_nb);
+	if (IS_ENABLED(CONFIG_CPU_PM))
+		cpu_pm_unregister_notifier(&etm4_cpu_pm_nb);
 }
-#else
-static int etm4_cpu_pm_register(void) { return 0; }
-static void etm4_cpu_pm_unregister(void) { }
-#endif
 static int etm4_probe(struct amba_device *adev, const struct amba_id *id)
 {

drivers/i2c/busses/i2c-iop3xx.c+8−4

 	adapter_data->gpio_scl = devm_gpiod_get_optional(&pdev->dev,
 							 "scl",
 							 GPIOD_ASIS);
-	if (IS_ERR(adapter_data->gpio_scl))
+	if (IS_ERR(adapter_data->gpio_scl)) {
-		return PTR_ERR(adapter_data->gpio_scl);
+		ret = PTR_ERR(adapter_data->gpio_scl);
+		goto free_both;
+	}
 	adapter_data->gpio_sda = devm_gpiod_get_optional(&pdev->dev,
 							 "sda",
 							 GPIOD_ASIS);
-	if (IS_ERR(adapter_data->gpio_sda))
+	if (IS_ERR(adapter_data->gpio_sda)) {
-		return PTR_ERR(adapter_data->gpio_sda);
+		ret = PTR_ERR(adapter_data->gpio_sda);
+		goto free_both;
+	}
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!res) {

drivers/i2c/busses/i2c-tegra.c+28−10

@@ -1608,14 +1608,18 @@ static int tegra_i2c_probe(struct platform_device *pdev) · 1607 unmodified lines
1608	}	1608	}
1609		1609
1610	pm_runtime_enable(&pdev->dev);	1610	pm_runtime_enable(&pdev->dev);
1611	if (!pm_runtime_enabled(&pdev->dev))	1611	if (!pm_runtime_enabled(&pdev->dev)) {
1612	ret = tegra_i2c_runtime_resume(&pdev->dev);	1612	ret = tegra_i2c_runtime_resume(&pdev->dev);
1613	else	1613	if (ret < 0) {
		1614	dev_err(&pdev->dev, "runtime resume failed\n");
		1615	goto unprepare_div_clk;
		1616	}
		1617	} else {
1614	ret = pm_runtime_get_sync(i2c_dev->dev);	1618	ret = pm_runtime_get_sync(i2c_dev->dev);
1615		1619	if (ret < 0) {
1616	if (ret < 0) {	1620	dev_err(&pdev->dev, "runtime resume failed\n");
1617	dev_err(&pdev->dev, "runtime resume failed\n");	1621	goto disable_rpm;
1618	goto unprepare_div_clk;	1622	}
1619	}	1623	}
1620		1624
1621	if (i2c_dev->is_multimaster_mode) {	1625	if (i2c_dev->is_multimaster_mode) {
@@ -1623,7 +1627,7 @@ static int tegra_i2c_probe(struct platform_device *pdev) · 1 unmodified line
1623	if (ret < 0) {	1627	if (ret < 0) {
1624	dev_err(i2c_dev->dev, "div_clk enable failed %d\n",	1628	dev_err(i2c_dev->dev, "div_clk enable failed %d\n",
1625	ret);	1629	ret);
1626	goto disable_rpm;	1630	goto put_rpm;
1627	}	1631	}
1628	}	1632	}
1629		1633
@@ -1671,11 +1675,16 @@ disable_div_clk: · 41 unmodified lines
1671	if (i2c_dev->is_multimaster_mode)	1675	if (i2c_dev->is_multimaster_mode)
1672	clk_disable(i2c_dev->div_clk);	1676	clk_disable(i2c_dev->div_clk);
1673		1677
1674	disable_rpm:	1678	put_rpm:
1675	pm_runtime_disable(&pdev->dev);	1679	if (pm_runtime_enabled(&pdev->dev))
1676	if (!pm_runtime_status_suspended(&pdev->dev))	1680	pm_runtime_put_sync(&pdev->dev);
		1681	else
1677	tegra_i2c_runtime_suspend(&pdev->dev);	1682	tegra_i2c_runtime_suspend(&pdev->dev);
1678		1683
		1684	disable_rpm:
		1685	if (pm_runtime_enabled(&pdev->dev))
		1686	pm_runtime_disable(&pdev->dev);
		1687
1679	unprepare_div_clk:	1688	unprepare_div_clk:
1680	clk_unprepare(i2c_dev->div_clk);	1689	clk_unprepare(i2c_dev->div_clk);
1681		1690
@@ -1710,9 +1719,14 @@ static int tegra_i2c_remove(struct platform_device *pdev) · 28 unmodified lines
1710	static int __maybe_unused tegra_i2c_suspend(struct device *dev)	1719	static int __maybe_unused tegra_i2c_suspend(struct device *dev)
1711	{	1720	{
1712	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);	1721	struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);
		1722	int err;
1713		1723
1714	i2c_mark_adapter_suspended(&i2c_dev->adapter);	1724	i2c_mark_adapter_suspended(&i2c_dev->adapter);
1715		1725
		1726	err = pm_runtime_force_suspend(dev);
		1727	if (err < 0)
		1728	return err;
		1729
1716	return 0;	1730	return 0;
1717	}	1731	}
1718		1732
@@ -1733,6 +1747,10 @@ static int __maybe_unused tegra_i2c_resume(struct device *dev) · 14 unmodified lines
1733	if (err)	1747	if (err)
1734	return err;	1748	return err;
1735		1749
		1750	err = pm_runtime_force_resume(dev);
		1751	if (err < 0)
		1752	return err;
		1753
1736	i2c_mark_adapter_resumed(&i2c_dev->adapter);	1754	i2c_mark_adapter_resumed(&i2c_dev->adapter);
1737		1755
1738	return 0;	1756	return 0;

drivers/iio/adc/ad7124.c+5−7

@@ -494,13 +494,11 @@ static int ad7124_of_parse_channel_config(struct iio_dev *indio_dev, · 493 unmodified lines
494	st->channel_config[channel].buf_negative =	494	st->channel_config[channel].buf_negative =
495	of_property_read_bool(child, "adi,buffered-negative");	495	of_property_read_bool(child, "adi,buffered-negative");
496		496
497	*chan = ad7124_channel_template;	497	chan[channel] = ad7124_channel_template;
498	chan->address = channel;	498	chan[channel].address = channel;
499	chan->scan_index = channel;	499	chan[channel].scan_index = channel;
500	chan->channel = ain[0];	500	chan[channel].channel = ain[0];
501	chan->channel2 = ain[1];	501	chan[channel].channel2 = ain[1];
502
503	chan++;
504	}	502	}
505		503
506	return 0;	504	return 0;

drivers/iio/chemical/Kconfig+1−0

@@ -65,6 +65,7 @@ config IAQCORE · 64 unmodified lines
65	config PMS7003	65	config PMS7003
66	tristate "Plantower PMS7003 particulate matter sensor"	66	tristate "Plantower PMS7003 particulate matter sensor"
67	depends on SERIAL_DEV_BUS	67	depends on SERIAL_DEV_BUS
		68	select IIO_BUFFER
68	select IIO_TRIGGERED_BUFFER	69	select IIO_TRIGGERED_BUFFER
69	help	70	help
70	Say Y here to build support for the Plantower PMS7003 particulate	71	Say Y here to build support for the Plantower PMS7003 particulate

drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c+2−1

@@ -1301,7 +1301,8 @@ static int st_lsm6dsx_check_whoami(struct st_lsm6dsx_hw *hw, int id, · 1300 unmodified lines
1301		1301
1302	for (i = 0; i < ARRAY_SIZE(st_lsm6dsx_sensor_settings); i++) {	1302	for (i = 0; i < ARRAY_SIZE(st_lsm6dsx_sensor_settings); i++) {
1303	for (j = 0; j < ST_LSM6DSX_MAX_ID; j++) {	1303	for (j = 0; j < ST_LSM6DSX_MAX_ID; j++) {
1304	if (id == st_lsm6dsx_sensor_settings[i].id[j].hw_id)	1304	if (st_lsm6dsx_sensor_settings[i].id[j].name &&
		1305	id == st_lsm6dsx_sensor_settings[i].id[j].hw_id)
1305	break;	1306	break;
1306	}	1307	}
1307	if (j < ST_LSM6DSX_MAX_ID)	1308	if (j < ST_LSM6DSX_MAX_ID)

drivers/iio/industrialio-buffer.c+5−1

 				const unsigned long *mask, bool timestamp)
 {
 	unsigned bytes = 0;
-	int length, i;
+	int length, i, largest = 0;
 	/* How much space will the demuxed element take? */
 	for_each_set_bit(i, mask,
 		length = iio_storage_bytes_for_si(indio_dev, i);
 		bytes = ALIGN(bytes, length);
 		bytes += length;
+		largest = max(largest, length);
 	}
 	if (timestamp) {
 		length = iio_storage_bytes_for_timestamp(indio_dev);
 		bytes = ALIGN(bytes, length);
 		bytes += length;
+		largest = max(largest, length);
 	}
+	bytes = ALIGN(bytes, largest);
 	return bytes;
 }

drivers/iio/light/vcnl4000.c+2−1

 	if (ret < 0)
 		return ret;
-	data->al_scale = 24000;
 	data->vcnl4200_al.reg = VCNL4200_AL_DATA;
 	data->vcnl4200_ps.reg = VCNL4200_PS_DATA;
 	switch (id) {
 		/* show 54ms in total. */
 		data->vcnl4200_al.sampling_rate = ktime_set(0, 54000 * 1000);
 		data->vcnl4200_ps.sampling_rate = ktime_set(0, 4200 * 1000);
+		data->al_scale = 24000;
 		break;
 	case VCNL4040_PROD_ID:
 		/* Integration time is 80ms, add 10ms. */
 		data->vcnl4200_al.sampling_rate = ktime_set(0, 100000 * 1000);
 		data->vcnl4200_ps.sampling_rate = ktime_set(0, 100000 * 1000);
+		data->al_scale = 120000;
 		break;
 	}
 	data->vcnl4200_al.last_measurement = ktime_set(0, 0);

drivers/irqchip/irq-ingenic.c+2−4

 #include <linux/delay.h>
 #include <asm/io.h>
-#include <asm/mach-jz4740/irq.h>
 struct ingenic_intc_data {
 	void __iomem *base;
 		while (pending) {
 			int bit = __fls(pending);
-			irq = irq_find_mapping(domain, bit + (i * 32));
+			irq = irq_linear_revmap(domain, bit + (i * 32));
 			generic_handle_irq(irq);
 			pending &= ~BIT(bit);
 		}
 		goto out_unmap_irq;
 	}
-	domain = irq_domain_add_legacy(node, num_chips * 32,
+	domain = irq_domain_add_linear(node, num_chips * 32,
-				       JZ4740_IRQ_BASE, 0,
 				       &irq_generic_chip_ops, NULL);
 	if (!domain) {
 		err = -ENOMEM;

drivers/md/dm-snap-persistent.c+1−1

@@ -17,7 +17,7 @@ · 16 unmodified lines
17	#include <linux/dm-bufio.h>	17	#include <linux/dm-bufio.h>
18		18
19	#define DM_MSG_PREFIX "persistent snapshot"	19	#define DM_MSG_PREFIX "persistent snapshot"
20	#define DM_CHUNK_SIZE_DEFAULT_SECTORS 32 /* 16KB */	20	#define DM_CHUNK_SIZE_DEFAULT_SECTORS 32U /* 16KB */
21		21
22	#define DM_PREFETCH_CHUNKS 12	22	#define DM_PREFETCH_CHUNKS 12
23		23

drivers/md/raid0.c+1−1

@@ -87,7 +87,7 @@ static int create_strip_zones(struct mddev mddev, struct r0conf *private_conf) · 86 unmodified lines
87	char b[BDEVNAME_SIZE];	87	char b[BDEVNAME_SIZE];
88	char b2[BDEVNAME_SIZE];	88	char b2[BDEVNAME_SIZE];
89	struct r0conf conf = kzalloc(sizeof(conf), GFP_KERNEL);	89	struct r0conf conf = kzalloc(sizeof(conf), GFP_KERNEL);
90	unsigned short blksize = 512;	90	unsigned blksize = 512;
91		91
92	*private_conf = ERR_PTR(-ENOMEM);	92	*private_conf = ERR_PTR(-ENOMEM);
93	if (!conf)	93	if (!conf)

drivers/message/fusion/mptctl.c+50−163

  * Function prototypes. Called from OS entry point mptctl_ioctl.
  * arg contents specific to function.
  */
-static int mptctl_fw_download(unsigned long arg);
+static int mptctl_fw_download(MPT_ADAPTER *iocp, unsigned long arg);
-static int mptctl_getiocinfo(unsigned long arg, unsigned int cmd);
+static int mptctl_getiocinfo(MPT_ADAPTER *iocp, unsigned long arg, unsigned int cmd);
-static int mptctl_gettargetinfo(unsigned long arg);
+static int mptctl_gettargetinfo(MPT_ADAPTER *iocp, unsigned long arg);
-static int mptctl_readtest(unsigned long arg);
+static int mptctl_readtest(MPT_ADAPTER *iocp, unsigned long arg);
-static int mptctl_mpt_command(unsigned long arg);
+static int mptctl_mpt_command(MPT_ADAPTER *iocp, unsigned long arg);
-static int mptctl_eventquery(unsigned long arg);
+static int mptctl_eventquery(MPT_ADAPTER *iocp, unsigned long arg);
-static int mptctl_eventenable(unsigned long arg);
+static int mptctl_eventenable(MPT_ADAPTER *iocp, unsigned long arg);
-static int mptctl_eventreport(unsigned long arg);
+static int mptctl_eventreport(MPT_ADAPTER *iocp, unsigned long arg);
-static int mptctl_replace_fw(unsigned long arg);
+static int mptctl_replace_fw(MPT_ADAPTER *iocp, unsigned long arg);
-static int mptctl_do_reset(unsigned long arg);
+static int mptctl_do_reset(MPT_ADAPTER *iocp, unsigned long arg);
-static int mptctl_hp_hostinfo(unsigned long arg, unsigned int cmd);
+static int mptctl_hp_hostinfo(MPT_ADAPTER *iocp, unsigned long arg, unsigned int cmd);
-static int mptctl_hp_targetinfo(unsigned long arg);
+static int mptctl_hp_targetinfo(MPT_ADAPTER *iocp, unsigned long arg);
 static int  mptctl_probe(struct pci_dev *, const struct pci_device_id *);
 static void mptctl_remove(struct pci_dev *);
 /*
  * Private function calls.
  */
-static int mptctl_do_mpt_command(struct mpt_ioctl_command karg, void __user *mfPtr);
+static int mptctl_do_mpt_command(MPT_ADAPTER *iocp, struct mpt_ioctl_command karg, void __user *mfPtr);
-static int mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen);
+static int mptctl_do_fw_download(MPT_ADAPTER *iocp, char __user *ufwbuf, size_t fwlen);
 static MptSge_t *kbuf_alloc_2_sgl(int bytes, u32 dir, int sge_offset, int *frags,
 		struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc);
 static void kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma,
 	 * by TM and FW reloads.
 	 */
 	if ((cmd & ~IOCSIZE_MASK) == (MPTIOCINFO & ~IOCSIZE_MASK)) {
-		return mptctl_getiocinfo(arg, _IOC_SIZE(cmd));
+		return mptctl_getiocinfo(iocp, arg, _IOC_SIZE(cmd));
 	} else if (cmd == MPTTARGETINFO) {
-		return mptctl_gettargetinfo(arg);
+		return mptctl_gettargetinfo(iocp, arg);
 	} else if (cmd == MPTTEST) {
-		return mptctl_readtest(arg);
+		return mptctl_readtest(iocp, arg);
 	} else if (cmd == MPTEVENTQUERY) {
-		return mptctl_eventquery(arg);
+		return mptctl_eventquery(iocp, arg);
 	} else if (cmd == MPTEVENTENABLE) {
-		return mptctl_eventenable(arg);
+		return mptctl_eventenable(iocp, arg);
 	} else if (cmd == MPTEVENTREPORT) {
-		return mptctl_eventreport(arg);
+		return mptctl_eventreport(iocp, arg);
 	} else if (cmd == MPTFWREPLACE) {
-		return mptctl_replace_fw(arg);
+		return mptctl_replace_fw(iocp, arg);
 	}
 	/* All of these commands require an interrupt or
 		return ret;
 	if (cmd == MPTFWDOWNLOAD)
-		ret = mptctl_fw_download(arg);
+		ret = mptctl_fw_download(iocp, arg);
 	else if (cmd == MPTCOMMAND)
-		ret = mptctl_mpt_command(arg);
+		ret = mptctl_mpt_command(iocp, arg);
 	else if (cmd == MPTHARDRESET)
-		ret = mptctl_do_reset(arg);
+		ret = mptctl_do_reset(iocp, arg);
 	else if ((cmd & ~IOCSIZE_MASK) == (HP_GETHOSTINFO & ~IOCSIZE_MASK))
-		ret = mptctl_hp_hostinfo(arg, _IOC_SIZE(cmd));
+		ret = mptctl_hp_hostinfo(iocp, arg, _IOC_SIZE(cmd));
 	else if (cmd == HP_GETTARGETINFO)
-		ret = mptctl_hp_targetinfo(arg);
+		ret = mptctl_hp_targetinfo(iocp, arg);
 	else
 		ret = -EINVAL;
 	return ret;
 }
-static int mptctl_do_reset(unsigned long arg)
+static int mptctl_do_reset(MPT_ADAPTER *iocp, unsigned long arg)
 {
 	struct mpt_ioctl_diag_reset __user *urinfo = (void __user *) arg;
 	struct mpt_ioctl_diag_reset krinfo;
-	MPT_ADAPTER		*iocp;
 	if (copy_from_user(&krinfo, urinfo, sizeof(struct mpt_ioctl_diag_reset))) {
 		printk(KERN_ERR MYNAM "%s@%d::mptctl_do_reset - "
 		return -EFAULT;
 	}
-	if (mpt_verify_adapter(krinfo.hdr.iocnum, &iocp) < 0) {
-		printk(KERN_DEBUG MYNAM "%s@%d::mptctl_do_reset - ioc%d not found!\n",
-				__FILE__, __LINE__, krinfo.hdr.iocnum);
-		return -ENODEV; /* (-6) No such device or address */
-	}
 	dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "mptctl_do_reset called.\n",
 	    iocp->name));
  *		-ENOMSG if FW upload returned bad status
  */
 static int
-mptctl_fw_download(unsigned long arg)
+mptctl_fw_download(MPT_ADAPTER *iocp, unsigned long arg)
 {
 	struct mpt_fw_xfer __user *ufwdl = (void __user *) arg;
 	struct mpt_fw_xfer	 kfwdl;
 		return -EFAULT;
 	}
-	return mptctl_do_fw_download(kfwdl.iocnum, kfwdl.bufp, kfwdl.fwlen);
+	return mptctl_do_fw_download(iocp, kfwdl.bufp, kfwdl.fwlen);
 }
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  *		-ENOMSG if FW upload returned bad status
  */
 static int
-mptctl_do_fw_download(int ioc, char __user *ufwbuf, size_t fwlen)
+mptctl_do_fw_download(MPT_ADAPTER *iocp, char __user *ufwbuf, size_t fwlen)
 {
 	FWDownload_t		*dlmsg;
 	MPT_FRAME_HDR		*mf;
-	MPT_ADAPTER		*iocp;
 	FWDownloadTCSGE_t	*ptsge;
 	MptSge_t		*sgl, *sgIn;
 	char			*sgOut;
 	pFWDownloadReply_t	 ReplyMsg = NULL;
 	unsigned long		 timeleft;
-	if (mpt_verify_adapter(ioc, &iocp) < 0) {
+	/*  Valid device. Get a message frame and construct the FW download message.
-		printk(KERN_DEBUG MYNAM "ioctl_fwdl - ioc%d not found!\n",
+	*/
-				 ioc);
+	if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
-		return -ENODEV; /* (-6) No such device or address */
+		return -EAGAIN;
-	} else {
-		/*  Valid device. Get a message frame and construct the FW download message.
-	 	*/
-		if ((mf = mpt_get_msg_frame(mptctl_id, iocp)) == NULL)
-			return -EAGAIN;
-	}
 	dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT
 	    "mptctl_do_fwdl called. mptctl_id = %xh.\n", iocp->name, mptctl_id));
 	    iocp->name, ufwbuf));
 	dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.fwlen = %d\n",
 	    iocp->name, (int)fwlen));
-	dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: kfwdl.ioc   = %04xh\n",
-	    iocp->name, ioc));
 	dlmsg = (FWDownload_t*) mf;
 	ptsge = (FWDownloadTCSGE_t *) &dlmsg->SGL;
  *		-ENODEV  if no such device/adapter
  */
 static int
-mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
+mptctl_getiocinfo (MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
 {
 	struct mpt_ioctl_iocinfo __user *uarg = (void __user *) arg;
 	struct mpt_ioctl_iocinfo *karg;
-	MPT_ADAPTER		*ioc;
 	struct pci_dev		*pdev;
-	int			iocnum;
 	unsigned int		port;
 	int			cim_rev;
 	struct scsi_device 	*sdev;
 		return PTR_ERR(karg);
 	}
-	if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
-	    (ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		kfree(karg);
-		return -ENODEV;
-	}
 	/* Verify the data transfer size is correct. */
 	if (karg->hdr.maxDataSize != data_size) {
 		printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
  *		-ENODEV  if no such device/adapter
  */
 static int
-mptctl_gettargetinfo (unsigned long arg)
+mptctl_gettargetinfo (MPT_ADAPTER *ioc, unsigned long arg)
 {
 	struct mpt_ioctl_targetinfo __user *uarg = (void __user *) arg;
 	struct mpt_ioctl_targetinfo karg;
-	MPT_ADAPTER		*ioc;
 	VirtDevice		*vdevice;
 	char			*pmem;
 	int			*pdata;
-	int			iocnum;
 	int			numDevices = 0;
 	int			lun;
 	int			maxWordsLeft;
 		return -EFAULT;
 	}
-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
-	    (ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		return -ENODEV;
-	}
 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_gettargetinfo called.\n",
 	    ioc->name));
 	/* Get the port number and set the maximum number of bytes
  *		-ENODEV  if no such device/adapter
  */
 static int
-mptctl_readtest (unsigned long arg)
+mptctl_readtest (MPT_ADAPTER *ioc, unsigned long arg)
 {
 	struct mpt_ioctl_test __user *uarg = (void __user *) arg;
 	struct mpt_ioctl_test	 karg;
-	MPT_ADAPTER *ioc;
-	int iocnum;
 	if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_test))) {
 		printk(KERN_ERR MYNAM "%s@%d::mptctl_readtest - "
 		return -EFAULT;
 	}
-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
-	    (ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_readtest() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		return -ENODEV;
-	}
 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_readtest called.\n",
 	    ioc->name));
 	/* Fill in the data and return the structure to the calling
  *		-ENODEV  if no such device/adapter
  */
 static int
-mptctl_eventquery (unsigned long arg)
+mptctl_eventquery (MPT_ADAPTER *ioc, unsigned long arg)
 {
 	struct mpt_ioctl_eventquery __user *uarg = (void __user *) arg;
 	struct mpt_ioctl_eventquery	 karg;
-	MPT_ADAPTER *ioc;
-	int iocnum;
 	if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventquery))) {
 		printk(KERN_ERR MYNAM "%s@%d::mptctl_eventquery - "
 		return -EFAULT;
 	}
-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
-	    (ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		return -ENODEV;
-	}
 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventquery called.\n",
 	    ioc->name));
 	karg.eventEntries = MPTCTL_EVENT_LOG_SIZE;
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 static int
-mptctl_eventenable (unsigned long arg)
+mptctl_eventenable (MPT_ADAPTER *ioc, unsigned long arg)
 {
 	struct mpt_ioctl_eventenable __user *uarg = (void __user *) arg;
 	struct mpt_ioctl_eventenable	 karg;
-	MPT_ADAPTER *ioc;
-	int iocnum;
 	if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventenable))) {
 		printk(KERN_ERR MYNAM "%s@%d::mptctl_eventenable - "
 		return -EFAULT;
 	}
-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
-	    (ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		return -ENODEV;
-	}
 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventenable called.\n",
 	    ioc->name));
 	if (ioc->events == NULL) {
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 static int
-mptctl_eventreport (unsigned long arg)
+mptctl_eventreport (MPT_ADAPTER *ioc, unsigned long arg)
 {
 	struct mpt_ioctl_eventreport __user *uarg = (void __user *) arg;
 	struct mpt_ioctl_eventreport	 karg;
-	MPT_ADAPTER		 *ioc;
-	int			 iocnum;
 	int			 numBytes, maxEvents, max;
 	if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_eventreport))) {
 		return -EFAULT;
 	}
-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
-	    (ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		return -ENODEV;
-	}
 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
 	    ioc->name));
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 static int
-mptctl_replace_fw (unsigned long arg)
+mptctl_replace_fw (MPT_ADAPTER *ioc, unsigned long arg)
 {
 	struct mpt_ioctl_replace_fw __user *uarg = (void __user *) arg;
 	struct mpt_ioctl_replace_fw	 karg;
-	MPT_ADAPTER		 *ioc;
-	int			 iocnum;
 	int			 newFwSize;
 	if (copy_from_user(&karg, uarg, sizeof(struct mpt_ioctl_replace_fw))) {
 		return -EFAULT;
 	}
-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
-	    (ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		return -ENODEV;
-	}
 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_replace_fw called.\n",
 	    ioc->name));
 	/* If caching FW, Free the old FW image
  *		-ENOMEM if memory allocation error
  */
 static int
-mptctl_mpt_command (unsigned long arg)
+mptctl_mpt_command (MPT_ADAPTER *ioc, unsigned long arg)
 {
 	struct mpt_ioctl_command __user *uarg = (void __user *) arg;
 	struct mpt_ioctl_command  karg;
-	MPT_ADAPTER	*ioc;
-	int		iocnum;
 	int		rc;
 		return -EFAULT;
 	}
-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+	rc = mptctl_do_mpt_command (ioc, karg, &uarg->MF);
-	    (ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		return -ENODEV;
-	}
-	rc = mptctl_do_mpt_command (karg, &uarg->MF);
 	return rc;
 }
  *		-EPERM if SCSI I/O and target is untagged
  */
 static int
-mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
+mptctl_do_mpt_command (MPT_ADAPTER *ioc, struct mpt_ioctl_command karg, void __user *mfPtr)
 {
-	MPT_ADAPTER	*ioc;
 	MPT_FRAME_HDR	*mf = NULL;
 	MPIHeader_t	*hdr;
 	char		*psge;
 	dma_addr_t	dma_addr_in;
 	dma_addr_t	dma_addr_out;
 	int		sgSize = 0;	/* Num SG elements */
-	int		iocnum, flagsLength;
+	int		flagsLength;
 	int		sz, rc = 0;
 	int		msgContext;
 	u16		req_idx;
 	bufIn.kptr = bufOut.kptr = NULL;
 	bufIn.len = bufOut.len = 0;
-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
-	    (ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		return -ENODEV;
-	}
 	spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
 	if (ioc->ioc_reset_in_progress) {
 		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
  *		-ENOMEM if memory allocation error
  */
 static int
-mptctl_hp_hostinfo(unsigned long arg, unsigned int data_size)
+mptctl_hp_hostinfo(MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
 {
 	hp_host_info_t	__user *uarg = (void __user *) arg;
-	MPT_ADAPTER		*ioc;
 	struct pci_dev		*pdev;
 	char                    *pbuf=NULL;
 	dma_addr_t		buf_dma;
 	hp_host_info_t		karg;
 	CONFIGPARMS		cfg;
 	ConfigPageHeader_t	hdr;
-	int			iocnum;
 	int			rc, cim_rev;
 	ToolboxIstwiReadWriteRequest_t	*IstwiRWRequest;
 	MPT_FRAME_HDR		*mf = NULL;
 		return -EFAULT;
 	}
-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
-	    (ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		return -ENODEV;
-	}
 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
 	    ioc->name));
  *		-ENOMEM if memory allocation error
  */
 static int
-mptctl_hp_targetinfo(unsigned long arg)
+mptctl_hp_targetinfo(MPT_ADAPTER *ioc, unsigned long arg)
 {
 	hp_target_info_t __user *uarg = (void __user *) arg;
 	SCSIDevicePage0_t	*pg0_alloc;
 	SCSIDevicePage3_t	*pg3_alloc;
-	MPT_ADAPTER		*ioc;
 	MPT_SCSI_HOST 		*hd = NULL;
 	hp_target_info_t	karg;
-	int			iocnum;
 	int			data_sz;
 	dma_addr_t		page_dma;
 	CONFIGPARMS	 	cfg;
 		return -EFAULT;
 	}
-	if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
-		(ioc == NULL)) {
-		printk(KERN_DEBUG MYNAM "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
-				__FILE__, __LINE__, iocnum);
-		return -ENODEV;
-	}
 	if (karg.hdr.id >= MPT_MAX_FC_DEVICES)
 		return -EINVAL;
 	dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_hp_targetinfo called.\n",
 	kfw.fwlen = kfw32.fwlen;
 	kfw.bufp = compat_ptr(kfw32.bufp);
-	ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
+	ret = mptctl_do_fw_download(iocp, kfw.bufp, kfw.fwlen);
 	mutex_unlock(&iocp->ioctl_cmds.mutex);
 	/* Pass new structure to do_mpt_command
 	 */
-	ret = mptctl_do_mpt_command (karg, &uarg->MF);
+	ret = mptctl_do_mpt_command (iocp, karg, &uarg->MF);
 	mutex_unlock(&iocp->ioctl_cmds.mutex);

drivers/misc/enclosure.c+1−2

 		cdev = &edev->component[i];
 		if (cdev->dev == dev) {
 			enclosure_remove_links(cdev);
-			device_del(&cdev->cdev);
 			put_device(dev);
 			cdev->dev = NULL;
-			return device_add(&cdev->cdev);
+			return 0;
 		}
 	}
 	return -ENODEV;

drivers/misc/lkdtm/bugs.c+7−5

 void lkdtm_UNSET_SMEP(void)
 {
-#ifdef CONFIG_X86_64
+#if IS_ENABLED(CONFIG_X86_64) && !IS_ENABLED(CONFIG_UML)
 #define MOV_CR4_DEPTH	64
 	void (*direct_write_cr4)(unsigned long val);
 	unsigned char *insn;
 		native_write_cr4(cr4);
 	}
 #else
-	pr_err("FAIL: this test is x86_64-only\n");
+	pr_err("XFAIL: this test is x86_64-only\n");
 #endif
 }
-#ifdef CONFIG_X86_32
 void lkdtm_DOUBLE_FAULT(void)
 {
+#ifdef CONFIG_X86_32
 	/*
 	 * Trigger #DF by setting the stack limit to zero.  This clobbers
 	 * a GDT TLS slot, which is okay because the current task will die
 	asm volatile ("movw %0, %%ss; addl $0, (%%esp)" ::
 		      "r" ((unsigned short)(GDT_ENTRY_TLS_MIN << 3)));
-	panic("tried to double fault but didn't die\n");
+	pr_err("FAIL: tried to double fault but didn't die\n");
-}
+#else
+	pr_err("XFAIL: this test is ia32-only\n");
 #endif
+}

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c+10−1

 	struct resources *r = &this->resources;
 	int ret;
+	ret = pm_runtime_get_sync(this->dev);
+	if (ret < 0)
+		return ret;
 	ret = gpmi_reset_block(r->gpmi_regs, false);
 	if (ret)
 		goto err_out;
 	 */
 	writel(BM_GPMI_CTRL1_DECOUPLE_CS, r->gpmi_regs + HW_GPMI_CTRL1_SET);
-	return 0;
 err_out:
+	pm_runtime_mark_last_busy(this->dev);
+	pm_runtime_put_autosuspend(this->dev);
 	return ret;
 }
 		return ret;
 	}
+	/* Set flag to get timing setup restored for next exec_op */
+	if (this->hw.clk_rate)
+		this->hw.must_apply_timings = true;
 	/* re-init the BCH registers */
 	ret = bch_set_geometry(this);
 	if (ret) {

drivers/mtd/spi-nor/spi-nor.c+3−3

 	if (nor->bouncebuf[0] & SR2_QUAD_EN_BIT1)
 		return 0;
+	nor->bouncebuf[0] |= SR2_QUAD_EN_BIT1;
 	return spi_nor_write_16bit_cr_and_check(nor, nor->bouncebuf[0]);
 }
 static void spansion_post_sfdp_fixups(struct spi_nor *nor)
 {
-	struct mtd_info *mtd = &nor->mtd;
+	if (nor->params.size <= SZ_16M)
-	if (mtd->size <= SZ_16M)
 		return;
 	nor->flags |= SNOR_F_4B_OPCODES;

drivers/net/dsa/bcm_sf2.c+1−1

@@ -68,7 +68,7 @@ static void bcm_sf2_imp_setup(struct dsa_switch *ds, int port) · 67 unmodified lines
68		68
69	/* Force link status for IMP port */	69	/* Force link status for IMP port */
70	reg = core_readl(priv, offset);	70	reg = core_readl(priv, offset);
71	reg \|= (MII_SW_OR \| LINK_STS);	71	reg \|= (MII_SW_OR \| LINK_STS \| GMII_SPEED_UP_2G);
72	core_writel(priv, reg, offset);	72	core_writel(priv, reg, offset);
73		73
74	/* Enable Broadcast, Multicast, Unicast forwarding to IMP port */	74	/* Enable Broadcast, Multicast, Unicast forwarding to IMP port */

drivers/net/dsa/sja1105/sja1105_main.c+1−1

@@ -582,7 +582,7 @@ static int sja1105_parse_ports_node(struct sja1105_private *priv, · 581 unmodified lines
582	struct device *dev = &priv->spidev->dev;	582	struct device *dev = &priv->spidev->dev;
583	struct device_node *child;	583	struct device_node *child;
584		584
585	for_each_child_of_node(ports_node, child) {	585	for_each_available_child_of_node(ports_node, child) {
586	struct device_node *phy_node;	586	struct device_node *phy_node;
587	phy_interface_t phy_mode;	587	phy_interface_t phy_mode;
588	u32 index;	588	u32 index;

drivers/net/ethernet/broadcom/bcmsysport.c+4−3

 		ring->switch_queue = qp;
 		ring->switch_port = port;
 		ring->inspect = true;
-		priv->ring_map[q + port * num_tx_queues] = ring;
+		priv->ring_map[qp + port * num_tx_queues] = ring;
 		qp++;
 	}
 	struct net_device *slave_dev;
 	unsigned int num_tx_queues;
 	struct net_device *dev;
-	unsigned int q, port;
+	unsigned int q, qp, port;
 	priv = container_of(nb, struct bcm_sysport_priv, dsa_notifier);
 	if (priv->netdev != info->master)
 			continue;
 		ring->inspect = false;
-		priv->ring_map[q + port * num_tx_queues] = NULL;
+		qp = ring->switch_queue;
+		priv->ring_map[qp + port * num_tx_queues] = NULL;
 	}
 	return 0;

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

@@ -11065,11 +11065,23 @@ static bool bnxt_fltr_match(struct bnxt_ntuple_filter *f1, · 11064 unmodified lines
11065	struct flow_keys *keys1 = &f1->fkeys;	11065	struct flow_keys *keys1 = &f1->fkeys;
11066	struct flow_keys *keys2 = &f2->fkeys;	11066	struct flow_keys *keys2 = &f2->fkeys;
11067		11067
11068	if (keys1->addrs.v4addrs.src == keys2->addrs.v4addrs.src &&	11068	if (keys1->basic.n_proto != keys2->basic.n_proto \|\|
11069	keys1->addrs.v4addrs.dst == keys2->addrs.v4addrs.dst &&	11069	keys1->basic.ip_proto != keys2->basic.ip_proto)
11070	keys1->ports.ports == keys2->ports.ports &&	11070	return false;
11071	keys1->basic.ip_proto == keys2->basic.ip_proto &&	11071
11072	keys1->basic.n_proto == keys2->basic.n_proto &&	11072	if (keys1->basic.n_proto == htons(ETH_P_IP)) {
		11073	if (keys1->addrs.v4addrs.src != keys2->addrs.v4addrs.src \|\|
		11074	keys1->addrs.v4addrs.dst != keys2->addrs.v4addrs.dst)
		11075	return false;
		11076	} else {
		11077	if (memcmp(&keys1->addrs.v6addrs.src, &keys2->addrs.v6addrs.src,
		11078	sizeof(keys1->addrs.v6addrs.src)) \|\|
		11079	memcmp(&keys1->addrs.v6addrs.dst, &keys2->addrs.v6addrs.dst,
		11080	sizeof(keys1->addrs.v6addrs.dst)))
		11081	return false;
		11082	}
		11083
		11084	if (keys1->ports.ports == keys2->ports.ports &&
11073	keys1->control.flags == keys2->control.flags &&	11085	keys1->control.flags == keys2->control.flags &&
11074	ether_addr_equal(f1->src_mac_addr, f2->src_mac_addr) &&	11086	ether_addr_equal(f1->src_mac_addr, f2->src_mac_addr) &&
11075	ether_addr_equal(f1->dst_mac_addr, f2->dst_mac_addr))	11087	ether_addr_equal(f1->dst_mac_addr, f2->dst_mac_addr))
@@ -11361,7 +11373,7 @@ int bnxt_get_port_parent_id(struct net_device *dev, · 285 unmodified lines
11361	return -EOPNOTSUPP;	11373	return -EOPNOTSUPP;
11362		11374
11363	/* The PF and it's VF-reps only support the switchdev framework */	11375	/* The PF and it's VF-reps only support the switchdev framework */
11364	if (!BNXT_PF(bp))	11376	if (!BNXT_PF(bp) \|\| !(bp->flags & BNXT_FLAG_DSN_VALID))
11365	return -EOPNOTSUPP;	11377	return -EOPNOTSUPP;
11366		11378
11367	ppid->id_len = sizeof(bp->switch_id);	11379	ppid->id_len = sizeof(bp->switch_id);
@@ -11734,6 +11746,7 @@ static int bnxt_pcie_dsn_get(struct bnxt *bp, u8 dsn[]) · 366 unmodified lines
11734	put_unaligned_le32(dw, &dsn[0]);	11746	put_unaligned_le32(dw, &dsn[0]);
11735	pci_read_config_dword(pdev, pos + 4, &dw);	11747	pci_read_config_dword(pdev, pos + 4, &dw);
11736	put_unaligned_le32(dw, &dsn[4]);	11748	put_unaligned_le32(dw, &dsn[4]);
		11749	bp->flags \|= BNXT_FLAG_DSN_VALID;
11737	return 0;	11750	return 0;
11738	}	11751	}
11739		11752
@@ -11845,9 +11858,7 @@ static int bnxt_init_one(struct pci_dev pdev, const struct pci_device_id ent) · 105 unmodified lines
11845		11858
11846	if (BNXT_PF(bp)) {	11859	if (BNXT_PF(bp)) {
11847	/* Read the adapter's DSN to use as the eswitch switch_id */	11860	/* Read the adapter's DSN to use as the eswitch switch_id */
11848	rc = bnxt_pcie_dsn_get(bp, bp->switch_id);	11861	bnxt_pcie_dsn_get(bp, bp->switch_id);
11849	if (rc)
11850	goto init_err_pci_clean;
11851	}	11862	}
11852		11863
11853	/* MTU range: 60 - FW defined max */	11864	/* MTU range: 60 - FW defined max */

drivers/net/ethernet/broadcom/bnxt/bnxt.h+1−3

 	#define BNXT_FLAG_NO_AGG_RINGS	0x20000
 	#define BNXT_FLAG_RX_PAGE_MODE	0x40000
 	#define BNXT_FLAG_MULTI_HOST	0x100000
+	#define BNXT_FLAG_DSN_VALID	0x200000
 	#define BNXT_FLAG_DOUBLE_DB	0x400000
 	#define BNXT_FLAG_CHIP_NITRO_A0	0x1000000
 	#define BNXT_FLAG_DIM		0x2000000
 	case HWRM_CFA_ENCAP_RECORD_FREE:
 	case HWRM_CFA_DECAP_FILTER_ALLOC:
 	case HWRM_CFA_DECAP_FILTER_FREE:
-	case HWRM_CFA_NTUPLE_FILTER_ALLOC:
-	case HWRM_CFA_NTUPLE_FILTER_FREE:
-	case HWRM_CFA_NTUPLE_FILTER_CFG:
 	case HWRM_CFA_EM_FLOW_ALLOC:
 	case HWRM_CFA_EM_FLOW_FREE:
 	case HWRM_CFA_EM_FLOW_CFG:

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c+3−0

@@ -398,6 +398,9 @@ static int bnxt_vf_reps_create(struct bnxt *bp) · 397 unmodified lines
398	struct net_device *dev;	398	struct net_device *dev;
399	int rc, i;	399	int rc, i;
400		400
		401	if (!(bp->flags & BNXT_FLAG_DSN_VALID))
		402	return -ENODEV;
		403
401	bp->vf_reps = kcalloc(num_vfs, sizeof(vf_rep), GFP_KERNEL);	404	bp->vf_reps = kcalloc(num_vfs, sizeof(vf_rep), GFP_KERNEL);
402	if (!bp->vf_reps)	405	if (!bp->vf_reps)
403	return -ENOMEM;	406	return -ENOMEM;

drivers/net/ethernet/cadence/macb_main.c+17−13

@@ -611,21 +611,24 @@ static const struct phylink_mac_ops macb_phylink_ops = { · 610 unmodified lines
611	.mac_link_up = macb_mac_link_up,	611	.mac_link_up = macb_mac_link_up,
612	};	612	};
613		613
		614	static bool macb_phy_handle_exists(struct device_node *dn)
		615	{
		616	dn = of_parse_phandle(dn, "phy-handle", 0);
		617	of_node_put(dn);
		618	return dn != NULL;
		619	}
		620
614	static int macb_phylink_connect(struct macb *bp)	621	static int macb_phylink_connect(struct macb *bp)
615	{	622	{
		623	struct device_node *dn = bp->pdev->dev.of_node;
616	struct net_device *dev = bp->dev;	624	struct net_device *dev = bp->dev;
617	struct phy_device *phydev;	625	struct phy_device *phydev;
618	int ret;	626	int ret;
619		627
620	if (bp->pdev->dev.of_node &&	628	if (dn)
621	of_parse_phandle(bp->pdev->dev.of_node, "phy-handle", 0)) {	629	ret = phylink_of_phy_connect(bp->phylink, dn, 0);
622	ret = phylink_of_phy_connect(bp->phylink, bp->pdev->dev.of_node,	630
623	0);	631	if (!dn \|\| (ret && !macb_phy_handle_exists(dn))) {
624	if (ret) {
625	netdev_err(dev, "Could not attach PHY (%d)\n", ret);
626	return ret;
627	}
628	} else {
629	phydev = phy_find_first(bp->mii_bus);	632	phydev = phy_find_first(bp->mii_bus);
630	if (!phydev) {	633	if (!phydev) {
631	netdev_err(dev, "no PHY found\n");	634	netdev_err(dev, "no PHY found\n");
@@ -634,10 +637,11 @@ static int macb_phylink_connect(struct macb *bp) · 2 unmodified lines
634		637
635	/* attach the mac to the phy */	638	/* attach the mac to the phy */
636	ret = phylink_connect_phy(bp->phylink, phydev);	639	ret = phylink_connect_phy(bp->phylink, phydev);
637	if (ret) {	640	}
638	netdev_err(dev, "Could not attach to PHY (%d)\n", ret);	641
639	return ret;	642	if (ret) {
640	}	643	netdev_err(dev, "Could not attach PHY (%d)\n", ret);
		644	return ret;
641	}	645	}
642		646
643	phylink_start(bp->phylink);	647	phylink_start(bp->phylink);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c+11−3

 {
 	struct port_info *pi = netdev_priv(dev);
 	struct adapter *adap = pi->adapter;
+	struct ch_sched_queue qe = { 0 };
+	struct ch_sched_params p = { 0 };
 	struct sched_class *e;
-	struct ch_sched_params p;
-	struct ch_sched_queue qe;
 	u32 req_rate;
 	int err = 0;
 		return -EINVAL;
 	}
+	qe.queue = index;
+	e = cxgb4_sched_queue_lookup(dev, &qe);
+	if (e && e->info.u.params.level != SCHED_CLASS_LEVEL_CL_RL) {
+		dev_err(adap->pdev_dev,
+			"Queue %u already bound to class %u of type: %u\n",
+			index, e->idx, e->info.u.params.level);
+		return -EBUSY;
+	}
 	/* Convert from Mbps to Kbps */
 	req_rate = rate * 1000;
 		return 0;
 	/* Fetch any available unused or matching scheduling class */
-	memset(&p, 0, sizeof(p));
 	p.type = SCHED_CLASS_TYPE_PACKET;
 	p.u.params.level    = SCHED_CLASS_LEVEL_CL_RL;
 	p.u.params.mode     = SCHED_CLASS_MODE_CLASS;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_matchall.c+67−0

@@ -15,6 +15,8 @@ static int cxgb4_matchall_egress_validate(struct net_device *dev, · 14 unmodified lines
15	struct flow_action *actions = &cls->rule->action;	15	struct flow_action *actions = &cls->rule->action;
16	struct port_info *pi = netdev2pinfo(dev);	16	struct port_info *pi = netdev2pinfo(dev);
17	struct flow_action_entry *entry;	17	struct flow_action_entry *entry;
		18	struct ch_sched_queue qe;
		19	struct sched_class *e;
18	u64 max_link_rate;	20	u64 max_link_rate;
19	u32 i, speed;	21	u32 i, speed;
20	int ret;	22	int ret;
@@ -60,9 +62,61 @@ static int cxgb4_matchall_egress_validate(struct net_device *dev, · 39 unmodified lines
60	}	62	}
61	}	63	}
62		64
		65	for (i = 0; i < pi->nqsets; i++) {
		66	memset(&qe, 0, sizeof(qe));
		67	qe.queue = i;
		68
		69	e = cxgb4_sched_queue_lookup(dev, &qe);
		70	if (e && e->info.u.params.level != SCHED_CLASS_LEVEL_CH_RL) {
		71	NL_SET_ERR_MSG_MOD(extack,
		72	"Some queues are already bound to different class");
		73	return -EBUSY;
		74	}
		75	}
		76
63	return 0;	77	return 0;
64	}	78	}
65		79
		80	static int cxgb4_matchall_tc_bind_queues(struct net_device *dev, u32 tc)
		81	{
		82	struct port_info *pi = netdev2pinfo(dev);
		83	struct ch_sched_queue qe;
		84	int ret;
		85	u32 i;
		86
		87	for (i = 0; i < pi->nqsets; i++) {
		88	qe.queue = i;
		89	qe.class = tc;
		90	ret = cxgb4_sched_class_bind(dev, &qe, SCHED_QUEUE);
		91	if (ret)
		92	goto out_free;
		93	}
		94
		95	return 0;
		96
		97	out_free:
		98	while (i--) {
		99	qe.queue = i;
		100	qe.class = SCHED_CLS_NONE;
		101	cxgb4_sched_class_unbind(dev, &qe, SCHED_QUEUE);
		102	}
		103
		104	return ret;
		105	}
		106
		107	static void cxgb4_matchall_tc_unbind_queues(struct net_device *dev)
		108	{
		109	struct port_info *pi = netdev2pinfo(dev);
		110	struct ch_sched_queue qe;
		111	u32 i;
		112
		113	for (i = 0; i < pi->nqsets; i++) {
		114	qe.queue = i;
		115	qe.class = SCHED_CLS_NONE;
		116	cxgb4_sched_class_unbind(dev, &qe, SCHED_QUEUE);
		117	}
		118	}
		119
66	static int cxgb4_matchall_alloc_tc(struct net_device *dev,	120	static int cxgb4_matchall_alloc_tc(struct net_device *dev,
67	struct tc_cls_matchall_offload *cls)	121	struct tc_cls_matchall_offload *cls)
68	{	122	{
@@ -83,6 +137,7 @@ static int cxgb4_matchall_alloc_tc(struct net_device *dev, · 14 unmodified lines
83	struct adapter *adap = netdev2adap(dev);	137	struct adapter *adap = netdev2adap(dev);
84	struct flow_action_entry *entry;	138	struct flow_action_entry *entry;
85	struct sched_class *e;	139	struct sched_class *e;
		140	int ret;
86	u32 i;	141	u32 i;
87		142
88	tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];	143	tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
@@ -101,10 +156,21 @@ static int cxgb4_matchall_alloc_tc(struct net_device *dev, · 12 unmodified lines
101	return -ENOMEM;	156	return -ENOMEM;
102	}	157	}
103		158
		159	ret = cxgb4_matchall_tc_bind_queues(dev, e->idx);
		160	if (ret) {
		161	NL_SET_ERR_MSG_MOD(extack,
		162	"Could not bind queues to traffic class");
		163	goto out_free;
		164	}
		165
104	tc_port_matchall->egress.hwtc = e->idx;	166	tc_port_matchall->egress.hwtc = e->idx;
105	tc_port_matchall->egress.cookie = cls->cookie;	167	tc_port_matchall->egress.cookie = cls->cookie;
106	tc_port_matchall->egress.state = CXGB4_MATCHALL_STATE_ENABLED;	168	tc_port_matchall->egress.state = CXGB4_MATCHALL_STATE_ENABLED;
107	return 0;	169	return 0;
		170
		171	out_free:
		172	cxgb4_sched_class_free(dev, e->idx);
		173	return ret;
108	}	174	}
109		175
110	static void cxgb4_matchall_free_tc(struct net_device *dev)	176	static void cxgb4_matchall_free_tc(struct net_device *dev)
@@ -114,6 +180,7 @@ static void cxgb4_matchall_free_tc(struct net_device *dev) · 3 unmodified lines
114	struct adapter *adap = netdev2adap(dev);	180	struct adapter *adap = netdev2adap(dev);
115		181
116	tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];	182	tc_port_matchall = &adap->tc_matchall->port_matchall[pi->port_id];
		183	cxgb4_matchall_tc_unbind_queues(dev);
117	cxgb4_sched_class_free(dev, tc_port_matchall->egress.hwtc);	184	cxgb4_sched_class_free(dev, tc_port_matchall->egress.hwtc);
118		185
119	tc_port_matchall->egress.hwtc = SCHED_CLS_NONE;	186	tc_port_matchall->egress.hwtc = SCHED_CLS_NONE;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_mqprio.c+27−1

@@ -12,8 +12,9 @@ static int cxgb4_mqprio_validate(struct net_device *dev, · 11 unmodified lines
12	struct port_info *pi = netdev2pinfo(dev);	12	struct port_info *pi = netdev2pinfo(dev);
13	struct adapter *adap = netdev2adap(dev);	13	struct adapter *adap = netdev2adap(dev);
14	u32 speed, qcount = 0, qoffset = 0;	14	u32 speed, qcount = 0, qoffset = 0;
		15	u32 start_a, start_b, end_a, end_b;
15	int ret;	16	int ret;
16	u8 i;	17	u8 i, j;
17		18
18	if (!mqprio->qopt.num_tc)	19	if (!mqprio->qopt.num_tc)
19	return 0;	20	return 0;
@@ -47,6 +48,31 @@ static int cxgb4_mqprio_validate(struct net_device *dev, · 27 unmodified lines
47	qoffset = max_t(u16, mqprio->qopt.offset[i], qoffset);	48	qoffset = max_t(u16, mqprio->qopt.offset[i], qoffset);
48	qcount += mqprio->qopt.count[i];	49	qcount += mqprio->qopt.count[i];
49		50
		51	start_a = mqprio->qopt.offset[i];
		52	end_a = start_a + mqprio->qopt.count[i] - 1;
		53	for (j = i + 1; j < mqprio->qopt.num_tc; j++) {
		54	start_b = mqprio->qopt.offset[j];
		55	end_b = start_b + mqprio->qopt.count[j] - 1;
		56
		57	/* If queue count is 0, then the traffic
		58	* belonging to this class will not use
		59	* ETHOFLD queues. So, no need to validate
		60	* further.
		61	*/
		62	if (!mqprio->qopt.count[i])
		63	break;
		64
		65	if (!mqprio->qopt.count[j])
		66	continue;
		67
		68	if (max_t(u32, start_a, start_b) <=
		69	min_t(u32, end_a, end_b)) {
		70	netdev_err(dev,
		71	"Queues can't overlap across tc\n");
		72	return -EINVAL;
		73	}
		74	}
		75
50	/* Convert byte per second to bits per second */	76	/* Convert byte per second to bits per second */
51	min_rate += (mqprio->min_rate[i] * 8);	77	min_rate += (mqprio->min_rate[i] * 8);
52	max_rate += (mqprio->max_rate[i] * 8);	78	max_rate += (mqprio->max_rate[i] * 8);

drivers/net/ethernet/chelsio/cxgb4/sched.c+16−0

@@ -165,6 +165,22 @@ static void t4_sched_entry_lookup(struct port_info pi, · 164 unmodified lines
165	return found;	165	return found;
166	}	166	}
167		167
		168	struct sched_class cxgb4_sched_queue_lookup(struct net_device dev,
		169	struct ch_sched_queue *p)
		170	{
		171	struct port_info *pi = netdev2pinfo(dev);
		172	struct sched_queue_entry *qe = NULL;
		173	struct adapter *adap = pi->adapter;
		174	struct sge_eth_txq *txq;
		175
		176	if (p->queue < 0 \|\| p->queue >= pi->nqsets)
		177	return NULL;
		178
		179	txq = &adap->sge.ethtxq[pi->first_qset + p->queue];
		180	qe = t4_sched_entry_lookup(pi, SCHED_QUEUE, txq->q.cntxt_id);
		181	return qe ? &pi->sched_tbl->tab[qe->param.class] : NULL;
		182	}
		183
168	static int t4_sched_queue_unbind(struct port_info pi, struct ch_sched_queue p)	184	static int t4_sched_queue_unbind(struct port_info pi, struct ch_sched_queue p)
169	{	185	{
170	struct sched_queue_entry *qe = NULL;	186	struct sched_queue_entry *qe = NULL;

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

@@ -103,6 +103,8 @@ static inline bool valid_class_id(struct net_device *dev, u8 class_id) · 102 unmodified lines
103	return true;	103	return true;
104	}	104	}
105		105
		106	struct sched_class cxgb4_sched_queue_lookup(struct net_device dev,
		107	struct ch_sched_queue *p);
106	int cxgb4_sched_class_bind(struct net_device dev, void arg,	108	int cxgb4_sched_class_bind(struct net_device dev, void arg,
107	enum sched_bind_type type);	109	enum sched_bind_type type);
108	int cxgb4_sched_class_unbind(struct net_device dev, void arg,	110	int cxgb4_sched_class_unbind(struct net_device dev, void arg,

drivers/net/ethernet/hisilicon/hns/hns_enet.c+1−3

 	skb = *out_skb = napi_alloc_skb(&ring_data->napi,
 					HNS_RX_HEAD_SIZE);
 	if (unlikely(!skb)) {
-		netdev_err(ndev, "alloc rx skb fail\n");
 		ring->stats.sw_err_cnt++;
 		return -ENOMEM;
 	}
 		container_of(napi, struct hns_nic_ring_data, napi);
 	struct hnae_ring *ring = ring_data->ring;
-try_again:
 	clean_complete += ring_data->poll_one(
 				ring_data, budget - clean_complete,
 				ring_data->ex_process);
 			napi_complete(napi);
 			ring->q->handle->dev->ops->toggle_ring_irq(ring, 0);
 		} else {
-			goto try_again;
+			return budget;
 		}
 	}

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c+6−0

 #define HNS3_INNER_VLAN_TAG	1
 #define HNS3_OUTER_VLAN_TAG	2
+#define HNS3_MIN_TX_LEN		33U
 /* hns3_pci_tbl - PCI Device ID Table
  *
  * Last entry must be all 0s
 	int bd_num = 0;
 	int ret;
+	/* Hardware can only handle short frames above 32 bytes */
+	if (skb_put_padto(skb, HNS3_MIN_TX_LEN))
+		return NETDEV_TX_OK;
 	/* Prefetch the data used later */
 	prefetch(skb->data);

drivers/net/ethernet/intel/e1000e/e1000.h+2−3

 /* board specific private data structure */
 struct e1000_adapter {
+	struct timer_list watchdog_timer;
 	struct timer_list phy_info_timer;
 	struct timer_list blink_timer;
 	struct work_struct reset_task;
-	struct delayed_work watchdog_task;
+	struct work_struct watchdog_task;
-	struct workqueue_struct *e1000_workqueue;
 	const struct e1000_info *ei;

drivers/net/ethernet/intel/e1000e/netdev.c+25−29

 		}
 		/* guard against interrupt when we're going down */
 		if (!test_bit(__E1000_DOWN, &adapter->state))
-			mod_delayed_work(adapter->e1000_workqueue,
+			mod_timer(&adapter->watchdog_timer, jiffies + 1);
-					 &adapter->watchdog_task, HZ);
 	}
 	/* Reset on uncorrectable ECC error */
 		}
 		/* guard against interrupt when we're going down */
 		if (!test_bit(__E1000_DOWN, &adapter->state))
-			mod_delayed_work(adapter->e1000_workqueue,
+			mod_timer(&adapter->watchdog_timer, jiffies + 1);
-					 &adapter->watchdog_task, HZ);
 	}
 	/* Reset on uncorrectable ECC error */
 		hw->mac.get_link_status = true;
 		/* guard against interrupt when we're going down */
 		if (!test_bit(__E1000_DOWN, &adapter->state))
-			mod_delayed_work(adapter->e1000_workqueue,
+			mod_timer(&adapter->watchdog_timer, jiffies + 1);
-					 &adapter->watchdog_task, HZ);
 	}
 	if (!test_bit(__E1000_DOWN, &adapter->state))
 	napi_synchronize(&adapter->napi);
+	del_timer_sync(&adapter->watchdog_timer);
 	del_timer_sync(&adapter->phy_info_timer);
 	spin_lock(&adapter->stats64_lock);
 	}
 }
+/**
+ * e1000_watchdog - Timer Call-back
+ * @data: pointer to adapter cast into an unsigned long
+ **/
+static void e1000_watchdog(struct timer_list *t)
+{
+	struct e1000_adapter *adapter = from_timer(adapter, t, watchdog_timer);
+	/* Do the rest outside of interrupt context */
+	schedule_work(&adapter->watchdog_task);
+	/* TODO: make this use queue_delayed_work() */
+}
 static void e1000_watchdog_task(struct work_struct *work)
 {
 	struct e1000_adapter *adapter = container_of(work,
 						     struct e1000_adapter,
-						     watchdog_task.work);
+						     watchdog_task);
 	struct net_device *netdev = adapter->netdev;
 	struct e1000_mac_info *mac = &adapter->hw.mac;
 	struct e1000_phy_info *phy = &adapter->hw.phy;
 	/* Reset the timer */
 	if (!test_bit(__E1000_DOWN, &adapter->state))
-		queue_delayed_work(adapter->e1000_workqueue,
+		mod_timer(&adapter->watchdog_timer,
-				   &adapter->watchdog_task,
+			  round_jiffies(jiffies + 2 * HZ));
-				   round_jiffies(2 * HZ));
 }
 #define E1000_TX_FLAGS_CSUM		0x00000001
 		goto err_eeprom;
 	}
-	adapter->e1000_workqueue = alloc_workqueue("%s", WQ_MEM_RECLAIM, 0,
+	timer_setup(&adapter->watchdog_timer, e1000_watchdog, 0);
-						   e1000e_driver_name);
-	if (!adapter->e1000_workqueue) {
-		err = -ENOMEM;
-		goto err_workqueue;
-	}
-	INIT_DELAYED_WORK(&adapter->watchdog_task, e1000_watchdog_task);
-	queue_delayed_work(adapter->e1000_workqueue, &adapter->watchdog_task,
-			   0);
 	timer_setup(&adapter->phy_info_timer, e1000_update_phy_info, 0);
 	INIT_WORK(&adapter->reset_task, e1000_reset_task);
+	INIT_WORK(&adapter->watchdog_task, e1000_watchdog_task);
 	INIT_WORK(&adapter->downshift_task, e1000e_downshift_workaround);
 	INIT_WORK(&adapter->update_phy_task, e1000e_update_phy_task);
 	INIT_WORK(&adapter->print_hang_task, e1000_print_hw_hang);
 	return 0;
 err_register:
-	flush_workqueue(adapter->e1000_workqueue);
-	destroy_workqueue(adapter->e1000_workqueue);
-err_workqueue:
 	if (!(adapter->flags & FLAG_HAS_AMT))
 		e1000e_release_hw_control(adapter);
 err_eeprom:
 	 * from being rescheduled.
 	 */
 	set_bit(__E1000_DOWN, &adapter->state);
+	del_timer_sync(&adapter->watchdog_timer);
 	del_timer_sync(&adapter->phy_info_timer);
 	cancel_work_sync(&adapter->reset_task);
+	cancel_work_sync(&adapter->watchdog_task);
 	cancel_work_sync(&adapter->downshift_task);
 	cancel_work_sync(&adapter->update_phy_task);
 	cancel_work_sync(&adapter->print_hang_task);
-	cancel_delayed_work(&adapter->watchdog_task);
-	flush_workqueue(adapter->e1000_workqueue);
-	destroy_workqueue(adapter->e1000_workqueue);
 	if (adapter->flags & FLAG_HAS_HW_TIMESTAMP) {
 		cancel_work_sync(&adapter->tx_hwtstamp_work);
 		if (adapter->tx_hwtstamp_skb) {

drivers/net/ethernet/intel/i40e/i40e_adminq.c+5−0

 		    (aq->api_maj_ver == 1 &&
 		     aq->api_min_ver >= I40E_MINOR_VER_FW_LLDP_STOPPABLE_X722))
 			hw->flags |= I40E_HW_FLAG_FW_LLDP_STOPPABLE;
+		if (aq->api_maj_ver > 1 ||
+		    (aq->api_maj_ver == 1 &&
+		     aq->api_min_ver >= I40E_MINOR_VER_GET_LINK_INFO_X722))
+			hw->flags |= I40E_HW_FLAG_AQ_PHY_ACCESS_CAPABLE;
 		/* fall through */
 	default:
 		break;

drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c+18−4

 	return ret;
 }
+/**
+ * i40e_vc_validate_vqs_bitmaps - validate Rx/Tx queue bitmaps from VIRTHCHNL
+ * @vqs: virtchnl_queue_select structure containing bitmaps to validate
+ *
+ * Returns true if validation was successful, else false.
+ */
+static bool i40e_vc_validate_vqs_bitmaps(struct virtchnl_queue_select *vqs)
+{
+	if ((!vqs->rx_queues && !vqs->tx_queues) ||
+	    vqs->rx_queues >= BIT(I40E_MAX_VF_QUEUES) ||
+	    vqs->tx_queues >= BIT(I40E_MAX_VF_QUEUES))
+		return false;
+	return true;
+}
 /**
  * i40e_vc_enable_queues_msg
  * @vf: pointer to the VF info
 		goto error_param;
 	}
-	if ((0 == vqs->rx_queues) && (0 == vqs->tx_queues)) {
+	if (i40e_vc_validate_vqs_bitmaps(vqs)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto error_param;
 	}
 		goto error_param;
 	}
-	if ((vqs->rx_queues == 0 && vqs->tx_queues == 0) ||
+	if (i40e_vc_validate_vqs_bitmaps(vqs)) {
-	    vqs->rx_queues > I40E_MAX_VF_QUEUES ||
-	    vqs->tx_queues > I40E_MAX_VF_QUEUES) {
 		aq_ret = I40E_ERR_PARAM;
 		goto error_param;
 	}

drivers/net/ethernet/intel/iavf/iavf.h+2−0

@@ -415,4 +415,6 @@ void iavf_enable_channels(struct iavf_adapter *adapter); · 414 unmodified lines
415	void iavf_disable_channels(struct iavf_adapter *adapter);	415	void iavf_disable_channels(struct iavf_adapter *adapter);
416	void iavf_add_cloud_filter(struct iavf_adapter *adapter);	416	void iavf_add_cloud_filter(struct iavf_adapter *adapter);
417	void iavf_del_cloud_filter(struct iavf_adapter *adapter);	417	void iavf_del_cloud_filter(struct iavf_adapter *adapter);
		418	struct iavf_mac_filter iavf_add_filter(struct iavf_adapter adapter,
		419	const u8 *macaddr);
418	#endif /* _IAVF_H_ */	420	#endif /* _IAVF_H_ */

drivers/net/ethernet/intel/iavf/iavf_main.c+13−4

  *
  * Returns ptr to the filter object or NULL when no memory available.
  **/
-static struct
+struct iavf_mac_filter *iavf_add_filter(struct iavf_adapter *adapter,
-iavf_mac_filter *iavf_add_filter(struct iavf_adapter *adapter,
+					const u8 *macaddr)
-				 const u8 *macaddr)
 {
 	struct iavf_mac_filter *f;
 	struct virtchnl_vf_resource *vfres = adapter->vf_res;
 	struct net_device *netdev = adapter->netdev;
 	struct iavf_hw *hw = &adapter->hw;
+	struct iavf_mac_filter *f, *ftmp;
 	struct iavf_vlan_filter *vlf;
 	struct iavf_cloud_filter *cf;
-	struct iavf_mac_filter *f;
 	u32 reg_val;
 	int i = 0, err;
 	bool running;
 	spin_lock_bh(&adapter->mac_vlan_list_lock);
+	/* Delete filter for the current MAC address, it could have
+	 * been changed by the PF via administratively set MAC.
+	 * Will be re-added via VIRTCHNL_OP_GET_VF_RESOURCES.
+	 */
+	list_for_each_entry_safe(f, ftmp, &adapter->mac_filter_list, list) {
+		if (ether_addr_equal(f->macaddr, adapter->hw.mac.addr)) {
+			list_del(&f->list);
+			kfree(f);
+		}
+	}
 	/* re-add all MAC filters */
 	list_for_each_entry(f, &adapter->mac_filter_list, list) {
 		f->add = true;

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c+3−0

 			ether_addr_copy(netdev->perm_addr,
 					adapter->hw.mac.addr);
 		}
+		spin_lock_bh(&adapter->mac_vlan_list_lock);
+		iavf_add_filter(adapter, adapter->hw.mac.addr);
+		spin_unlock_bh(&adapter->mac_vlan_list_lock);
 		iavf_process_config(adapter);
 		}
 		break;

drivers/net/ethernet/intel/igb/e1000_82575.c+2−6

 		dev_spec->module_plugged = true;
 		if (eth_flags->e1000_base_lx || eth_flags->e1000_base_sx) {
 			hw->phy.media_type = e1000_media_type_internal_serdes;
-		} else if (eth_flags->e100_base_fx) {
+		} else if (eth_flags->e100_base_fx || eth_flags->e100_base_lx) {
 			dev_spec->sgmii_active = true;
 			hw->phy.media_type = e1000_media_type_internal_serdes;
 		} else if (eth_flags->e1000_base_t) {
 			break;
 		}
-		/* do not change link mode for 100BaseFX */
-		if (dev_spec->eth_flags.e100_base_fx)
-			break;
 		/* change current link mode setting */
 		ctrl_ext &= ~E1000_CTRL_EXT_LINK_MODE_MASK;
-		if (hw->phy.media_type == e1000_media_type_copper)
+		if (dev_spec->sgmii_active)
 			ctrl_ext |= E1000_CTRL_EXT_LINK_MODE_SGMII;
 		else
 			ctrl_ext |= E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES;

drivers/net/ethernet/intel/igb/igb_ethtool.c+1−1

@@ -181,7 +181,7 @@ static int igb_get_link_ksettings(struct net_device *netdev, · 180 unmodified lines
181	advertising &= ~ADVERTISED_1000baseKX_Full;	181	advertising &= ~ADVERTISED_1000baseKX_Full;
182	}	182	}
183	}	183	}
184	if (eth_flags->e100_base_fx) {	184	if (eth_flags->e100_base_fx \|\| eth_flags->e100_base_lx) {
185	supported \|= SUPPORTED_100baseT_Full;	185	supported \|= SUPPORTED_100baseT_Full;
186	advertising \|= ADVERTISED_100baseT_Full;	186	advertising \|= ADVERTISED_100baseT_Full;
187	}	187	}

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c+27−10

 	struct ixgbe_hw *hw = &adapter->hw;
 	struct hlist_node *node2;
 	struct ixgbe_fdir_filter *filter;
-	u64 action;
+	u8 queue;
 	spin_lock(&adapter->fdir_perfect_lock);
 	hlist_for_each_entry_safe(filter, node2,
 				  &adapter->fdir_filter_list, fdir_node) {
-		action = filter->action;
+		if (filter->action == IXGBE_FDIR_DROP_QUEUE) {
-		if (action != IXGBE_FDIR_DROP_QUEUE && action != 0)
+			queue = IXGBE_FDIR_DROP_QUEUE;
-			action =
+		} else {
-			(action >> ETHTOOL_RX_FLOW_SPEC_RING_VF_OFF) - 1;
+			u32 ring = ethtool_get_flow_spec_ring(filter->action);
+			u8 vf = ethtool_get_flow_spec_ring_vf(filter->action);
+			if (!vf && (ring >= adapter->num_rx_queues)) {
+				e_err(drv, "FDIR restore failed without VF, ring: %u\n",
+				      ring);
+				continue;
+			} else if (vf &&
+				   ((vf > adapter->num_vfs) ||
+				     ring >= adapter->num_rx_queues_per_pool)) {
+				e_err(drv, "FDIR restore failed with VF, vf: %hhu, ring: %u\n",
+				      vf, ring);
+				continue;
+			}
+			/* Map the ring onto the absolute queue index */
+			if (!vf)
+				queue = adapter->rx_ring[ring]->reg_idx;
+			else
+				queue = ((vf - 1) *
+					adapter->num_rx_queues_per_pool) + ring;
+		}
 		ixgbe_fdir_write_perfect_filter_82599(hw,
-				&filter->filter,
+				&filter->filter, filter->sw_idx, queue);
-				filter->sw_idx,
-				(action == IXGBE_FDIR_DROP_QUEUE) ?
-				IXGBE_FDIR_DROP_QUEUE :
-				adapter->rx_ring[action]->reg_idx);
 	}
 	spin_unlock(&adapter->fdir_perfect_lock);

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

 	struct ixgbe_hw *hw = &adapter->hw;
 	int count = 0;
-	if ((netdev_uc_count(netdev)) > 10) {
-		pr_err("Too many unicast filters - No Space\n");
-		return -ENOSPC;
-	}
 	if (!netdev_uc_empty(netdev)) {
 		struct netdev_hw_addr *ha;

drivers/net/ethernet/marvell/mvneta.c+10−9

 mvneta_run_xdp(struct mvneta_port *pp, struct mvneta_rx_queue *rxq,
 	       struct bpf_prog *prog, struct xdp_buff *xdp)
 {
-	u32 ret, act = bpf_prog_run_xdp(prog, xdp);
+	unsigned int len;
+	u32 ret, act;
+	len = xdp->data_end - xdp->data_hard_start - pp->rx_offset_correction;
+	act = bpf_prog_run_xdp(prog, xdp);
 	switch (act) {
 	case XDP_PASS:
 		if (err) {
 			ret = MVNETA_XDP_DROPPED;
 			__page_pool_put_page(rxq->page_pool,
-					virt_to_head_page(xdp->data),
+					     virt_to_head_page(xdp->data),
-					xdp->data_end - xdp->data_hard_start,
+					     len, true);
-					true);
 		} else {
 			ret = MVNETA_XDP_REDIR;
 		}
 		ret = mvneta_xdp_xmit_back(pp, xdp);
 		if (ret != MVNETA_XDP_TX)
 			__page_pool_put_page(rxq->page_pool,
-					virt_to_head_page(xdp->data),
+					     virt_to_head_page(xdp->data),
-					xdp->data_end - xdp->data_hard_start,
+					     len, true);
-					true);
 		break;
 	default:
 		bpf_warn_invalid_xdp_action(act);
 	case XDP_DROP:
 		__page_pool_put_page(rxq->page_pool,
 				     virt_to_head_page(xdp->data),
-				     xdp->data_end - xdp->data_hard_start,
+				     len, true);
-				     true);
 		ret = MVNETA_XDP_DROPPED;
 		break;
 	}

drivers/net/ethernet/mellanox/mlx4/crdump.c+1−1

@@ -182,7 +182,7 @@ int mlx4_crdump_collect(struct mlx4_dev *dev) · 181 unmodified lines
182	crdump_enable_crspace_access(dev, cr_space);	182	crdump_enable_crspace_access(dev, cr_space);
183		183
184	/* Get the available snapshot ID for the dumps */	184	/* Get the available snapshot ID for the dumps */
185	id = devlink_region_shapshot_id_get(devlink);	185	id = devlink_region_snapshot_id_get(devlink);
186		186
187	/* Try to capture dumps */	187	/* Try to capture dumps */
188	mlx4_crdump_collect_crspace(dev, cr_space, id);	188	mlx4_crdump_collect_crspace(dev, cr_space, id);

drivers/net/ethernet/mellanox/mlxsw/spectrum.c+41−13

 	u64 len;
 	int err;
+	if (skb_cow_head(skb, MLXSW_TXHDR_LEN)) {
+		this_cpu_inc(mlxsw_sp_port->pcpu_stats->tx_dropped);
+		dev_kfree_skb_any(skb);
+		return NETDEV_TX_OK;
+	}
 	memset(skb->cb, 0, sizeof(struct mlxsw_skb_cb));
 	if (mlxsw_core_skb_transmit_busy(mlxsw_sp->core, &tx_info))
 		return NETDEV_TX_BUSY;
-	if (unlikely(skb_headroom(skb) < MLXSW_TXHDR_LEN)) {
-		struct sk_buff *skb_orig = skb;
-		skb = skb_realloc_headroom(skb, MLXSW_TXHDR_LEN);
-		if (!skb) {
-			this_cpu_inc(mlxsw_sp_port->pcpu_stats->tx_dropped);
-			dev_kfree_skb_any(skb_orig);
-			return NETDEV_TX_OK;
-		}
-		dev_consume_skb_any(skb_orig);
-	}
 	if (eth_skb_pad(skb)) {
 		this_cpu_inc(mlxsw_sp_port->pcpu_stats->tx_dropped);
 		return NETDEV_TX_OK;
 			     periodic_hw_stats.update_dw.work);
 	if (!netif_carrier_ok(mlxsw_sp_port->dev))
+		/* Note: mlxsw_sp_port_down_wipe_counters() clears the cache as
+		 * necessary when port goes down.
+		 */
 		goto out;
 	mlxsw_sp_port_get_hw_stats(mlxsw_sp_port->dev,
 	return 0;
 }
+static void
+mlxsw_sp_port_down_wipe_counters(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+	int i;
+	for (i = 0; i < TC_MAX_QUEUE; i++)
+		mlxsw_sp_port->periodic_hw_stats.xstats.backlog[i] = 0;
+}
 static void mlxsw_sp_pude_event_func(const struct mlxsw_reg_info *reg,
 				     char *pude_pl, void *priv)
 {
 	} else {
 		netdev_info(mlxsw_sp_port->dev, "link down\n");
 		netif_carrier_off(mlxsw_sp_port->dev);
+		mlxsw_sp_port_down_wipe_counters(mlxsw_sp_port);
 	}
 }
 	return mlxsw_sp_init(mlxsw_core, mlxsw_bus_info, extack);
 }
+static int mlxsw_sp3_init(struct mlxsw_core *mlxsw_core,
+			  const struct mlxsw_bus_info *mlxsw_bus_info,
+			  struct netlink_ext_ack *extack)
+{
+	struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
+	mlxsw_sp->kvdl_ops = &mlxsw_sp2_kvdl_ops;
+	mlxsw_sp->afa_ops = &mlxsw_sp2_act_afa_ops;
+	mlxsw_sp->afk_ops = &mlxsw_sp2_afk_ops;
+	mlxsw_sp->mr_tcam_ops = &mlxsw_sp2_mr_tcam_ops;
+	mlxsw_sp->acl_tcam_ops = &mlxsw_sp2_acl_tcam_ops;
+	mlxsw_sp->nve_ops_arr = mlxsw_sp2_nve_ops_arr;
+	mlxsw_sp->mac_mask = mlxsw_sp2_mac_mask;
+	mlxsw_sp->rif_ops_arr = mlxsw_sp2_rif_ops_arr;
+	mlxsw_sp->sb_vals = &mlxsw_sp2_sb_vals;
+	mlxsw_sp->port_type_speed_ops = &mlxsw_sp2_port_type_speed_ops;
+	mlxsw_sp->ptp_ops = &mlxsw_sp2_ptp_ops;
+	return mlxsw_sp_init(mlxsw_core, mlxsw_bus_info, extack);
+}
 static void mlxsw_sp_fini(struct mlxsw_core *mlxsw_core)
 {
 	struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
 static struct mlxsw_driver mlxsw_sp3_driver = {
 	.kind				= mlxsw_sp3_driver_name,
 	.priv_size			= sizeof(struct mlxsw_sp),
-	.init				= mlxsw_sp2_init,
+	.init				= mlxsw_sp3_init,
 	.fini				= mlxsw_sp_fini,
 	.basic_trap_groups_set		= mlxsw_sp_basic_trap_groups_set,
 	.port_split			= mlxsw_sp_port_split,

drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c+23−7

 	return -EOPNOTSUPP;
 }
+static u64
+mlxsw_sp_xstats_backlog(struct mlxsw_sp_port_xstats *xstats, int tclass_num)
+{
+	return xstats->backlog[tclass_num] +
+	       xstats->backlog[tclass_num + 8];
+}
+static u64
+mlxsw_sp_xstats_tail_drop(struct mlxsw_sp_port_xstats *xstats, int tclass_num)
+{
+	return xstats->tail_drop[tclass_num] +
+	       xstats->tail_drop[tclass_num + 8];
+}
 static void
 mlxsw_sp_qdisc_bstats_per_priority_get(struct mlxsw_sp_port_xstats *xstats,
 				       u8 prio_bitmap, u64 *tx_packets,
 					       &stats_base->tx_bytes);
 	red_base->prob_mark = xstats->ecn;
 	red_base->prob_drop = xstats->wred_drop[tclass_num];
-	red_base->pdrop = xstats->tail_drop[tclass_num];
+	red_base->pdrop = mlxsw_sp_xstats_tail_drop(xstats, tclass_num);
 	stats_base->overlimits = red_base->prob_drop + red_base->prob_mark;
 	stats_base->drops = red_base->prob_drop + red_base->pdrop;
 	early_drops = xstats->wred_drop[tclass_num] - xstats_base->prob_drop;
 	marks = xstats->ecn - xstats_base->prob_mark;
-	pdrops = xstats->tail_drop[tclass_num] - xstats_base->pdrop;
+	pdrops = mlxsw_sp_xstats_tail_drop(xstats, tclass_num) -
+		 xstats_base->pdrop;
 	res->pdrop += pdrops;
 	res->prob_drop += early_drops;
 	overlimits = xstats->wred_drop[tclass_num] + xstats->ecn -
 		     stats_base->overlimits;
-	drops = xstats->wred_drop[tclass_num] + xstats->tail_drop[tclass_num] -
+	drops = xstats->wred_drop[tclass_num] +
+		mlxsw_sp_xstats_tail_drop(xstats, tclass_num) -
 		stats_base->drops;
-	backlog = xstats->backlog[tclass_num];
+	backlog = mlxsw_sp_xstats_backlog(xstats, tclass_num);
 	_bstats_update(stats_ptr->bstats, tx_bytes, tx_packets);
 	stats_ptr->qstats->overlimits += overlimits;
 	tx_packets = stats->tx_packets - stats_base->tx_packets;
 	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
-		drops += xstats->tail_drop[i];
+		drops += mlxsw_sp_xstats_tail_drop(xstats, i);
 		drops += xstats->wred_drop[i];
-		backlog += xstats->backlog[i];
+		backlog += mlxsw_sp_xstats_backlog(xstats, i);
 	}
 	drops = drops - stats_base->drops;
 	stats_base->drops = 0;
 	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
-		stats_base->drops += xstats->tail_drop[i];
+		stats_base->drops += mlxsw_sp_xstats_tail_drop(xstats, i);
 		stats_base->drops += xstats->wred_drop[i];
 	}

drivers/net/ethernet/mellanox/mlxsw/switchx2.c+6−11

 	u64 len;
 	int err;
+	if (skb_cow_head(skb, MLXSW_TXHDR_LEN)) {
+		this_cpu_inc(mlxsw_sx_port->pcpu_stats->tx_dropped);
+		dev_kfree_skb_any(skb);
+		return NETDEV_TX_OK;
+	}
 	memset(skb->cb, 0, sizeof(struct mlxsw_skb_cb));
 	if (mlxsw_core_skb_transmit_busy(mlxsw_sx->core, &tx_info))
 		return NETDEV_TX_BUSY;
-	if (unlikely(skb_headroom(skb) < MLXSW_TXHDR_LEN)) {
-		struct sk_buff *skb_orig = skb;
-		skb = skb_realloc_headroom(skb, MLXSW_TXHDR_LEN);
-		if (!skb) {
-			this_cpu_inc(mlxsw_sx_port->pcpu_stats->tx_dropped);
-			dev_kfree_skb_any(skb_orig);
-			return NETDEV_TX_OK;
-		}
-		dev_consume_skb_any(skb_orig);
-	}
 	mlxsw_sx_txhdr_construct(skb, &tx_info);
 	/* TX header is consumed by HW on the way so we shouldn't count its
 	 * bytes as being sent.

drivers/net/ethernet/renesas/sh_eth.c+21−17

@@ -2204,24 +2204,28 @@ static size_t __sh_eth_get_regs(struct net_device ndev, u32 buf) · 2203 unmodified lines
2204	if (cd->tsu) {	2204	if (cd->tsu) {
2205	add_tsu_reg(ARSTR);	2205	add_tsu_reg(ARSTR);
2206	add_tsu_reg(TSU_CTRST);	2206	add_tsu_reg(TSU_CTRST);
2207	add_tsu_reg(TSU_FWEN0);	2207	if (cd->dual_port) {
2208	add_tsu_reg(TSU_FWEN1);	2208	add_tsu_reg(TSU_FWEN0);
2209	add_tsu_reg(TSU_FCM);	2209	add_tsu_reg(TSU_FWEN1);
2210	add_tsu_reg(TSU_BSYSL0);	2210	add_tsu_reg(TSU_FCM);
2211	add_tsu_reg(TSU_BSYSL1);	2211	add_tsu_reg(TSU_BSYSL0);
2212	add_tsu_reg(TSU_PRISL0);	2212	add_tsu_reg(TSU_BSYSL1);
2213	add_tsu_reg(TSU_PRISL1);	2213	add_tsu_reg(TSU_PRISL0);
2214	add_tsu_reg(TSU_FWSL0);	2214	add_tsu_reg(TSU_PRISL1);
2215	add_tsu_reg(TSU_FWSL1);	2215	add_tsu_reg(TSU_FWSL0);
		2216	add_tsu_reg(TSU_FWSL1);
		2217	}
2216	add_tsu_reg(TSU_FWSLC);	2218	add_tsu_reg(TSU_FWSLC);
2217	add_tsu_reg(TSU_QTAGM0);	2219	if (cd->dual_port) {
2218	add_tsu_reg(TSU_QTAGM1);	2220	add_tsu_reg(TSU_QTAGM0);
2219	add_tsu_reg(TSU_FWSR);	2221	add_tsu_reg(TSU_QTAGM1);
2220	add_tsu_reg(TSU_FWINMK);	2222	add_tsu_reg(TSU_FWSR);
2221	add_tsu_reg(TSU_ADQT0);	2223	add_tsu_reg(TSU_FWINMK);
2222	add_tsu_reg(TSU_ADQT1);	2224	add_tsu_reg(TSU_ADQT0);
2223	add_tsu_reg(TSU_VTAG0);	2225	add_tsu_reg(TSU_ADQT1);
2224	add_tsu_reg(TSU_VTAG1);	2226	add_tsu_reg(TSU_VTAG0);
		2227	add_tsu_reg(TSU_VTAG1);
		2228	}
2225	add_tsu_reg(TSU_ADSBSY);	2229	add_tsu_reg(TSU_ADSBSY);
2226	add_tsu_reg(TSU_TEN);	2230	add_tsu_reg(TSU_TEN);
2227	add_tsu_reg(TSU_POST1);	2231	add_tsu_reg(TSU_POST1);

drivers/net/ethernet/socionext/sni_ave.c+13−7

 		phy_ethtool_get_wol(ndev->phydev, wol);
 }
-static int ave_ethtool_set_wol(struct net_device *ndev,
+static int __ave_ethtool_set_wol(struct net_device *ndev,
-			       struct ethtool_wolinfo *wol)
+				 struct ethtool_wolinfo *wol)
 {
-	int ret;
 	if (!ndev->phydev ||
 	    (wol->wolopts & (WAKE_ARP | WAKE_MAGICSECURE)))
 		return -EOPNOTSUPP;
-	ret = phy_ethtool_set_wol(ndev->phydev, wol);
+	return phy_ethtool_set_wol(ndev->phydev, wol);
+}
+static int ave_ethtool_set_wol(struct net_device *ndev,
+			       struct ethtool_wolinfo *wol)
+{
+	int ret;
+	ret = __ave_ethtool_set_wol(ndev, wol);
 	if (!ret)
 		device_set_wakeup_enable(&ndev->dev, !!wol->wolopts);
 	/* set wol initial state disabled */
 	wol.wolopts = 0;
-	ave_ethtool_set_wol(ndev, &wol);
+	__ave_ethtool_set_wol(ndev, &wol);
 	if (!phy_interface_is_rgmii(phydev))
 		phy_set_max_speed(phydev, SPEED_100);
 	ave_ethtool_get_wol(ndev, &wol);
 	wol.wolopts = priv->wolopts;
-	ave_ethtool_set_wol(ndev, &wol);
+	__ave_ethtool_set_wol(ndev, &wol);
 	if (ndev->phydev) {
 		ret = phy_resume(ndev->phydev);

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c+36−16

 	if (attr->max_size && (attr->max_size > size))
 		size = attr->max_size;
-	skb = netdev_alloc_skb_ip_align(priv->dev, size);
+	skb = netdev_alloc_skb(priv->dev, size);
 	if (!skb)
 		return NULL;
 					 struct net_device *orig_ndev)
 {
 	struct stmmac_test_priv *tpriv = pt->af_packet_priv;
+	unsigned char *src = tpriv->packet->src;
+	unsigned char *dst = tpriv->packet->dst;
 	struct stmmachdr *shdr;
 	struct ethhdr *ehdr;
 	struct udphdr *uhdr;
 		goto out;
 	ehdr = (struct ethhdr *)skb_mac_header(skb);
-	if (tpriv->packet->dst) {
+	if (dst) {
-		if (!ether_addr_equal(ehdr->h_dest, tpriv->packet->dst))
+		if (!ether_addr_equal_unaligned(ehdr->h_dest, dst))
 			goto out;
 	}
 	if (tpriv->packet->sarc) {
-		if (!ether_addr_equal(ehdr->h_source, ehdr->h_dest))
+		if (!ether_addr_equal_unaligned(ehdr->h_source, ehdr->h_dest))
 			goto out;
-	} else if (tpriv->packet->src) {
+	} else if (src) {
-		if (!ether_addr_equal(ehdr->h_source, tpriv->packet->src))
+		if (!ether_addr_equal_unaligned(ehdr->h_source, src))
 			goto out;
 	}
 	struct ethhdr *ehdr;
 	ehdr = (struct ethhdr *)skb_mac_header(skb);
-	if (!ether_addr_equal(ehdr->h_source, orig_ndev->dev_addr))
+	if (!ether_addr_equal_unaligned(ehdr->h_source, orig_ndev->dev_addr))
 		goto out;
 	if (ehdr->h_proto != htons(ETH_P_PAUSE))
 		goto out;
 	if (tpriv->vlan_id) {
 		if (skb->vlan_proto != htons(proto))
 			goto out;
-		if (skb->vlan_tci != tpriv->vlan_id)
+		if (skb->vlan_tci != tpriv->vlan_id) {
+			/* Means filter did not work. */
+			tpriv->ok = false;
+			complete(&tpriv->comp);
 			goto out;
+		}
 	}
 	ehdr = (struct ethhdr *)skb_mac_header(skb);
-	if (!ether_addr_equal(ehdr->h_dest, tpriv->packet->dst))
+	if (!ether_addr_equal_unaligned(ehdr->h_dest, tpriv->packet->dst))
 		goto out;
 	ihdr = ip_hdr(skb);
 {
 	int ret, prev_cap = priv->dma_cap.vlhash;
+	if (!(priv->dev->features & NETIF_F_HW_VLAN_CTAG_FILTER))
+		return -EOPNOTSUPP;
 	priv->dma_cap.vlhash = 0;
 	ret = __stmmac_test_vlanfilt(priv);
 	priv->dma_cap.vlhash = prev_cap;
 {
 	int ret, prev_cap = priv->dma_cap.vlhash;
+	if (!(priv->dev->features & NETIF_F_HW_VLAN_STAG_FILTER))
+		return -EOPNOTSUPP;
 	priv->dma_cap.vlhash = 0;
 	ret = __stmmac_test_dvlanfilt(priv);
 	priv->dma_cap.vlhash = prev_cap;
 	struct stmmac_packet_attrs attr = { };
 	struct flow_dissector *dissector;
 	struct flow_cls_offload *cls;
+	int ret, old_enable = 0;
 	struct flow_rule *rule;
-	int ret;
 	if (!tc_can_offload(priv->dev))
 		return -EOPNOTSUPP;
 	if (!priv->dma_cap.l3l4fnum)
 		return -EOPNOTSUPP;
-	if (priv->rss.enable)
+	if (priv->rss.enable) {
+		old_enable = priv->rss.enable;
+		priv->rss.enable = false;
 		stmmac_rss_configure(priv, priv->hw, NULL,
 				     priv->plat->rx_queues_to_use);
+	}
 	dissector = kzalloc(sizeof(*dissector), GFP_KERNEL);
 	if (!dissector) {
 cleanup_dissector:
 	kfree(dissector);
 cleanup_rss:
-	if (priv->rss.enable) {
+	if (old_enable) {
+		priv->rss.enable = old_enable;
 		stmmac_rss_configure(priv, priv->hw, &priv->rss,
 				     priv->plat->rx_queues_to_use);
 	}
 	struct stmmac_packet_attrs attr = { };
 	struct flow_dissector *dissector;
 	struct flow_cls_offload *cls;
+	int ret, old_enable = 0;
 	struct flow_rule *rule;
-	int ret;
 	if (!tc_can_offload(priv->dev))
 		return -EOPNOTSUPP;
 	if (!priv->dma_cap.l3l4fnum)
 		return -EOPNOTSUPP;
-	if (priv->rss.enable)
+	if (priv->rss.enable) {
+		old_enable = priv->rss.enable;
+		priv->rss.enable = false;
 		stmmac_rss_configure(priv, priv->hw, NULL,
 				     priv->plat->rx_queues_to_use);
+	}
 	dissector = kzalloc(sizeof(*dissector), GFP_KERNEL);
 	if (!dissector) {
 cleanup_dissector:
 	kfree(dissector);
 cleanup_rss:
-	if (priv->rss.enable) {
+	if (old_enable) {
+		priv->rss.enable = old_enable;
 		stmmac_rss_configure(priv, priv->hw, &priv->rss,
 				     priv->plat->rx_queues_to_use);
 	}
 	struct arphdr *ahdr;
 	ehdr = (struct ethhdr *)skb_mac_header(skb);
-	if (!ether_addr_equal(ehdr->h_dest, tpriv->packet->src))
+	if (!ether_addr_equal_unaligned(ehdr->h_dest, tpriv->packet->src))
 		goto out;
 	ahdr = arp_hdr(skb);

drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c+4−0

 {
 	int ret = 0;
+	/* When RSS is enabled, the filtering will be bypassed */
+	if (priv->rss.enable)
+		return -EBUSY;
 	switch (cls->command) {
 	case FLOW_CLS_REPLACE:
 		ret = tc_add_flow(priv, cls);

drivers/net/hyperv/rndis_filter.c+0−2

@@ -1443,8 +1443,6 @@ void rndis_filter_device_remove(struct hv_device *dev, · 1442 unmodified lines
1443	/* Halt and release the rndis device */	1443	/* Halt and release the rndis device */
1444	rndis_filter_halt_device(net_dev, rndis_dev);	1444	rndis_filter_halt_device(net_dev, rndis_dev);
1445		1445
1446	net_dev->extension = NULL;
1447
1448	netvsc_device_remove(dev);	1446	netvsc_device_remove(dev);
1449	}	1447	}
1450		1448

drivers/net/macvlan.c+3−2

 			      struct net_device *src,
 			      enum macvlan_mode mode)
 {
-	const struct ethhdr *eth = skb_eth_hdr(skb);
+	const struct ethhdr *eth = eth_hdr(skb);
 	const struct macvlan_dev *vlan;
 	struct sk_buff *nskb;
 	unsigned int i;
 	const struct macvlan_dev *dest;
 	if (vlan->mode == MACVLAN_MODE_BRIDGE) {
-		const struct ethhdr *eth = (void *)skb->data;
+		const struct ethhdr *eth = skb_eth_hdr(skb);
 		/* send to other bridge ports directly */
 		if (is_multicast_ether_addr(eth->h_dest)) {
+			skb_reset_mac_header(skb);
 			macvlan_broadcast(skb, port, dev, MACVLAN_MODE_BRIDGE);
 			goto xmit_world;
 		}

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

@@ -53,7 +53,7 @@ static ssize_t nsim_dev_take_snapshot_write(struct file *file, · 52 unmodified lines
53		53
54	get_random_bytes(dummy_data, NSIM_DEV_DUMMY_REGION_SIZE);	54	get_random_bytes(dummy_data, NSIM_DEV_DUMMY_REGION_SIZE);
55		55
56	id = devlink_region_shapshot_id_get(priv_to_devlink(nsim_dev));	56	id = devlink_region_snapshot_id_get(priv_to_devlink(nsim_dev));
57	err = devlink_region_snapshot_create(nsim_dev->dummy_region,	57	err = devlink_region_snapshot_create(nsim_dev->dummy_region,
58	dummy_data, id, kfree);	58	dummy_data, id, kfree);
59	if (err) {	59	if (err) {

drivers/net/phy/Kconfig+4−4

@@ -340,14 +340,14 @@ config DAVICOM_PHY · 339 unmodified lines
340	Currently supports dm9161e and dm9131	340	Currently supports dm9161e and dm9131
341		341
342	config DP83822_PHY	342	config DP83822_PHY
343	tristate "Texas Instruments DP83822 PHY"	343	tristate "Texas Instruments DP83822/825 PHYs"
344	---help---	344	---help---
345	Supports the DP83822 PHY.	345	Supports the DP83822 and DP83825I PHYs.
346		346
347	config DP83TC811_PHY	347	config DP83TC811_PHY
348	tristate "Texas Instruments DP83TC822 PHY"	348	tristate "Texas Instruments DP83TC811 PHY"
349	---help---	349	---help---
350	Supports the DP83TC822 PHY.	350	Supports the DP83TC811 PHY.
351		351
352	config DP83848_PHY	352	config DP83848_PHY
353	tristate "Texas Instruments DP83848 PHY"	353	tristate "Texas Instruments DP83848 PHY"

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

 #define DP83867_PHYCR_FIFO_DEPTH_MAX		0x03
 #define DP83867_PHYCR_FIFO_DEPTH_MASK		GENMASK(15, 14)
 #define DP83867_PHYCR_RESERVED_MASK		BIT(11)
+#define DP83867_PHYCR_FORCE_LINK_GOOD		BIT(10)
 /* RGMIIDCTL bits */
 #define DP83867_RGMII_TX_CLK_DELAY_MAX		0xf
 	usleep_range(10, 20);
-	return 0;
+	/* After reset FORCE_LINK_GOOD bit is set. Although the
+	 * default value should be unset. Disable FORCE_LINK_GOOD
+	 * for the phy to work properly.
+	 */
+	return phy_modify(phydev, MII_DP83867_PHYCTRL,
+			 DP83867_PHYCR_FORCE_LINK_GOOD, 0);
 }
 static struct phy_driver dp83867_driver[] = {

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

@@ -3750,6 +3750,7 @@ static int lan78xx_probe(struct usb_interface *intf, · 3749 unmodified lines
3750		3750
3751	/* MTU range: 68 - 9000 */	3751	/* MTU range: 68 - 9000 */
3752	netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;	3752	netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
		3753	netif_set_gso_max_size(netdev, MAX_SINGLE_PACKET_SIZE - MAX_HEADER);
3753		3754
3754	dev->ep_blkin = (intf->cur_altsetting)->endpoint + 0;	3755	dev->ep_blkin = (intf->cur_altsetting)->endpoint + 0;
3755	dev->ep_blkout = (intf->cur_altsetting)->endpoint + 1;	3756	dev->ep_blkout = (intf->cur_altsetting)->endpoint + 1;

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

@@ -1062,6 +1062,7 @@ static const struct usb_device_id products[] = { · 1061 unmodified lines
1062	{QMI_QUIRK_QUECTEL_DYNCFG(0x2c7c, 0x0125)}, /* Quectel EC25, EC20 R2.0 Mini PCIe */	1062	{QMI_QUIRK_QUECTEL_DYNCFG(0x2c7c, 0x0125)}, /* Quectel EC25, EC20 R2.0 Mini PCIe */
1063	{QMI_QUIRK_QUECTEL_DYNCFG(0x2c7c, 0x0306)}, /* Quectel EP06/EG06/EM06 */	1063	{QMI_QUIRK_QUECTEL_DYNCFG(0x2c7c, 0x0306)}, /* Quectel EP06/EG06/EM06 */
1064	{QMI_QUIRK_QUECTEL_DYNCFG(0x2c7c, 0x0512)}, /* Quectel EG12/EM12 */	1064	{QMI_QUIRK_QUECTEL_DYNCFG(0x2c7c, 0x0512)}, /* Quectel EG12/EM12 */
		1065	{QMI_QUIRK_QUECTEL_DYNCFG(0x2c7c, 0x0800)}, /* Quectel RM500Q-GL */
1065		1066
1066	/* 3. Combined interface devices matching on interface number */	1067	/* 3. Combined interface devices matching on interface number */
1067	{QMI_FIXED_INTF(0x0408, 0xea42, 4)}, /* Yota / Megafon M100-1 */	1068	{QMI_FIXED_INTF(0x0408, 0xea42, 4)}, /* Yota / Megafon M100-1 */

drivers/net/usb/r8152.c+3−0

@@ -6597,6 +6597,9 @@ static int rtl8152_probe(struct usb_interface *intf, · 6596 unmodified lines
6597	return -ENODEV;	6597	return -ENODEV;
6598	}	6598	}
6599		6599
		6600	if (intf->cur_altsetting->desc.bNumEndpoints < 3)
		6601	return -ENODEV;
		6602
6600	usb_reset_device(udev);	6603	usb_reset_device(udev);
6601	netdev = alloc_etherdev(sizeof(struct r8152));	6604	netdev = alloc_etherdev(sizeof(struct r8152));
6602	if (!netdev) {	6605	if (!netdev) {

drivers/net/wan/fsl_ucc_hdlc.c+1−1

@@ -73,7 +73,7 @@ static struct ucc_tdm_info utdm_primary_info = { · 72 unmodified lines
73	},	73	},
74	};	74	};
75		75
76	static struct ucc_tdm_info utdm_info[MAX_HDLC_NUM];	76	static struct ucc_tdm_info utdm_info[UCC_MAX_NUM];
77		77
78	static int uhdlc_init(struct ucc_hdlc_private *priv)	78	static int uhdlc_init(struct ucc_hdlc_private *priv)
79	{	79	{

drivers/net/wan/lapbether.c+1−1

@@ -64,7 +64,7 @@ static struct lapbethdev lapbeth_get_x25_dev(struct net_device dev) · 63 unmodified lines
64	{	64	{
65	struct lapbethdev *lapbeth;	65	struct lapbethdev *lapbeth;
66		66
67	list_for_each_entry_rcu(lapbeth, &lapbeth_devices, node) {	67	list_for_each_entry_rcu(lapbeth, &lapbeth_devices, node, lockdep_rtnl_is_held()) {
68	if (lapbeth->ethdev == dev)	68	if (lapbeth->ethdev == dev)
69	return lapbeth;	69	return lapbeth;
70	}	70	}

drivers/nfc/pn533/usb.c+1−1

@@ -391,7 +391,7 @@ static int pn533_acr122_poweron_rdr(struct pn533_usb_phy *phy) · 390 unmodified lines
391	cmd, sizeof(cmd), false);	391	cmd, sizeof(cmd), false);
392		392
393	rc = usb_bulk_msg(phy->udev, phy->out_urb->pipe, buffer, sizeof(cmd),	393	rc = usb_bulk_msg(phy->udev, phy->out_urb->pipe, buffer, sizeof(cmd),
394	&transferred, 0);	394	&transferred, 5000);
395	kfree(buffer);	395	kfree(buffer);
396	if (rc \|\| (transferred != sizeof(cmd))) {	396	if (rc \|\| (transferred != sizeof(cmd))) {
397	nfc_err(&phy->udev->dev,	397	nfc_err(&phy->udev->dev,

drivers/platform/chrome/wilco_ec/keyboard_leds.c+20−8

 		return ret;
 	}
-	if (response->status) {
-		dev_err(ec->dev,
-			"EC reported failure sending keyboard LEDs command: %d",
-			response->status);
-		return -EIO;
-	}
 	return 0;
 }
 {
 	struct wilco_keyboard_leds_msg request;
 	struct wilco_keyboard_leds_msg response;
+	int ret;
 	memset(&request, 0, sizeof(request));
 	request.command = WILCO_EC_COMMAND_KBBL;
 	request.mode    = WILCO_KBBL_MODE_FLAG_PWM;
 	request.percent = brightness;
-	return send_kbbl_msg(ec, &request, &response);
+	ret = send_kbbl_msg(ec, &request, &response);
+	if (ret < 0)
+		return ret;
+	if (response.status) {
+		dev_err(ec->dev,
+			"EC reported failure sending keyboard LEDs command: %d",
+			response.status);
+		return -EIO;
+	}
+	return 0;
 }
 static int kbbl_exist(struct wilco_ec_device *ec, bool *exists)
 	if (ret < 0)
 		return ret;
+	if (response.status) {
+		dev_err(ec->dev,
+			"EC reported failure sending keyboard LEDs command: %d",
+			response.status);
+		return -EIO;
+	}
 	if (response.mode & WILCO_KBBL_MODE_FLAG_PWM)
 		return response.percent;

drivers/platform/mellanox/mlxbf-tmfifo.c+10−9

  * @work: work struct for deferred process
  * @timer: background timer
  * @vring: Tx/Rx ring
- * @spin_lock: spin lock
+ * @spin_lock: Tx/Rx spin lock
  * @is_ready: ready flag
  */
 struct mlxbf_tmfifo {
 	struct work_struct work;
 	struct timer_list timer;
 	struct mlxbf_tmfifo_vring *vring[2];
-	spinlock_t spin_lock;		/* spin lock */
+	spinlock_t spin_lock[2];	/* spin lock */
 	bool is_ready;
 };
 	writeq(*(u64 *)&hdr, fifo->tx_base + MLXBF_TMFIFO_TX_DATA);
 	/* Use spin-lock to protect the 'cons->tx_buf'. */
-	spin_lock_irqsave(&fifo->spin_lock, flags);
+	spin_lock_irqsave(&fifo->spin_lock[0], flags);
 	while (size > 0) {
 		addr = cons->tx_buf.buf + cons->tx_buf.tail;
 		}
 	}
-	spin_unlock_irqrestore(&fifo->spin_lock, flags);
+	spin_unlock_irqrestore(&fifo->spin_lock[0], flags);
 }
 /* Rx/Tx one word in the descriptor buffer. */
 		fifo->vring[is_rx] = NULL;
 		/* Notify upper layer that packet is done. */
-		spin_lock_irqsave(&fifo->spin_lock, flags);
+		spin_lock_irqsave(&fifo->spin_lock[is_rx], flags);
 		vring_interrupt(0, vring->vq);
-		spin_unlock_irqrestore(&fifo->spin_lock, flags);
+		spin_unlock_irqrestore(&fifo->spin_lock[is_rx], flags);
 	}
 mlxbf_tmfifo_desc_done:
 		 * worker handler.
 		 */
 		if (vring->vdev_id == VIRTIO_ID_CONSOLE) {
-			spin_lock_irqsave(&fifo->spin_lock, flags);
+			spin_lock_irqsave(&fifo->spin_lock[0], flags);
 			tm_vdev = fifo->vdev[VIRTIO_ID_CONSOLE];
 			mlxbf_tmfifo_console_output(tm_vdev, vring);
-			spin_unlock_irqrestore(&fifo->spin_lock, flags);
+			spin_unlock_irqrestore(&fifo->spin_lock[0], flags);
 		} else if (test_and_set_bit(MLXBF_TM_TX_LWM_IRQ,
 					    &fifo->pend_events)) {
 			return true;
 	if (!fifo)
 		return -ENOMEM;
-	spin_lock_init(&fifo->spin_lock);
+	spin_lock_init(&fifo->spin_lock[0]);
+	spin_lock_init(&fifo->spin_lock[1]);
 	INIT_WORK(&fifo->work, mlxbf_tmfifo_work_handler);
 	mutex_init(&fifo->lock);

drivers/platform/x86/asus-wmi.c+1−7

 {
 	int ctrl_param = 0;
-	/*
+	ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
-	 * bits 0-2: level
-	 * bit 7: light on/off
-	 */
-	if (asus->kbd_led_wk > 0)
-		ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
 	asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
 }

drivers/platform/x86/gpd-pocket-fan.c+20−7

 #define MAX_SPEED 3
-static int temp_limits[3] = { 55000, 60000, 65000 };
+#define TEMP_LIMIT0_DEFAULT	55000
+#define TEMP_LIMIT1_DEFAULT	60000
+#define TEMP_LIMIT2_DEFAULT	65000
+#define HYSTERESIS_DEFAULT	3000
+#define SPEED_ON_AC_DEFAULT	2
+static int temp_limits[3] = {
+	TEMP_LIMIT0_DEFAULT, TEMP_LIMIT1_DEFAULT, TEMP_LIMIT2_DEFAULT,
+};
 module_param_array(temp_limits, int, NULL, 0444);
 MODULE_PARM_DESC(temp_limits,
 		 "Millicelsius values above which the fan speed increases");
-static int hysteresis = 3000;
+static int hysteresis = HYSTERESIS_DEFAULT;
 module_param(hysteresis, int, 0444);
 MODULE_PARM_DESC(hysteresis,
 		 "Hysteresis in millicelsius before lowering the fan speed");
-static int speed_on_ac = 2;
+static int speed_on_ac = SPEED_ON_AC_DEFAULT;
 module_param(speed_on_ac, int, 0444);
 MODULE_PARM_DESC(speed_on_ac,
 		 "minimum fan speed to allow when system is powered by AC");
 	int i;
 	for (i = 0; i < ARRAY_SIZE(temp_limits); i++) {
-		if (temp_limits[i] < 40000 || temp_limits[i] > 70000) {
+		if (temp_limits[i] < 20000 || temp_limits[i] > 90000) {
 			dev_err(&pdev->dev, "Invalid temp-limit %d (must be between 40000 and 70000)\n",
 				temp_limits[i]);
-			return -EINVAL;
+			temp_limits[0] = TEMP_LIMIT0_DEFAULT;
+			temp_limits[1] = TEMP_LIMIT1_DEFAULT;
+			temp_limits[2] = TEMP_LIMIT2_DEFAULT;
+			break;
 		}
 	}
 	if (hysteresis < 1000 || hysteresis > 10000) {
 		dev_err(&pdev->dev, "Invalid hysteresis %d (must be between 1000 and 10000)\n",
 			hysteresis);
-		return -EINVAL;
+		hysteresis = HYSTERESIS_DEFAULT;
 	}
 	if (speed_on_ac < 0 || speed_on_ac > MAX_SPEED) {
 		dev_err(&pdev->dev, "Invalid speed_on_ac %d (must be between 0 and 3)\n",
 			speed_on_ac);
-		return -EINVAL;
+		speed_on_ac = SPEED_ON_AC_DEFAULT;
 	}
 	fan = devm_kzalloc(&pdev->dev, sizeof(*fan), GFP_KERNEL);

drivers/platform/x86/intel_ips.h+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/*	2	/*
3	* Copyright (c) 2010 Intel Corporation	3	* Copyright (c) 2010 Intel Corporation
4	*/	4	*/

drivers/platform/x86/intel_pmc_core.h+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/*	2	/*
3	* Intel Core SoC Power Management Controller Header File	3	* Intel Core SoC Power Management Controller Header File
4	*	4	*

drivers/platform/x86/intel_pmc_core_pltdrv.c+2−0

 	INTEL_CPU_FAM6(KABYLAKE, pmc_core_device),
 	INTEL_CPU_FAM6(CANNONLAKE_L, pmc_core_device),
 	INTEL_CPU_FAM6(ICELAKE_L, pmc_core_device),
+	INTEL_CPU_FAM6(COMETLAKE, pmc_core_device),
+	INTEL_CPU_FAM6(COMETLAKE_L, pmc_core_device),
 	{}
 };
 MODULE_DEVICE_TABLE(x86cpu, intel_pmc_core_platform_ids);

drivers/ptp/ptp_clock.c+2−2

 {
 	struct ptp_clock *ptp = container_of(dev, struct ptp_clock, dev);
+	ptp_cleanup_pin_groups(ptp);
 	mutex_destroy(&ptp->tsevq_mux);
 	mutex_destroy(&ptp->pincfg_mux);
 	ida_simple_remove(&ptp_clocks_map, ptp->index);
 	if (ptp->pps_source)
 		pps_unregister_source(ptp->pps_source);
-	ptp_cleanup_pin_groups(ptp);
 	posix_clock_unregister(&ptp->clock);
 	return 0;
 }
 EXPORT_SYMBOL(ptp_clock_unregister);

drivers/s390/crypto/ap_bus.c+0−2

@@ -793,8 +793,6 @@ static int ap_device_probe(struct device *dev) · 792 unmodified lines
793	drvres = ap_drv->flags & AP_DRIVER_FLAG_DEFAULT;	793	drvres = ap_drv->flags & AP_DRIVER_FLAG_DEFAULT;
794	if (!!devres != !!drvres)	794	if (!!devres != !!drvres)
795	return -ENODEV;	795	return -ENODEV;
796	/* (re-)init queue's state machine */
797	ap_queue_reinit_state(to_ap_queue(dev));
798	}	796	}
799		797
800	/* Add queue/card to list of active queues/cards */	798	/* Add queue/card to list of active queues/cards */

drivers/s390/crypto/ap_bus.h+1−1

@@ -261,7 +261,7 @@ void ap_queue_prepare_remove(struct ap_queue *aq); · 260 unmodified lines
261	void ap_queue_remove(struct ap_queue *aq);	261	void ap_queue_remove(struct ap_queue *aq);
262	void ap_queue_suspend(struct ap_device *ap_dev);	262	void ap_queue_suspend(struct ap_device *ap_dev);
263	void ap_queue_resume(struct ap_device *ap_dev);	263	void ap_queue_resume(struct ap_device *ap_dev);
264	void ap_queue_reinit_state(struct ap_queue *aq);	264	void ap_queue_init_state(struct ap_queue *aq);
265		265
266	struct ap_card *ap_card_create(int id, int queue_depth, int raw_device_type,	266	struct ap_card *ap_card_create(int id, int queue_depth, int raw_device_type,
267	int comp_device_type, unsigned int functions);	267	int comp_device_type, unsigned int functions);

drivers/s390/crypto/ap_queue.c+3−2

 	aq->ap_dev.device.type = &ap_queue_type;
 	aq->ap_dev.device_type = device_type;
 	aq->qid = qid;
-	aq->state = AP_STATE_RESET_START;
+	aq->state = AP_STATE_UNBOUND;
 	aq->interrupt = AP_INTR_DISABLED;
 	spin_lock_init(&aq->lock);
 	INIT_LIST_HEAD(&aq->list);
 	spin_unlock_bh(&aq->lock);
 }
-void ap_queue_reinit_state(struct ap_queue *aq)
+void ap_queue_init_state(struct ap_queue *aq)
 {
 	spin_lock_bh(&aq->lock);
 	aq->state = AP_STATE_RESET_START;
 	ap_wait(ap_sm_event(aq, AP_EVENT_POLL));
 	spin_unlock_bh(&aq->lock);
 }
+EXPORT_SYMBOL(ap_queue_init_state);

drivers/s390/crypto/zcrypt_ccamisc.c+2−2

@@ -1037,8 +1037,8 @@ static int _ip_cprb_helper(u16 cardnr, u16 domain, · 1036 unmodified lines
1037	prepparm = (struct iprepparm *) prepcblk->rpl_parmb;	1037	prepparm = (struct iprepparm *) prepcblk->rpl_parmb;
1038		1038
1039	/* do some plausibility checks on the key block */	1039	/* do some plausibility checks on the key block */
1040	if (prepparm->kb.len < 120 + 5 * sizeof(uint16_t) \|\|	1040	if (prepparm->kb.len < 120 + 3 * sizeof(uint16_t) \|\|
1041	prepparm->kb.len > 136 + 5 * sizeof(uint16_t)) {	1041	prepparm->kb.len > 136 + 3 * sizeof(uint16_t)) {
1042	DEBUG_ERR("%s reply with invalid or unknown key block\n",	1042	DEBUG_ERR("%s reply with invalid or unknown key block\n",
1043	__func__);	1043	__func__);
1044	rc = -EIO;	1044	rc = -EIO;

drivers/s390/crypto/zcrypt_cex2a.c+1−0

@@ -175,6 +175,7 @@ static int zcrypt_cex2a_queue_probe(struct ap_device *ap_dev) · 174 unmodified lines
175	zq->queue = aq;	175	zq->queue = aq;
176	zq->online = 1;	176	zq->online = 1;
177	atomic_set(&zq->load, 0);	177	atomic_set(&zq->load, 0);
		178	ap_queue_init_state(aq);
178	ap_queue_init_reply(aq, &zq->reply);	179	ap_queue_init_reply(aq, &zq->reply);
179	aq->request_timeout = CEX2A_CLEANUP_TIME,	180	aq->request_timeout = CEX2A_CLEANUP_TIME,
180	aq->private = zq;	181	aq->private = zq;

drivers/s390/crypto/zcrypt_cex2c.c+2−0

 	zq->queue = aq;
 	zq->online = 1;
 	atomic_set(&zq->load, 0);
+	ap_rapq(aq->qid);
 	rc = zcrypt_cex2c_rng_supported(aq);
 	if (rc < 0) {
 		zcrypt_queue_free(zq);
 	else
 		zq->ops = zcrypt_msgtype(MSGTYPE06_NAME,
 					 MSGTYPE06_VARIANT_NORNG);
+	ap_queue_init_state(aq);
 	ap_queue_init_reply(aq, &zq->reply);
 	aq->request_timeout = CEX2C_CLEANUP_TIME;
 	aq->private = zq;

drivers/s390/crypto/zcrypt_cex4.c+1−0

@@ -381,6 +381,7 @@ static int zcrypt_cex4_queue_probe(struct ap_device *ap_dev) · 380 unmodified lines
381	zq->queue = aq;	381	zq->queue = aq;
382	zq->online = 1;	382	zq->online = 1;
383	atomic_set(&zq->load, 0);	383	atomic_set(&zq->load, 0);
		384	ap_queue_init_state(aq);
384	ap_queue_init_reply(aq, &zq->reply);	385	ap_queue_init_reply(aq, &zq->reply);
385	aq->request_timeout = CEX4_CLEANUP_TIME,	386	aq->request_timeout = CEX4_CLEANUP_TIME,
386	aq->private = zq;	387	aq->private = zq;

drivers/scsi/fnic/vnic_dev.c+10−10

@@ -688,26 +688,26 @@ int vnic_dev_soft_reset_done(struct vnic_dev vdev, int done) · 687 unmodified lines
688		688
689	int vnic_dev_hang_notify(struct vnic_dev *vdev)	689	int vnic_dev_hang_notify(struct vnic_dev *vdev)
690	{	690	{
691	u64 a0, a1;	691	u64 a0 = 0, a1 = 0;
692	int wait = 1000;	692	int wait = 1000;
693	return vnic_dev_cmd(vdev, CMD_HANG_NOTIFY, &a0, &a1, wait);	693	return vnic_dev_cmd(vdev, CMD_HANG_NOTIFY, &a0, &a1, wait);
694	}	694	}
695		695
696	int vnic_dev_mac_addr(struct vnic_dev vdev, u8 mac_addr)	696	int vnic_dev_mac_addr(struct vnic_dev vdev, u8 mac_addr)
697	{	697	{
698	u64 a0, a1;	698	u64 a[2] = {};
699	int wait = 1000;	699	int wait = 1000;
700	int err, i;	700	int err, i;
701		701
702	for (i = 0; i < ETH_ALEN; i++)	702	for (i = 0; i < ETH_ALEN; i++)
703	mac_addr[i] = 0;	703	mac_addr[i] = 0;
704		704
705	err = vnic_dev_cmd(vdev, CMD_MAC_ADDR, &a0, &a1, wait);	705	err = vnic_dev_cmd(vdev, CMD_MAC_ADDR, &a[0], &a[1], wait);
706	if (err)	706	if (err)
707	return err;	707	return err;
708		708
709	for (i = 0; i < ETH_ALEN; i++)	709	for (i = 0; i < ETH_ALEN; i++)
710	mac_addr[i] = ((u8 *)&a0)[i];	710	mac_addr[i] = ((u8 *)&a)[i];
711		711
712	return 0;	712	return 0;
713	}	713	}
@@ -732,30 +732,30 @@ void vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast, · 18 unmodified lines
732		732
733	void vnic_dev_add_addr(struct vnic_dev vdev, u8 addr)	733	void vnic_dev_add_addr(struct vnic_dev vdev, u8 addr)
734	{	734	{
735	u64 a0 = 0, a1 = 0;	735	u64 a[2] = {};
736	int wait = 1000;	736	int wait = 1000;
737	int err;	737	int err;
738	int i;	738	int i;
739		739
740	for (i = 0; i < ETH_ALEN; i++)	740	for (i = 0; i < ETH_ALEN; i++)
741	((u8 *)&a0)[i] = addr[i];	741	((u8 *)&a)[i] = addr[i];
742		742
743	err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);	743	err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a[0], &a[1], wait);
744	if (err)	744	if (err)
745	pr_err("Can't add addr [%pM], %d\n", addr, err);	745	pr_err("Can't add addr [%pM], %d\n", addr, err);
746	}	746	}
747		747
748	void vnic_dev_del_addr(struct vnic_dev vdev, u8 addr)	748	void vnic_dev_del_addr(struct vnic_dev vdev, u8 addr)
749	{	749	{
750	u64 a0 = 0, a1 = 0;	750	u64 a[2] = {};
751	int wait = 1000;	751	int wait = 1000;
752	int err;	752	int err;
753	int i;	753	int i;
754		754
755	for (i = 0; i < ETH_ALEN; i++)	755	for (i = 0; i < ETH_ALEN; i++)
756	((u8 *)&a0)[i] = addr[i];	756	((u8 *)&a)[i] = addr[i];
757		757
758	err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a0, &a1, wait);	758	err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a[0], &a[1], wait);
759	if (err)	759	if (err)
760	pr_err("Can't del addr [%pM], %d\n", addr, err);	760	pr_err("Can't del addr [%pM], %d\n", addr, err);
761	}	761	}

drivers/scsi/sd.c+3−1

@@ -2211,8 +2211,10 @@ static int sd_read_protection_type(struct scsi_disk sdkp, unsigned char buffer · 2210 unmodified lines
2211	u8 type;	2211	u8 type;
2212	int ret = 0;	2212	int ret = 0;
2213		2213
2214	if (scsi_device_protection(sdp) == 0 \|\| (buffer[12] & 1) == 0)	2214	if (scsi_device_protection(sdp) == 0 \|\| (buffer[12] & 1) == 0) {
		2215	sdkp->protection_type = 0;
2215	return ret;	2216	return ret;
		2217	}
2216		2218
2217	type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */	2219	type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */
2218		2220

drivers/scsi/storvsc_drv.c+3−1

 	 */
 	host->sg_tablesize = (stor_device->max_transfer_bytes >> PAGE_SHIFT);
 	/*
+	 * For non-IDE disks, the host supports multiple channels.
 	 * Set the number of HW queues we are supporting.
 	 */
-	host->nr_hw_queues = num_present_cpus();
+	if (!dev_is_ide)
+		host->nr_hw_queues = num_present_cpus();
 	/*
 	 * Set the error handler work queue.

drivers/soc/amlogic/meson-ee-pwrc.c+15−9

 				     struct meson_ee_pwrc *pwrc,
 				     struct meson_ee_pwrc_domain *dom)
 {
+	int ret;
 	dom->pwrc = pwrc;
 	dom->num_rstc = dom->desc.reset_names_count;
 	dom->num_clks = dom->desc.clk_names_count;
          * prepare/enable counters won't be in sync.
          */
 	if (dom->num_clks && dom->desc.get_power && !dom->desc.get_power(dom)) {
-		int ret = clk_bulk_prepare_enable(dom->num_clks, dom->clks);
+		ret = clk_bulk_prepare_enable(dom->num_clks, dom->clks);
 		if (ret)
 			return ret;
-		pm_genpd_init(&dom->base, &pm_domain_always_on_gov, false);
+		ret = pm_genpd_init(&dom->base, &pm_domain_always_on_gov,
-	} else
+				    false);
-		pm_genpd_init(&dom->base, NULL,
+		if (ret)
-			      (dom->desc.get_power ?
+			return ret;
-			       dom->desc.get_power(dom) : true));
+	} else {
+		ret = pm_genpd_init(&dom->base, NULL,
+				    (dom->desc.get_power ?
+				     dom->desc.get_power(dom) : true));
+		if (ret)
+			return ret;
+	}
 	return 0;
 }
 		pwrc->xlate.domains[i] = &dom->base;
 	}
-	of_genpd_add_provider_onecell(pdev->dev.of_node, &pwrc->xlate);
+	return of_genpd_add_provider_onecell(pdev->dev.of_node, &pwrc->xlate);
-	return 0;
 }
 static void meson_ee_pwrc_shutdown(struct platform_device *pdev)

drivers/soc/ti/wkup_m3_ipc.c+2−2

 	ret = rproc_boot(m3_ipc->rproc);
 	if (ret)
 		dev_err(dev, "rproc_boot failed\n");
+	else
+		m3_ipc_state = m3_ipc;
 	do_exit(0);
 }
 		goto err_put_rproc;
 	}
-	m3_ipc_state = m3_ipc;
 	return 0;
 err_put_rproc:

drivers/staging/comedi/drivers/ni_routes.c+6−6

 		}
 	}
-	if (!rv)
-		return -ENODATA;
 	/* Second, find the set of routes valid for this device. */
 	for (i = 0; ni_device_routes_list[i]; ++i) {
 		if (memcmp(ni_device_routes_list[i]->device, board_name,
 		}
 	}
-	if (!dr)
-		return -ENODATA;
 	tables->route_values = rv;
 	tables->valid_routes = dr;
+	if (!rv || !dr)
+		return -ENODATA;
 	return 0;
 }
 {
 	int src;
+	if (!tables->route_values)
+		return -EINVAL;
 	dest = B(dest); /* subtract NI names offset */
 	/* ensure we are not going to under/over run the route value table */
 	if (dest < 0 || dest >= NI_NUM_NAMES)

drivers/tee/optee/shm_pool.c+14−1

@@ -28,9 +28,22 @@ static int pool_op_alloc(struct tee_shm_pool_mgr *poolm, · 27 unmodified lines
28	shm->size = PAGE_SIZE << order;	28	shm->size = PAGE_SIZE << order;
29		29
30	if (shm->flags & TEE_SHM_DMA_BUF) {	30	if (shm->flags & TEE_SHM_DMA_BUF) {
		31	unsigned int nr_pages = 1 << order, i;
		32	struct page **pages;
		33
		34	pages = kcalloc(nr_pages, sizeof(pages), GFP_KERNEL);
		35	if (!pages)
		36	return -ENOMEM;
		37
		38	for (i = 0; i < nr_pages; i++) {
		39	pages[i] = page;
		40	page++;
		41	}
		42
31	shm->flags \|= TEE_SHM_REGISTER;	43	shm->flags \|= TEE_SHM_REGISTER;
32	rc = optee_shm_register(shm->ctx, shm, &page, 1 << order,	44	rc = optee_shm_register(shm->ctx, shm, pages, nr_pages,
33	(unsigned long)shm->kaddr);	45	(unsigned long)shm->kaddr);
		46	kfree(pages);
34	}	47	}
35		48
36	return rc;	49	return rc;

drivers/usb/core/hub.c+1−0

@@ -1192,6 +1192,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type) · 1191 unmodified lines
1192	* PORT_OVER_CURRENT is not. So check for any of them.	1192	* PORT_OVER_CURRENT is not. So check for any of them.
1193	*/	1193	*/
1194	if (udev \|\| (portstatus & USB_PORT_STAT_CONNECTION) \|\|	1194	if (udev \|\| (portstatus & USB_PORT_STAT_CONNECTION) \|\|
		1195	(portchange & USB_PORT_STAT_C_CONNECTION) \|\|
1195	(portstatus & USB_PORT_STAT_OVERCURRENT) \|\|	1196	(portstatus & USB_PORT_STAT_OVERCURRENT) \|\|
1196	(portchange & USB_PORT_STAT_C_OVERCURRENT))	1197	(portchange & USB_PORT_STAT_C_OVERCURRENT))
1197	set_bit(port1, hub->change_bits);	1198	set_bit(port1, hub->change_bits);

drivers/usb/serial/ch341.c+5−1

 static int ch341_reset_resume(struct usb_serial *serial)
 {
 	struct usb_serial_port *port = serial->port[0];
-	struct ch341_private *priv = usb_get_serial_port_data(port);
+	struct ch341_private *priv;
 	int ret;
+	priv = usb_get_serial_port_data(port);
+	if (!priv)
+		return 0;
 	/* reconfigure ch341 serial port after bus-reset */
 	ch341_configure(serial->dev, priv);

drivers/usb/serial/io_edgeport.c+9−7

 			if (txCredits) {
 				port = edge_serial->serial->port[portNumber];
 				edge_port = usb_get_serial_port_data(port);
-				if (edge_port->open) {
+				if (edge_port && edge_port->open) {
 					spin_lock_irqsave(&edge_port->ep_lock,
 							  flags);
 					edge_port->txCredits += txCredits;
 static void process_rcvd_data(struct edgeport_serial *edge_serial,
 				unsigned char *buffer, __u16 bufferLength)
 {
-	struct device *dev = &edge_serial->serial->dev->dev;
+	struct usb_serial *serial = edge_serial->serial;
+	struct device *dev = &serial->dev->dev;
 	struct usb_serial_port *port;
 	struct edgeport_port *edge_port;
 	__u16 lastBufferLength;
 			/* spit this data back into the tty driver if this
 			   port is open */
-			if (rxLen) {
+			if (rxLen && edge_serial->rxPort < serial->num_ports) {
-				port = edge_serial->serial->port[
+				port = serial->port[edge_serial->rxPort];
-							edge_serial->rxPort];
 				edge_port = usb_get_serial_port_data(port);
-				if (edge_port->open) {
+				if (edge_port && edge_port->open) {
 					dev_dbg(dev, "%s - Sending %d bytes to TTY for port %d\n",
 						__func__, rxLen,
 						edge_serial->rxPort);
 							rxLen);
 					edge_port->port->icount.rx += rxLen;
 				}
-				buffer += rxLen;
 			}
+			buffer += rxLen;
 			break;
 		case EXPECT_HDR3:	/* Expect 3rd byte of status header */
 	__u8 code = edge_serial->rxStatusCode;
 	/* switch the port pointer to the one being currently talked about */
+	if (edge_serial->rxPort >= edge_serial->serial->num_ports)
+		return;
 	port = edge_serial->serial->port[edge_serial->rxPort];
 	edge_port = usb_get_serial_port_data(port);
 	if (edge_port == NULL) {

drivers/usb/serial/keyspan.c+4−0

 	for (i = 0; i < serial->num_ports; ++i) {
 		port = serial->port[i];
 		p_priv = usb_get_serial_port_data(port);
+		if (!p_priv)
+			continue;
 		if (p_priv->resend_cont) {
 			dev_dbg(&port->dev, "%s - sending setup\n", __func__);
 	for (i = 0; i < serial->num_ports; ++i) {
 		port = serial->port[i];
 		p_priv = usb_get_serial_port_data(port);
+		if (!p_priv)
+			continue;
 		if (p_priv->resend_cont) {
 			dev_dbg(&port->dev, "%s - sending setup\n", __func__);

drivers/usb/serial/opticon.c+1−1

@@ -113,7 +113,7 @@ static int send_control_msg(struct usb_serial_port *port, u8 requesttype, · 112 unmodified lines
113	retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),	113	retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
114	requesttype,	114	requesttype,
115	USB_DIR_OUT\|USB_TYPE_VENDOR\|USB_RECIP_INTERFACE,	115	USB_DIR_OUT\|USB_TYPE_VENDOR\|USB_RECIP_INTERFACE,
116	0, 0, buffer, 1, 0);	116	0, 0, buffer, 1, USB_CTRL_SET_TIMEOUT);
117	kfree(buffer);	117	kfree(buffer);
118		118
119	if (retval < 0)	119	if (retval < 0)

drivers/usb/serial/option.c+6−0

 #define QUECTEL_PRODUCT_BG96			0x0296
 #define QUECTEL_PRODUCT_EP06			0x0306
 #define QUECTEL_PRODUCT_EM12			0x0512
+#define QUECTEL_PRODUCT_RM500Q			0x0800
 #define CMOTECH_VENDOR_ID			0x16d8
 #define CMOTECH_PRODUCT_6001			0x6001
 	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EM12, 0xff, 0xff, 0xff),
 	  .driver_info = RSVD(1) | RSVD(2) | RSVD(3) | RSVD(4) | NUMEP2 },
 	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EM12, 0xff, 0, 0) },
+	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM500Q, 0xff, 0xff, 0x30) },
+	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM500Q, 0xff, 0, 0) },
+	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM500Q, 0xff, 0xff, 0x10),
+	  .driver_info = ZLP },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6001) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CMU_300) },
 	{ USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6003),

drivers/usb/serial/quatech2.c+6−0

 	u8 newMSR = (u8) *ch;
 	unsigned long flags;
+	/* May be called from qt2_process_read_urb() for an unbound port. */
 	port_priv = usb_get_serial_port_data(port);
+	if (!port_priv)
+		return;
 	spin_lock_irqsave(&port_priv->lock, flags);
 	port_priv->shadowMSR = newMSR;
 	unsigned long flags;
 	u8 newLSR = (u8) *ch;
+	/* May be called from qt2_process_read_urb() for an unbound port. */
 	port_priv = usb_get_serial_port_data(port);
+	if (!port_priv)
+		return;
 	if (newLSR & UART_LSR_BI)
 		newLSR &= (u8) (UART_LSR_OE | UART_LSR_BI);

drivers/usb/serial/usb-serial-simple.c+2−0

@@ -86,6 +86,8 @@ DEVICE(moto_modem, MOTO_IDS); · 85 unmodified lines
86	#define MOTOROLA_TETRA_IDS() \	86	#define MOTOROLA_TETRA_IDS() \
87	{ USB_DEVICE(0x0cad, 0x9011) }, /* Motorola Solutions TETRA PEI */ \	87	{ USB_DEVICE(0x0cad, 0x9011) }, /* Motorola Solutions TETRA PEI */ \
88	{ USB_DEVICE(0x0cad, 0x9012) }, /* MTP6550 */ \	88	{ USB_DEVICE(0x0cad, 0x9012) }, /* MTP6550 */ \
		89	{ USB_DEVICE(0x0cad, 0x9013) }, /* MTP3xxx */ \
		90	{ USB_DEVICE(0x0cad, 0x9015) }, /* MTP85xx */ \
89	{ USB_DEVICE(0x0cad, 0x9016) } /* TPG2200 */	91	{ USB_DEVICE(0x0cad, 0x9016) } /* TPG2200 */
90	DEVICE(motorola_tetra, MOTOROLA_TETRA_IDS);	92	DEVICE(motorola_tetra, MOTOROLA_TETRA_IDS);
91		93

drivers/usb/serial/usb-serial.c+3−0

@@ -1317,6 +1317,9 @@ static int usb_serial_register(struct usb_serial_driver *driver) · 1316 unmodified lines
1317	return -EINVAL;	1317	return -EINVAL;
1318	}	1318	}
1319		1319
		1320	/* Prevent individual ports from being unbound. */
		1321	driver->driver.suppress_bind_attrs = true;
		1322
1320	usb_serial_operations_init(driver);	1323	usb_serial_operations_init(driver);
1321		1324
1322	/* Add this device to our list of devices */	1325	/* Add this device to our list of devices */

fs/afs/dir.c+8−10

@@ -908,6 +908,7 @@ static struct dentry afs_lookup(struct inode dir, struct dentry *dentry, · 907 unmodified lines
908	unsigned int flags)	908	unsigned int flags)
909	{	909	{
910	struct afs_vnode *dvnode = AFS_FS_I(dir);	910	struct afs_vnode *dvnode = AFS_FS_I(dir);
		911	struct afs_fid fid = {};
911	struct inode *inode;	912	struct inode *inode;
912	struct dentry *d;	913	struct dentry *d;
913	struct key *key;	914	struct key *key;
@@ -951,21 +952,18 @@ static struct dentry afs_lookup(struct inode dir, struct dentry *dentry, · 37 unmodified lines
951	afs_stat_v(dvnode, n_lookup);	952	afs_stat_v(dvnode, n_lookup);
952	inode = afs_do_lookup(dir, dentry, key);	953	inode = afs_do_lookup(dir, dentry, key);
953	key_put(key);	954	key_put(key);
954	if (inode == ERR_PTR(-ENOENT)) {	955	if (inode == ERR_PTR(-ENOENT))
955	inode = afs_try_auto_mntpt(dentry, dir);	956	inode = afs_try_auto_mntpt(dentry, dir);
956	} else {	957
957	dentry->d_fsdata =	958	if (!IS_ERR_OR_NULL(inode))
958	(void *)(unsigned long)dvnode->status.data_version;	959	fid = AFS_FS_I(inode)->fid;
959	}	960
960	d = d_splice_alias(inode, dentry);	961	d = d_splice_alias(inode, dentry);
961	if (!IS_ERR_OR_NULL(d)) {	962	if (!IS_ERR_OR_NULL(d)) {
962	d->d_fsdata = dentry->d_fsdata;	963	d->d_fsdata = dentry->d_fsdata;
963	trace_afs_lookup(dvnode, &d->d_name,	964	trace_afs_lookup(dvnode, &d->d_name, &fid);
964	inode ? AFS_FS_I(inode) : NULL);
965	} else {	965	} else {
966	trace_afs_lookup(dvnode, &dentry->d_name,	966	trace_afs_lookup(dvnode, &dentry->d_name, &fid);
967	IS_ERR_OR_NULL(inode) ? NULL
968	: AFS_FS_I(inode));
969	}	967	}
970	return d;	968	return d;
971	}	969	}

fs/btrfs/inode.c+39−34

 }
 static int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
-			       struct inode *dir, u64 objectid,
+			       struct inode *dir, struct dentry *dentry)
-			       const char *name, int name_len)
 {
 	struct btrfs_root *root = BTRFS_I(dir)->root;
+	struct btrfs_inode *inode = BTRFS_I(d_inode(dentry));
 	struct btrfs_path *path;
 	struct extent_buffer *leaf;
 	struct btrfs_dir_item *di;
 	struct btrfs_key key;
+	const char *name = dentry->d_name.name;
+	int name_len = dentry->d_name.len;
 	u64 index;
 	int ret;
+	u64 objectid;
 	u64 dir_ino = btrfs_ino(BTRFS_I(dir));
+	if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID) {
+		objectid = inode->root->root_key.objectid;
+	} else if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID) {
+		objectid = inode->location.objectid;
+	} else {
+		WARN_ON(1);
+		return -EINVAL;
+	}
 	path = btrfs_alloc_path();
 	if (!path)
 		return -ENOMEM;
 	}
 	btrfs_release_path(path);
-	ret = btrfs_del_root_ref(trans, objectid, root->root_key.objectid,
+	/*
-				 dir_ino, &index, name, name_len);
+	 * This is a placeholder inode for a subvolume we didn't have a
-	if (ret < 0) {
+	 * reference to at the time of the snapshot creation.  In the meantime
-		if (ret != -ENOENT) {
+	 * we could have renamed the real subvol link into our snapshot, so
-			btrfs_abort_transaction(trans, ret);
+	 * depending on btrfs_del_root_ref to return -ENOENT here is incorret.
-			goto out;
+	 * Instead simply lookup the dir_index_item for this entry so we can
-		}
+	 * remove it.  Otherwise we know we have a ref to the root and we can
+	 * call btrfs_del_root_ref, and it _shouldn't_ fail.
+	 */
+	if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID) {
 		di = btrfs_search_dir_index_item(root, path, dir_ino,
 						 name, name_len);
 		if (IS_ERR_OR_NULL(di)) {
 		leaf = path->nodes[0];
 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 		index = key.offset;
+		btrfs_release_path(path);
+	} else {
+		ret = btrfs_del_root_ref(trans, objectid,
+					 root->root_key.objectid, dir_ino,
+					 &index, name, name_len);
+		if (ret) {
+			btrfs_abort_transaction(trans, ret);
+			goto out;
+		}
 	}
-	btrfs_release_path(path);
 	ret = btrfs_delete_delayed_dir_index(trans, BTRFS_I(dir), index);
 	if (ret) {
 	btrfs_record_snapshot_destroy(trans, BTRFS_I(dir));
-	ret = btrfs_unlink_subvol(trans, dir, dest->root_key.objectid,
+	ret = btrfs_unlink_subvol(trans, dir, dentry);
-				  dentry->d_name.name, dentry->d_name.len);
 	if (ret) {
 		err = ret;
 		btrfs_abort_transaction(trans, ret);
 		return PTR_ERR(trans);
 	if (unlikely(btrfs_ino(BTRFS_I(inode)) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
-		err = btrfs_unlink_subvol(trans, dir,
+		err = btrfs_unlink_subvol(trans, dir, dentry);
-					  BTRFS_I(inode)->location.objectid,
-					  dentry->d_name.name,
-					  dentry->d_name.len);
 		goto out;
 	}
 	u64 new_ino = btrfs_ino(BTRFS_I(new_inode));
 	u64 old_idx = 0;
 	u64 new_idx = 0;
-	u64 root_objectid;
 	int ret;
 	bool root_log_pinned = false;
 	bool dest_log_pinned = false;
 	/* src is a subvolume */
 	if (old_ino == BTRFS_FIRST_FREE_OBJECTID) {
-		root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
+		ret = btrfs_unlink_subvol(trans, old_dir, old_dentry);
-		ret = btrfs_unlink_subvol(trans, old_dir, root_objectid,
-					  old_dentry->d_name.name,
-					  old_dentry->d_name.len);
 	} else { /* src is an inode */
 		ret = __btrfs_unlink_inode(trans, root, BTRFS_I(old_dir),
 					   BTRFS_I(old_dentry->d_inode),
 	/* dest is a subvolume */
 	if (new_ino == BTRFS_FIRST_FREE_OBJECTID) {
-		root_objectid = BTRFS_I(new_inode)->root->root_key.objectid;
+		ret = btrfs_unlink_subvol(trans, new_dir, new_dentry);
-		ret = btrfs_unlink_subvol(trans, new_dir, root_objectid,
-					  new_dentry->d_name.name,
-					  new_dentry->d_name.len);
 	} else { /* dest is an inode */
 		ret = __btrfs_unlink_inode(trans, dest, BTRFS_I(new_dir),
 					   BTRFS_I(new_dentry->d_inode),
 	struct inode *new_inode = d_inode(new_dentry);
 	struct inode *old_inode = d_inode(old_dentry);
 	u64 index = 0;
-	u64 root_objectid;
 	int ret;
 	u64 old_ino = btrfs_ino(BTRFS_I(old_inode));
 	bool log_pinned = false;
 				BTRFS_I(old_inode), 1);
 	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
-		root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
+		ret = btrfs_unlink_subvol(trans, old_dir, old_dentry);
-		ret = btrfs_unlink_subvol(trans, old_dir, root_objectid,
-					old_dentry->d_name.name,
-					old_dentry->d_name.len);
 	} else {
 		ret = __btrfs_unlink_inode(trans, root, BTRFS_I(old_dir),
 					BTRFS_I(d_inode(old_dentry)),
 		new_inode->i_ctime = current_time(new_inode);
 		if (unlikely(btrfs_ino(BTRFS_I(new_inode)) ==
 			     BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
-			root_objectid = BTRFS_I(new_inode)->location.objectid;
+			ret = btrfs_unlink_subvol(trans, new_dir, new_dentry);
-			ret = btrfs_unlink_subvol(trans, new_dir, root_objectid,
-						new_dentry->d_name.name,
-						new_dentry->d_name.len);
 			BUG_ON(new_inode->i_nlink == 0);
 		} else {
 			ret = btrfs_unlink_inode(trans, dest, BTRFS_I(new_dir),

fs/btrfs/ioctl.c+13−1

@@ -4252,7 +4252,19 @@ static long btrfs_ioctl_scrub(struct file file, void __user arg) · 4251 unmodified lines
4252	&sa->progress, sa->flags & BTRFS_SCRUB_READONLY,	4252	&sa->progress, sa->flags & BTRFS_SCRUB_READONLY,
4253	0);	4253	0);
4254		4254
4255	if (ret == 0 && copy_to_user(arg, sa, sizeof(*sa)))	4255	/*
		4256	* Copy scrub args to user space even if btrfs_scrub_dev() returned an
		4257	* error. This is important as it allows user space to know how much
		4258	* progress scrub has done. For example, if scrub is canceled we get
		4259	* -ECANCELED from btrfs_scrub_dev() and return that error back to user
		4260	* space. Later user space can inspect the progress from the structure
		4261	* btrfs_ioctl_scrub_args and resume scrub from where it left off
		4262	* previously (btrfs-progs does this).
		4263	* If we fail to copy the btrfs_ioctl_scrub_args structure to user space
		4264	* then return -EFAULT to signal the structure was not copied or it may
		4265	* be corrupt and unreliable due to a partial copy.
		4266	*/
		4267	if (copy_to_user(arg, sa, sizeof(*sa)))
4256	ret = -EFAULT;	4268	ret = -EFAULT;
4257		4269
4258	if (!(sa->flags & BTRFS_SCRUB_READONLY))	4270	if (!(sa->flags & BTRFS_SCRUB_READONLY))

fs/btrfs/qgroup.c+5−1

 	u64 nr_old_roots = 0;
 	int ret = 0;
+	/*
+	 * If quotas get disabled meanwhile, the resouces need to be freed and
+	 * we can't just exit here.
+	 */
 	if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))
-		return 0;
+		goto out_free;
 	if (new_roots) {
 		if (!maybe_fs_roots(new_roots))

fs/btrfs/relocation.c+46−5

 	return 1;
 }
+static bool reloc_root_is_dead(struct btrfs_root *root)
+{
+	/*
+	 * Pair with set_bit/clear_bit in clean_dirty_subvols and
+	 * btrfs_update_reloc_root. We need to see the updated bit before
+	 * trying to access reloc_root
+	 */
+	smp_rmb();
+	if (test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state))
+		return true;
+	return false;
+}
+/*
+ * Check if this subvolume tree has valid reloc tree.
+ *
+ * Reloc tree after swap is considered dead, thus not considered as valid.
+ * This is enough for most callers, as they don't distinguish dead reloc root
+ * from no reloc root.  But should_ignore_root() below is a special case.
+ */
+static bool have_reloc_root(struct btrfs_root *root)
+{
+	if (reloc_root_is_dead(root))
+		return false;
+	if (!root->reloc_root)
+		return false;
+	return true;
+}
 static int should_ignore_root(struct btrfs_root *root)
 {
 	if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))
 		return 0;
+	/* This root has been merged with its reloc tree, we can ignore it */
+	if (reloc_root_is_dead(root))
+		return 1;
 	reloc_root = root->reloc_root;
 	if (!reloc_root)
 		return 0;
 	 * The subvolume has reloc tree but the swap is finished, no need to
 	 * create/update the dead reloc tree
 	 */
-	if (test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state))
+	if (reloc_root_is_dead(root))
 		return 0;
 	if (root->reloc_root) {
 	struct btrfs_root_item *root_item;
 	int ret;
-	if (test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state) ||
+	if (!have_reloc_root(root))
-	    !root->reloc_root)
 		goto out;
 	reloc_root = root->reloc_root;
 	if (fs_info->reloc_ctl->merge_reloc_tree &&
 	    btrfs_root_refs(root_item) == 0) {
 		set_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state);
+		/*
+		 * Mark the tree as dead before we change reloc_root so
+		 * have_reloc_root will not touch it from now on.
+		 */
+		smp_wmb();
 		__del_reloc_root(reloc_root);
 	}
 				if (ret2 < 0 && !ret)
 					ret = ret2;
 			}
+			/*
+			 * Need barrier to ensure clear_bit() only happens after
+			 * root->reloc_root = NULL. Pairs with have_reloc_root.
+			 */
+			smp_wmb();
 			clear_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state);
 			btrfs_put_fs_root(root);
 		} else {
 	struct btrfs_root *root = pending->root;
 	struct reloc_control *rc = root->fs_info->reloc_ctl;
-	if (!root->reloc_root || !rc)
+	if (!rc || !have_reloc_root(root))
 		return;
 	if (!rc->merge_reloc_tree)
 	struct reloc_control *rc = root->fs_info->reloc_ctl;
 	int ret;
-	if (!root->reloc_root || !rc)
+	if (!rc || !have_reloc_root(root))
 		return 0;
 	rc = root->fs_info->reloc_ctl;

fs/btrfs/root-tree.c+6−4

 		leaf = path->nodes[0];
 		ref = btrfs_item_ptr(leaf, path->slots[0],
 				     struct btrfs_root_ref);
-		WARN_ON(btrfs_root_ref_dirid(leaf, ref) != dirid);
-		WARN_ON(btrfs_root_ref_name_len(leaf, ref) != name_len);
 		ptr = (unsigned long)(ref + 1);
-		WARN_ON(memcmp_extent_buffer(leaf, name, ptr, name_len));
+		if ((btrfs_root_ref_dirid(leaf, ref) != dirid) ||
+		    (btrfs_root_ref_name_len(leaf, ref) != name_len) ||
+		    memcmp_extent_buffer(leaf, name, ptr, name_len)) {
+			err = -ENOENT;
+			goto out;
+		}
 		*sequence = btrfs_root_ref_sequence(leaf, ref);
 		ret = btrfs_del_item(trans, tree_root, path);

fs/btrfs/volumes.c+5−1

 		}
 	}
-	num_devices = btrfs_num_devices(fs_info);
+	/*
+	 * rw_devices will not change at the moment, device add/delete/replace
+	 * are excluded by EXCL_OP
+	 */
+	num_devices = fs_info->fs_devices->rw_devices;
 	/*
 	 * SINGLE profile on-disk has no profile bit, but in-memory we have a

fs/fuse/file.c+3−1

 	struct fuse_args_pages *ap = &ia->ap;
 	loff_t pos = page_offset(ap->pages[0]);
 	size_t count = ap->num_pages << PAGE_SHIFT;
+	ssize_t res;
 	int err;
 	ap->args.out_pages = true;
 		if (!err)
 			return;
 	} else {
-		err = fuse_simple_request(fc, &ap->args);
+		res = fuse_simple_request(fc, &ap->args);
+		err = res < 0 ? res : 0;
 	}
 	fuse_readpages_end(fc, &ap->args, err);
 }

fs/io-wq.c+8−4

 			task_unlock(current);
 		}
 		if ((work->flags & IO_WQ_WORK_NEEDS_USER) && !worker->mm &&
-		    wq->mm && mmget_not_zero(wq->mm)) {
+		    wq->mm) {
-			use_mm(wq->mm);
+			if (mmget_not_zero(wq->mm)) {
-			set_fs(USER_DS);
+				use_mm(wq->mm);
-			worker->mm = wq->mm;
+				set_fs(USER_DS);
+				worker->mm = wq->mm;
+			} else {
+				work->flags |= IO_WQ_WORK_CANCEL;
+			}
 		}
 		if (!worker->creds)
 			worker->creds = override_creds(wq->creds);

fs/io_uring.c+48−24

 			     struct iovec *iovec, struct iovec *fast_iov,
 			     struct iov_iter *iter)
 {
+	if (req->opcode == IORING_OP_READ_FIXED ||
+	    req->opcode == IORING_OP_WRITE_FIXED)
+		return 0;
 	if (!req->io && io_alloc_async_ctx(req))
 		return -ENOMEM;
 	if (!force_nonblock)
 		req->rw.kiocb.ki_flags &= ~IOCB_NOWAIT;
+	req->result = 0;
 	io_size = ret;
 	if (req->flags & REQ_F_LINK)
 		req->result = io_size;
 	if (!force_nonblock)
 		req->rw.kiocb.ki_flags &= ~IOCB_NOWAIT;
+	req->result = 0;
 	io_size = ret;
 	if (req->flags & REQ_F_LINK)
 		req->result = io_size;
 	return false;
 }
+static void io_link_work_cb(struct io_wq_work **workptr)
+{
+	struct io_wq_work *work = *workptr;
+	struct io_kiocb *link = work->data;
+	io_queue_linked_timeout(link);
+	work->func = io_wq_submit_work;
+}
+static void io_wq_assign_next(struct io_wq_work **workptr, struct io_kiocb *nxt)
+{
+	struct io_kiocb *link;
+	io_prep_async_work(nxt, &link);
+	*workptr = &nxt->work;
+	if (link) {
+		nxt->work.flags |= IO_WQ_WORK_CB;
+		nxt->work.func = io_link_work_cb;
+		nxt->work.data = link;
+	}
+}
 static void io_fsync_finish(struct io_wq_work **workptr)
 {
 	struct io_kiocb *req = container_of(*workptr, struct io_kiocb, work);
 	io_cqring_add_event(req, ret);
 	io_put_req_find_next(req, &nxt);
 	if (nxt)
-		*workptr = &nxt->work;
+		io_wq_assign_next(workptr, nxt);
 }
 static int io_fsync(struct io_kiocb *req, struct io_kiocb **nxt,
 	io_cqring_add_event(req, ret);
 	io_put_req_find_next(req, &nxt);
 	if (nxt)
-		*workptr = &nxt->work;
+		io_wq_assign_next(workptr, nxt);
 }
 static int io_sync_file_range(struct io_kiocb *req, struct io_kiocb **nxt,
 		return;
 	__io_accept(req, &nxt, false);
 	if (nxt)
-		*workptr = &nxt->work;
+		io_wq_assign_next(workptr, nxt);
 }
 #endif
 		req_set_fail_links(req);
 	io_put_req_find_next(req, &nxt);
 	if (nxt)
-		*workptr = &nxt->work;
+		io_wq_assign_next(workptr, nxt);
 }
 static int io_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync,
 		return ret;
 	if (ctx->flags & IORING_SETUP_IOPOLL) {
+		const bool in_async = io_wq_current_is_worker();
 		if (req->result == -EAGAIN)
 			return -EAGAIN;
+		/* workqueue context doesn't hold uring_lock, grab it now */
+		if (in_async)
+			mutex_lock(&ctx->uring_lock);
 		io_iopoll_req_issued(req);
+		if (in_async)
+			mutex_unlock(&ctx->uring_lock);
 	}
 	return 0;
 }
-static void io_link_work_cb(struct io_wq_work **workptr)
-{
-	struct io_wq_work *work = *workptr;
-	struct io_kiocb *link = work->data;
-	io_queue_linked_timeout(link);
-	work->func = io_wq_submit_work;
-}
 static void io_wq_submit_work(struct io_wq_work **workptr)
 {
 	struct io_wq_work *work = *workptr;
 	}
 	/* if a dependent link is ready, pass it back */
-	if (!ret && nxt) {
+	if (!ret && nxt)
-		struct io_kiocb *link;
+		io_wq_assign_next(workptr, nxt);
-		io_prep_async_work(nxt, &link);
-		*workptr = &nxt->work;
-		if (link) {
-			nxt->work.flags |= IO_WQ_WORK_CB;
-			nxt->work.func = io_link_work_cb;
-			nxt->work.data = link;
-		}
-	}
 }
 static bool io_req_op_valid(int op)
 	} else if (to_submit) {
 		struct mm_struct *cur_mm;
+		if (current->mm != ctx->sqo_mm ||
+		    current_cred() != ctx->creds) {
+			ret = -EPERM;
+			goto out;
+		}
 		to_submit = min(to_submit, ctx->sq_entries);
 		mutex_lock(&ctx->uring_lock);
 		/* already have mm, so io_submit_sqes() won't try to grab it */

fs/namei.c+13−77

@@ -1232,6 +1232,7 @@ static int follow_managed(struct path path, struct nameidata nd) · 1231 unmodified lines
1232	BUG_ON(!path->dentry->d_op);	1232	BUG_ON(!path->dentry->d_op);
1233	BUG_ON(!path->dentry->d_op->d_manage);	1233	BUG_ON(!path->dentry->d_op->d_manage);
1234	ret = path->dentry->d_op->d_manage(path, false);	1234	ret = path->dentry->d_op->d_manage(path, false);
		1235	flags = smp_load_acquire(&path->dentry->d_flags);
1235	if (ret < 0)	1236	if (ret < 0)
1236	break;	1237	break;
1237	}	1238	}
@@ -1649,17 +1650,15 @@ again: · 411 unmodified lines
1649	if (IS_ERR(dentry))	1650	if (IS_ERR(dentry))
1650	return dentry;	1651	return dentry;
1651	if (unlikely(!d_in_lookup(dentry))) {	1652	if (unlikely(!d_in_lookup(dentry))) {
1652	if (!(flags & LOOKUP_NO_REVAL)) {	1653	int error = d_revalidate(dentry, flags);
1653	int error = d_revalidate(dentry, flags);	1654	if (unlikely(error <= 0)) {
1654	if (unlikely(error <= 0)) {	1655	if (!error) {
1655	if (!error) {	1656	d_invalidate(dentry);
1656	d_invalidate(dentry);
1657	dput(dentry);
1658	goto again;
1659	}
1660	dput(dentry);	1657	dput(dentry);
1661	dentry = ERR_PTR(error);	1658	goto again;
1662	}	1659	}
		1660	dput(dentry);
		1661	dentry = ERR_PTR(error);
1663	}	1662	}
1664	} else {	1663	} else {
1665	old = inode->i_op->lookup(inode, dentry, flags);	1664	old = inode->i_op->lookup(inode, dentry, flags);
@@ -2617,72 +2616,6 @@ int user_path_at_empty(int dfd, const char __user *name, unsigned flags, · 951 unmodified lines
2617	}	2616	}
2618	EXPORT_SYMBOL(user_path_at_empty);	2617	EXPORT_SYMBOL(user_path_at_empty);
2619		2618
2620	/**
2621	* mountpoint_last - look up last component for umount
2622	* @nd: pathwalk nameidata - currently pointing at parent directory of "last"
2623	*
2624	* This is a special lookup_last function just for umount. In this case, we
2625	* need to resolve the path without doing any revalidation.
2626	*
2627	* The nameidata should be the result of doing a LOOKUP_PARENT pathwalk. Since
2628	* mountpoints are always pinned in the dcache, their ancestors are too. Thus,
2629	* in almost all cases, this lookup will be served out of the dcache. The only
2630	* cases where it won't are if nd->last refers to a symlink or the path is
2631	* bogus and it doesn't exist.
2632	*
2633	* Returns:
2634	* -error: if there was an error during lookup. This includes -ENOENT if the
2635	* lookup found a negative dentry.
2636	*
2637	* 0: if we successfully resolved nd->last and found it to not to be a
2638	* symlink that needs to be followed.
2639	*
2640	* 1: if we successfully resolved nd->last and found it to be a symlink
2641	* that needs to be followed.
2642	*/
2643	static int
2644	mountpoint_last(struct nameidata *nd)
2645	{
2646	int error = 0;
2647	struct dentry *dir = nd->path.dentry;
2648	struct path path;
2649
2650	/* If we're in rcuwalk, drop out of it to handle last component */
2651	if (nd->flags & LOOKUP_RCU) {
2652	if (unlazy_walk(nd))
2653	return -ECHILD;
2654	}
2655
2656	nd->flags &= ~LOOKUP_PARENT;
2657
2658	if (unlikely(nd->last_type != LAST_NORM)) {
2659	error = handle_dots(nd, nd->last_type);
2660	if (error)
2661	return error;
2662	path.dentry = dget(nd->path.dentry);
2663	} else {
2664	path.dentry = d_lookup(dir, &nd->last);
2665	if (!path.dentry) {
2666	/*
2667	* No cached dentry. Mounted dentries are pinned in the
2668	* cache, so that means that this dentry is probably
2669	* a symlink or the path doesn't actually point
2670	* to a mounted dentry.
2671	*/
2672	path.dentry = lookup_slow(&nd->last, dir,
2673	nd->flags \| LOOKUP_NO_REVAL);
2674	if (IS_ERR(path.dentry))
2675	return PTR_ERR(path.dentry);
2676	}
2677	}
2678	if (d_flags_negative(smp_load_acquire(&path.dentry->d_flags))) {
2679	dput(path.dentry);
2680	return -ENOENT;
2681	}
2682	path.mnt = nd->path.mnt;
2683	return step_into(nd, &path, 0, d_backing_inode(path.dentry), 0);
2684	}
2685
2686	/**	2619	/**
2687	* path_mountpoint - look up a path to be umounted	2620	* path_mountpoint - look up a path to be umounted
2688	* @nd: lookup context	2621	* @nd: lookup context
@@ -2699,14 +2632,17 @@ path_mountpoint(struct nameidata nd, unsigned flags, struct path path) · 10 unmodified lines
2699	int err;	2632	int err;
2700		2633
2701	while (!(err = link_path_walk(s, nd)) &&	2634	while (!(err = link_path_walk(s, nd)) &&
2702	(err = mountpoint_last(nd)) > 0) {	2635	(err = lookup_last(nd)) > 0) {
2703	s = trailing_symlink(nd);	2636	s = trailing_symlink(nd);
2704	}	2637	}
		2638	if (!err && (nd->flags & LOOKUP_RCU))
		2639	err = unlazy_walk(nd);
		2640	if (!err)
		2641	err = handle_lookup_down(nd);
2705	if (!err) {	2642	if (!err) {
2706	*path = nd->path;	2643	*path = nd->path;
2707	nd->path.mnt = NULL;	2644	nd->path.mnt = NULL;
2708	nd->path.dentry = NULL;	2645	nd->path.dentry = NULL;
2709	follow_mount(path);
2710	}	2646	}
2711	terminate_walk(nd);	2647	terminate_walk(nd);
2712	return err;	2648	return err;

fs/nfs/nfstrace.h+0−2

 TRACE_DEFINE_ENUM(LOOKUP_PARENT);
 TRACE_DEFINE_ENUM(LOOKUP_REVAL);
 TRACE_DEFINE_ENUM(LOOKUP_RCU);
-TRACE_DEFINE_ENUM(LOOKUP_NO_REVAL);
 TRACE_DEFINE_ENUM(LOOKUP_OPEN);
 TRACE_DEFINE_ENUM(LOOKUP_CREATE);
 TRACE_DEFINE_ENUM(LOOKUP_EXCL);
 			{ LOOKUP_PARENT, "PARENT" }, \
 			{ LOOKUP_REVAL, "REVAL" }, \
 			{ LOOKUP_RCU, "RCU" }, \
-			{ LOOKUP_NO_REVAL, "NO_REVAL" }, \
 			{ LOOKUP_OPEN, "OPEN" }, \
 			{ LOOKUP_CREATE, "CREATE" }, \
 			{ LOOKUP_EXCL, "EXCL" }, \

include/asm-generic/cacheflush.h+32−1

  * The cache doesn't need to be flushed when TLB entries change when
  * the cache is mapped to physical memory, not virtual memory
  */
+#ifndef flush_cache_all
 static inline void flush_cache_all(void)
 {
 }
+#endif
+#ifndef flush_cache_mm
 static inline void flush_cache_mm(struct mm_struct *mm)
 {
 }
+#endif
+#ifndef flush_cache_dup_mm
 static inline void flush_cache_dup_mm(struct mm_struct *mm)
 {
 }
+#endif
+#ifndef flush_cache_range
 static inline void flush_cache_range(struct vm_area_struct *vma,
 				     unsigned long start,
 				     unsigned long end)
 {
 }
+#endif
+#ifndef flush_cache_page
 static inline void flush_cache_page(struct vm_area_struct *vma,
 				    unsigned long vmaddr,
 				    unsigned long pfn)
 {
 }
+#endif
+#ifndef flush_dcache_page
 static inline void flush_dcache_page(struct page *page)
 {
 }
+#endif
+#ifndef flush_dcache_mmap_lock
 static inline void flush_dcache_mmap_lock(struct address_space *mapping)
 {
 }
+#endif
+#ifndef flush_dcache_mmap_unlock
 static inline void flush_dcache_mmap_unlock(struct address_space *mapping)
 {
 }
+#endif
+#ifndef flush_icache_range
 static inline void flush_icache_range(unsigned long start, unsigned long end)
 {
 }
+#endif
+#ifndef flush_icache_page
 static inline void flush_icache_page(struct vm_area_struct *vma,
 				     struct page *page)
 {
 }
+#endif
+#ifndef flush_icache_user_range
 static inline void flush_icache_user_range(struct vm_area_struct *vma,
 					   struct page *page,
 					   unsigned long addr, int len)
 {
 }
+#endif
+#ifndef flush_cache_vmap
 static inline void flush_cache_vmap(unsigned long start, unsigned long end)
 {
 }
+#endif
+#ifndef flush_cache_vunmap
 static inline void flush_cache_vunmap(unsigned long start, unsigned long end)
 {
 }
+#endif
-#define copy_to_user_page(vma, page, vaddr, dst, src, len) \
+#ifndef copy_to_user_page
+#define copy_to_user_page(vma, page, vaddr, dst, src, len)	\
 	do { \
 		memcpy(dst, src, len); \
 		flush_icache_user_range(vma, page, vaddr, len); \
 	} while (0)
+#endif
+#ifndef copy_from_user_page
 #define copy_from_user_page(vma, page, vaddr, dst, src, len) \
 	memcpy(dst, src, len)
+#endif
 #endif /* __ASM_CACHEFLUSH_H */

include/drm/drm_dp_mst_helper.h+6−0

 	 * &drm_dp_sideband_msg_tx.state once they are queued
 	 */
 	struct mutex qlock;
+	/**
+	 * @is_waiting_for_dwn_reply: indicate whether is waiting for down reply
+	 */
+	bool is_waiting_for_dwn_reply;
 	/**
 	 * @tx_msg_downq: List of pending down replies.
 	 */

include/dt-bindings/reset/amlogic,meson8b-reset.h+3−3

@@ -46,9 +46,9 @@ · 45 unmodified lines
46	#define RESET_VD_RMEM 64	46	#define RESET_VD_RMEM 64
47	#define RESET_AUDIN 65	47	#define RESET_AUDIN 65
48	#define RESET_DBLK 66	48	#define RESET_DBLK 66
49	#define RESET_PIC_DC 66	49	#define RESET_PIC_DC 67
50	#define RESET_PSC 66	50	#define RESET_PSC 68
51	#define RESET_NAND 66	51	#define RESET_NAND 69
52	#define RESET_GE2D 70	52	#define RESET_GE2D 70
53	#define RESET_PARSER_REG 71	53	#define RESET_PARSER_REG 71
54	#define RESET_PARSER_FETCH 72	54	#define RESET_PARSER_FETCH 72

include/linux/blkdev.h+4−4

 	unsigned int		max_sectors;
 	unsigned int		max_segment_size;
 	unsigned int		physical_block_size;
+	unsigned int		logical_block_size;
 	unsigned int		alignment_offset;
 	unsigned int		io_min;
 	unsigned int		io_opt;
 	unsigned int		discard_granularity;
 	unsigned int		discard_alignment;
-	unsigned short		logical_block_size;
 	unsigned short		max_segments;
 	unsigned short		max_integrity_segments;
 	unsigned short		max_discard_segments;
 		unsigned int max_write_same_sectors);
 extern void blk_queue_max_write_zeroes_sectors(struct request_queue *q,
 		unsigned int max_write_same_sectors);
-extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
+extern void blk_queue_logical_block_size(struct request_queue *, unsigned int);
 extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
 extern void blk_queue_alignment_offset(struct request_queue *q,
 				       unsigned int alignment);
 	return q->limits.max_segment_size;
 }
-static inline unsigned short queue_logical_block_size(const struct request_queue *q)
+static inline unsigned queue_logical_block_size(const struct request_queue *q)
 {
 	int retval = 512;
 	return retval;
 }
-static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
+static inline unsigned int bdev_logical_block_size(struct block_device *bdev)
 {
 	return queue_logical_block_size(bdev_get_queue(bdev));
 }

include/linux/mm.h+15−3

 	       !page_poisoning_enabled();
 }
-#ifdef CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT
+#ifdef CONFIG_DEBUG_PAGEALLOC
-DECLARE_STATIC_KEY_TRUE(_debug_pagealloc_enabled);
+extern void init_debug_pagealloc(void);
 #else
-DECLARE_STATIC_KEY_FALSE(_debug_pagealloc_enabled);
+static inline void init_debug_pagealloc(void) {}
 #endif
+extern bool _debug_pagealloc_enabled_early;
+DECLARE_STATIC_KEY_FALSE(_debug_pagealloc_enabled);
 static inline bool debug_pagealloc_enabled(void)
+{
+	return IS_ENABLED(CONFIG_DEBUG_PAGEALLOC) &&
+		_debug_pagealloc_enabled_early;
+}
+/*
+ * For use in fast paths after init_debug_pagealloc() has run, or when a
+ * false negative result is not harmful when called too early.
+ */
+static inline bool debug_pagealloc_enabled_static(void)
 {
 	if (!IS_ENABLED(CONFIG_DEBUG_PAGEALLOC))
 		return false;

include/linux/mmzone.h+2−3

 	NR_INACTIVE_FILE,	/*  "     "     "   "       "         */
 	NR_ACTIVE_FILE,		/*  "     "     "   "       "         */
 	NR_UNEVICTABLE,		/*  "     "     "   "       "         */
-	NR_SLAB_RECLAIMABLE,	/* Please do not reorder this item */
+	NR_SLAB_RECLAIMABLE,
-	NR_SLAB_UNRECLAIMABLE,	/* and this one without looking at
+	NR_SLAB_UNRECLAIMABLE,
-				 * memcg_flush_percpu_vmstats() first. */
 	NR_ISOLATED_ANON,	/* Temporary isolated pages from anon lru */
 	NR_ISOLATED_FILE,	/* Temporary isolated pages from file lru */
 	WORKINGSET_NODES,

include/linux/namei.h+0−1

@@ -34,7 +34,6 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND}; · 33 unmodified lines
34		34
35	/* internal use only */	35	/* internal use only */
36	#define LOOKUP_PARENT 0x0010	36	#define LOOKUP_PARENT 0x0010
37	#define LOOKUP_NO_REVAL 0x0080
38	#define LOOKUP_JUMPED 0x1000	37	#define LOOKUP_JUMPED 0x1000
39	#define LOOKUP_ROOT 0x2000	38	#define LOOKUP_ROOT 0x2000
40	#define LOOKUP_ROOT_GRABBED 0x0008	39	#define LOOKUP_ROOT_GRABBED 0x0008

include/linux/sched.h+2−2

@@ -1929,11 +1929,11 @@ static inline void rseq_migrate(struct task_struct *t) · 1928 unmodified lines
1929		1929
1930	/*	1930	/*
1931	* If parent process has a registered restartable sequences area, the	1931	* If parent process has a registered restartable sequences area, the
1932	* child inherits. Only applies when forking a process, not a thread.	1932	* child inherits. Unregister rseq for a clone with CLONE_VM set.
1933	*/	1933	*/
1934	static inline void rseq_fork(struct task_struct *t, unsigned long clone_flags)	1934	static inline void rseq_fork(struct task_struct *t, unsigned long clone_flags)
1935	{	1935	{
1936	if (clone_flags & CLONE_THREAD) {	1936	if (clone_flags & CLONE_VM) {
1937	t->rseq = NULL;	1937	t->rseq = NULL;
1938	t->rseq_sig = 0;	1938	t->rseq_sig = 0;
1939	t->rseq_event_mask = 0;	1939	t->rseq_event_mask = 0;

include/linux/skmsg.h+9−4

 static inline void sk_psock_restore_proto(struct sock *sk,
 					  struct sk_psock *psock)
 {
-	sk->sk_write_space = psock->saved_write_space;
+	sk->sk_prot->unhash = psock->saved_unhash;
 	if (psock->sk_proto) {
 		struct inet_connection_sock *icsk = inet_csk(sk);
 		bool has_ulp = !!icsk->icsk_ulp_data;
-		if (has_ulp)
+		if (has_ulp) {
-			tcp_update_ulp(sk, psock->sk_proto);
+			tcp_update_ulp(sk, psock->sk_proto,
-		else
+				       psock->saved_write_space);
+		} else {
 			sk->sk_prot = psock->sk_proto;
+			sk->sk_write_space = psock->saved_write_space;
+		}
 		psock->sk_proto = NULL;
+	} else {
+		sk->sk_write_space = psock->saved_write_space;
 	}
 }

include/linux/tnum.h+1−1

@@ -30,7 +30,7 @@ struct tnum tnum_lshift(struct tnum a, u8 shift); · 29 unmodified lines
30	/* Shift (rsh) a tnum right (by a fixed shift) */	30	/* Shift (rsh) a tnum right (by a fixed shift) */
31	struct tnum tnum_rshift(struct tnum a, u8 shift);	31	struct tnum tnum_rshift(struct tnum a, u8 shift);
32	/* Shift (arsh) a tnum right (by a fixed min_shift) */	32	/* Shift (arsh) a tnum right (by a fixed min_shift) */
33	struct tnum tnum_arshift(struct tnum a, u8 min_shift);	33	struct tnum tnum_arshift(struct tnum a, u8 min_shift, u8 insn_bitness);
34	/* Add two tnums, return @a + @b */	34	/* Add two tnums, return @a + @b */
35	struct tnum tnum_add(struct tnum a, struct tnum b);	35	struct tnum tnum_add(struct tnum a, struct tnum b);
36	/* Subtract two tnums, return @a - @b */	36	/* Subtract two tnums, return @a - @b */

include/net/cfg80211.h+5−0

  *
  * @start_radar_detection: Start radar detection in the driver.
  *
+ * @end_cac: End running CAC, probably because a related CAC
+ *	was finished on another phy.
+ *
  * @update_ft_ies: Provide updated Fast BSS Transition information to the
  *	driver. If the SME is in the driver/firmware, this information can be
  *	used in building Authentication and Reassociation Request frames.
 					 struct net_device *dev,
 					 struct cfg80211_chan_def *chandef,
 					 u32 cac_time_ms);
+	void	(*end_cac)(struct wiphy *wiphy,
+				struct net_device *dev);
 	int	(*update_ft_ies)(struct wiphy *wiphy, struct net_device *dev,
 				 struct cfg80211_update_ft_ies_params *ftie);
 	int	(*crit_proto_start)(struct wiphy *wiphy,

include/net/devlink.h+1−1

@@ -938,7 +938,7 @@ struct devlink_region devlink_region_create(struct devlink devlink, · 937 unmodified lines
938	u32 region_max_snapshots,	938	u32 region_max_snapshots,
939	u64 region_size);	939	u64 region_size);
940	void devlink_region_destroy(struct devlink_region *region);	940	void devlink_region_destroy(struct devlink_region *region);
941	u32 devlink_region_shapshot_id_get(struct devlink *devlink);	941	u32 devlink_region_snapshot_id_get(struct devlink *devlink);
942	int devlink_region_snapshot_create(struct devlink_region *region,	942	int devlink_region_snapshot_create(struct devlink_region *region,
943	u8 *data, u32 snapshot_id,	943	u8 *data, u32 snapshot_id,
944	devlink_snapshot_data_dest_t *data_destructor);	944	devlink_snapshot_data_dest_t *data_destructor);

include/net/tcp.h+4−2

 	/* initialize ulp */
 	int (*init)(struct sock *sk);
 	/* update ulp */
-	void (*update)(struct sock *sk, struct proto *p);
+	void (*update)(struct sock *sk, struct proto *p,
+		       void (*write_space)(struct sock *sk));
 	/* cleanup ulp */
 	void (*release)(struct sock *sk);
 	/* diagnostic */
 int tcp_set_ulp(struct sock *sk, const char *name);
 void tcp_get_available_ulp(char *buf, size_t len);
 void tcp_cleanup_ulp(struct sock *sk);
-void tcp_update_ulp(struct sock *sk, struct proto *p);
+void tcp_update_ulp(struct sock *sk, struct proto *p,
+		    void (*write_space)(struct sock *sk));
 #define MODULE_ALIAS_TCP_ULP(name)				\
 	__MODULE_INFO(alias, alias_userspace, name);		\

include/trace/events/afs.h+3−9

 TRACE_EVENT(afs_lookup,
 	    TP_PROTO(struct afs_vnode *dvnode, const struct qstr *name,
-		     struct afs_vnode *vnode),
+		     struct afs_fid *fid),
-	    TP_ARGS(dvnode, name, vnode),
+	    TP_ARGS(dvnode, name, fid),
 	    TP_STRUCT__entry(
 		    __field_struct(struct afs_fid,	dfid		)
 	    TP_fast_assign(
 		    int __len = min_t(int, name->len, 23);
 		    __entry->dfid = dvnode->fid;
-		    if (vnode) {
+		    __entry->fid = *fid;
-			    __entry->fid = vnode->fid;
-		    } else {
-			    __entry->fid.vid = 0;
-			    __entry->fid.vnode = 0;
-			    __entry->fid.unique = 0;
-		    }
 		    memcpy(__entry->name, name->name, __len);
 		    __entry->name[__len] = 0;
 			   ),

include/trace/events/huge_memory.h+2−1

@@ -31,7 +31,8 @@ · 30 unmodified lines
31	EM( SCAN_ALLOC_HUGE_PAGE_FAIL, "alloc_huge_page_failed") \	31	EM( SCAN_ALLOC_HUGE_PAGE_FAIL, "alloc_huge_page_failed") \
32	EM( SCAN_CGROUP_CHARGE_FAIL, "ccgroup_charge_failed") \	32	EM( SCAN_CGROUP_CHARGE_FAIL, "ccgroup_charge_failed") \
33	EM( SCAN_EXCEED_SWAP_PTE, "exceed_swap_pte") \	33	EM( SCAN_EXCEED_SWAP_PTE, "exceed_swap_pte") \
34	EMe(SCAN_TRUNCATED, "truncated") \	34	EM( SCAN_TRUNCATED, "truncated") \
		35	EMe(SCAN_PAGE_HAS_PRIVATE, "page_has_private") \
35		36
36	#undef EM	37	#undef EM
37	#undef EMe	38	#undef EMe

init/main.c+1−0

@@ -553,6 +553,7 @@ static void __init mm_init(void) · 552 unmodified lines
553	* bigger than MAX_ORDER unless SPARSEMEM.	553	* bigger than MAX_ORDER unless SPARSEMEM.
554	*/	554	*/
555	page_ext_init_flatmem();	555	page_ext_init_flatmem();
		556	init_debug_pagealloc();
556	report_meminit();	557	report_meminit();
557	mem_init();	558	mem_init();
558	kmem_cache_init();	559	kmem_cache_init();

kernel/bpf/tnum.c+7−2

 	return TNUM(a.value >> shift, a.mask >> shift);
 }
-struct tnum tnum_arshift(struct tnum a, u8 min_shift)
+struct tnum tnum_arshift(struct tnum a, u8 min_shift, u8 insn_bitness)
 {
 	/* if a.value is negative, arithmetic shifting by minimum shift
 	 * will have larger negative offset compared to more shifting.
 	 * If a.value is nonnegative, arithmetic shifting by minimum shift
 	 * will have larger positive offset compare to more shifting.
 	 */
-	return TNUM((s64)a.value >> min_shift, (s64)a.mask >> min_shift);
+	if (insn_bitness == 32)
+		return TNUM((u32)(((s32)a.value) >> min_shift),
+			    (u32)(((s32)a.mask)  >> min_shift));
+	else
+		return TNUM((s64)a.value >> min_shift,
+			    (s64)a.mask  >> min_shift);
 }
 struct tnum tnum_add(struct tnum a, struct tnum b)

kernel/bpf/verifier.c+10−3

 		/* Upon reaching here, src_known is true and
 		 * umax_val is equal to umin_val.
 		 */
-		dst_reg->smin_value >>= umin_val;
+		if (insn_bitness == 32) {
-		dst_reg->smax_value >>= umin_val;
+			dst_reg->smin_value = (u32)(((s32)dst_reg->smin_value) >> umin_val);
-		dst_reg->var_off = tnum_arshift(dst_reg->var_off, umin_val);
+			dst_reg->smax_value = (u32)(((s32)dst_reg->smax_value) >> umin_val);
+		} else {
+			dst_reg->smin_value >>= umin_val;
+			dst_reg->smax_value >>= umin_val;
+		}
+		dst_reg->var_off = tnum_arshift(dst_reg->var_off, umin_val,
+						insn_bitness);
 		/* blow away the dst_reg umin_value/umax_value and rely on
 		 * dst_reg var_off to refine the result.

kernel/cpu.c+72−71

 }
 EXPORT_SYMBOL(__cpuhp_remove_state);
+#ifdef CONFIG_HOTPLUG_SMT
+static void cpuhp_offline_cpu_device(unsigned int cpu)
+{
+	struct device *dev = get_cpu_device(cpu);
+	dev->offline = true;
+	/* Tell user space about the state change */
+	kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
+}
+static void cpuhp_online_cpu_device(unsigned int cpu)
+{
+	struct device *dev = get_cpu_device(cpu);
+	dev->offline = false;
+	/* Tell user space about the state change */
+	kobject_uevent(&dev->kobj, KOBJ_ONLINE);
+}
+int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval)
+{
+	int cpu, ret = 0;
+	cpu_maps_update_begin();
+	for_each_online_cpu(cpu) {
+		if (topology_is_primary_thread(cpu))
+			continue;
+		ret = cpu_down_maps_locked(cpu, CPUHP_OFFLINE);
+		if (ret)
+			break;
+		/*
+		 * As this needs to hold the cpu maps lock it's impossible
+		 * to call device_offline() because that ends up calling
+		 * cpu_down() which takes cpu maps lock. cpu maps lock
+		 * needs to be held as this might race against in kernel
+		 * abusers of the hotplug machinery (thermal management).
+		 *
+		 * So nothing would update device:offline state. That would
+		 * leave the sysfs entry stale and prevent onlining after
+		 * smt control has been changed to 'off' again. This is
+		 * called under the sysfs hotplug lock, so it is properly
+		 * serialized against the regular offline usage.
+		 */
+		cpuhp_offline_cpu_device(cpu);
+	}
+	if (!ret)
+		cpu_smt_control = ctrlval;
+	cpu_maps_update_done();
+	return ret;
+}
+int cpuhp_smt_enable(void)
+{
+	int cpu, ret = 0;
+	cpu_maps_update_begin();
+	cpu_smt_control = CPU_SMT_ENABLED;
+	for_each_present_cpu(cpu) {
+		/* Skip online CPUs and CPUs on offline nodes */
+		if (cpu_online(cpu) || !node_online(cpu_to_node(cpu)))
+			continue;
+		ret = _cpu_up(cpu, 0, CPUHP_ONLINE);
+		if (ret)
+			break;
+		/* See comment in cpuhp_smt_disable() */
+		cpuhp_online_cpu_device(cpu);
+	}
+	cpu_maps_update_done();
+	return ret;
+}
+#endif
 #if defined(CONFIG_SYSFS) && defined(CONFIG_HOTPLUG_CPU)
 static ssize_t show_cpuhp_state(struct device *dev,
 				struct device_attribute *attr, char *buf)
 #ifdef CONFIG_HOTPLUG_SMT
-static void cpuhp_offline_cpu_device(unsigned int cpu)
-{
-	struct device *dev = get_cpu_device(cpu);
-	dev->offline = true;
-	/* Tell user space about the state change */
-	kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
-}
-static void cpuhp_online_cpu_device(unsigned int cpu)
-{
-	struct device *dev = get_cpu_device(cpu);
-	dev->offline = false;
-	/* Tell user space about the state change */
-	kobject_uevent(&dev->kobj, KOBJ_ONLINE);
-}
-int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval)
-{
-	int cpu, ret = 0;
-	cpu_maps_update_begin();
-	for_each_online_cpu(cpu) {
-		if (topology_is_primary_thread(cpu))
-			continue;
-		ret = cpu_down_maps_locked(cpu, CPUHP_OFFLINE);
-		if (ret)
-			break;
-		/*
-		 * As this needs to hold the cpu maps lock it's impossible
-		 * to call device_offline() because that ends up calling
-		 * cpu_down() which takes cpu maps lock. cpu maps lock
-		 * needs to be held as this might race against in kernel
-		 * abusers of the hotplug machinery (thermal management).
-		 *
-		 * So nothing would update device:offline state. That would
-		 * leave the sysfs entry stale and prevent onlining after
-		 * smt control has been changed to 'off' again. This is
-		 * called under the sysfs hotplug lock, so it is properly
-		 * serialized against the regular offline usage.
-		 */
-		cpuhp_offline_cpu_device(cpu);
-	}
-	if (!ret)
-		cpu_smt_control = ctrlval;
-	cpu_maps_update_done();
-	return ret;
-}
-int cpuhp_smt_enable(void)
-{
-	int cpu, ret = 0;
-	cpu_maps_update_begin();
-	cpu_smt_control = CPU_SMT_ENABLED;
-	for_each_present_cpu(cpu) {
-		/* Skip online CPUs and CPUs on offline nodes */
-		if (cpu_online(cpu) || !node_online(cpu_to_node(cpu)))
-			continue;
-		ret = _cpu_up(cpu, 0, CPUHP_ONLINE);
-		if (ret)
-			break;
-		/* See comment in cpuhp_smt_disable() */
-		cpuhp_online_cpu_device(cpu);
-	}
-	cpu_maps_update_done();
-	return ret;
-}
 static ssize_t
 __store_smt_control(struct device *dev, struct device_attribute *attr,
 		    const char *buf, size_t count)

kernel/cred.c+2−2

@@ -175,8 +175,8 @@ void exit_creds(struct task_struct *tsk) · 174 unmodified lines
175	put_cred(cred);	175	put_cred(cred);
176		176
177	#ifdef CONFIG_KEYS_REQUEST_CACHE	177	#ifdef CONFIG_KEYS_REQUEST_CACHE
178	key_put(current->cached_requested_key);	178	key_put(tsk->cached_requested_key);
179	current->cached_requested_key = NULL;	179	tsk->cached_requested_key = NULL;
180	#endif	180	#endif
181	}	181	}
182		182

kernel/events/core.c+3−1

 		}
 	}
-	if (perf_need_aux_event(event) && !perf_get_aux_event(event, group_leader))
+	if (perf_need_aux_event(event) && !perf_get_aux_event(event, group_leader)) {
+		err = -EINVAL;
 		goto err_locked;
+	}
 	/*
 	 * Must be under the same ctx::mutex as perf_install_in_context(),

kernel/futex.c+1−0

@@ -1178,6 +1178,7 @@ out_error: · 1177 unmodified lines
1178		1178
1179	/**	1179	/**
1180	* wait_for_owner_exiting - Block until the owner has exited	1180	* wait_for_owner_exiting - Block until the owner has exited
		1181	* @ret: owner's current futex lock status
1181	* @exiting: Pointer to the exiting task	1182	* @exiting: Pointer to the exiting task
1182	*	1183	*
1183	* Caller must hold a refcount on @exiting.	1184	* Caller must hold a refcount on @exiting.

kernel/locking/lockdep.c+3−4

 	struct lock_trace *trace, *t2;
 	struct hlist_head *hash_head;
 	u32 hash;
-	unsigned int max_entries;
+	int max_entries;
 	BUILD_BUG_ON_NOT_POWER_OF_2(STACK_TRACE_HASH_SIZE);
 	BUILD_BUG_ON(LOCK_TRACE_SIZE_IN_LONGS >= MAX_STACK_TRACE_ENTRIES);
 	trace = (struct lock_trace *)(stack_trace + nr_stack_trace_entries);
 	max_entries = MAX_STACK_TRACE_ENTRIES - nr_stack_trace_entries -
 		LOCK_TRACE_SIZE_IN_LONGS;
-	trace->nr_entries = stack_trace_save(trace->entries, max_entries, 3);
-	if (nr_stack_trace_entries >= MAX_STACK_TRACE_ENTRIES -
+	if (max_entries <= 0) {
-	    LOCK_TRACE_SIZE_IN_LONGS - 1) {
 		if (!debug_locks_off_graph_unlock())
 			return NULL;
 		return NULL;
 	}
+	trace->nr_entries = stack_trace_save(trace->entries, max_entries, 3);
 	hash = jhash(trace->entries, trace->nr_entries *
 		     sizeof(trace->entries[0]), 0);

kernel/locking/rwsem.c+2−2

@@ -1226,8 +1226,8 @@ wait: · 1225 unmodified lines
1226	* In this case, we attempt to acquire the lock again	1226	* In this case, we attempt to acquire the lock again
1227	* without sleeping.	1227	* without sleeping.
1228	*/	1228	*/
1229	if ((wstate == WRITER_HANDOFF) &&	1229	if (wstate == WRITER_HANDOFF &&
1230	(rwsem_spin_on_owner(sem, 0) == OWNER_NULL))	1230	rwsem_spin_on_owner(sem, RWSEM_NONSPINNABLE) == OWNER_NULL)
1231	goto trylock_again;	1231	goto trylock_again;
1232		1232
1233	/* Block until there are no active lockers. */	1233	/* Block until there are no active lockers. */

kernel/ptrace.c+10−5

 	return ret;
 }
-static int ptrace_has_cap(struct user_namespace *ns, unsigned int mode)
+static bool ptrace_has_cap(const struct cred *cred, struct user_namespace *ns,
+			   unsigned int mode)
 {
+	int ret;
 	if (mode & PTRACE_MODE_NOAUDIT)
-		return has_ns_capability_noaudit(current, ns, CAP_SYS_PTRACE);
+		ret = security_capable(cred, ns, CAP_SYS_PTRACE, CAP_OPT_NOAUDIT);
 	else
-		return has_ns_capability(current, ns, CAP_SYS_PTRACE);
+		ret = security_capable(cred, ns, CAP_SYS_PTRACE, CAP_OPT_NONE);
+	return ret == 0;
 }
 /* Returns 0 on success, -errno on denial. */
 	    gid_eq(caller_gid, tcred->sgid) &&
 	    gid_eq(caller_gid, tcred->gid))
 		goto ok;
-	if (ptrace_has_cap(tcred->user_ns, mode))
+	if (ptrace_has_cap(cred, tcred->user_ns, mode))
 		goto ok;
 	rcu_read_unlock();
 	return -EPERM;
 	mm = task->mm;
 	if (mm &&
 	    ((get_dumpable(mm) != SUID_DUMP_USER) &&
-	     !ptrace_has_cap(mm->user_ns, mode)))
+	     !ptrace_has_cap(cred, mm->user_ns, mode)))
 	    return -EPERM;
 	return security_ptrace_access_check(task, mode);

kernel/rseq.c+2−0

@@ -310,6 +310,8 @@ SYSCALL_DEFINE4(rseq, struct rseq __user *, rseq, u32, rseq_len, · 309 unmodified lines
310	int ret;	310	int ret;
311		311
312	if (flags & RSEQ_FLAG_UNREGISTER) {	312	if (flags & RSEQ_FLAG_UNREGISTER) {
		313	if (flags & ~RSEQ_FLAG_UNREGISTER)
		314	return -EINVAL;
313	/* Unregister rseq for current thread. */	315	/* Unregister rseq for current thread. */
314	if (current->rseq != rseq \|\| !current->rseq)	316	if (current->rseq != rseq \|\| !current->rseq)
315	return -EINVAL;	317	return -EINVAL;

kernel/time/posix-stubs.c+3−0

@@ -151,6 +151,9 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags, · 150 unmodified lines
151		151
152	#ifdef CONFIG_COMPAT	152	#ifdef CONFIG_COMPAT
153	COMPAT_SYS_NI(timer_create);	153	COMPAT_SYS_NI(timer_create);
		154	#endif
		155
		156	#if defined(CONFIG_COMPAT) \|\| defined(CONFIG_ALPHA)
154	COMPAT_SYS_NI(getitimer);	157	COMPAT_SYS_NI(getitimer);
155	COMPAT_SYS_NI(setitimer);	158	COMPAT_SYS_NI(setitimer);
156	#endif	159	#endif

kernel/time/tick-sched.c+9−5

 	/*
 	 * Do a quick check without holding jiffies_lock:
+	 * The READ_ONCE() pairs with two updates done later in this function.
 	 */
-	delta = ktime_sub(now, last_jiffies_update);
+	delta = ktime_sub(now, READ_ONCE(last_jiffies_update));
 	if (delta < tick_period)
 		return;
 	if (delta >= tick_period) {
 		delta = ktime_sub(delta, tick_period);
-		last_jiffies_update = ktime_add(last_jiffies_update,
+		/* Pairs with the lockless read in this function. */
-						tick_period);
+		WRITE_ONCE(last_jiffies_update,
+			   ktime_add(last_jiffies_update, tick_period));
 		/* Slow path for long timeouts */
 		if (unlikely(delta >= tick_period)) {
 			ticks = ktime_divns(delta, incr);
-			last_jiffies_update = ktime_add_ns(last_jiffies_update,
+			/* Pairs with the lockless read in this function. */
-							   incr * ticks);
+			WRITE_ONCE(last_jiffies_update,
+				   ktime_add_ns(last_jiffies_update,
+						incr * ticks));
 		}
 		do_timer(++ticks);

lib/vdso/gettimeofday.c+1−0

@@ -221,6 +221,7 @@ int __cvdso_clock_getres_common(clockid_t clock, struct __kernel_timespec *res) · 220 unmodified lines
221	return 0;	221	return 0;
222	}	222	}
223		223
		224	static __maybe_unused
224	int __cvdso_clock_getres(clockid_t clock, struct __kernel_timespec *res)	225	int __cvdso_clock_getres(clockid_t clock, struct __kernel_timespec *res)
225	{	226	{
226	int ret = __cvdso_clock_getres_common(clock, res);	227	int ret = __cvdso_clock_getres_common(clock, res);

mm/huge_memory.c+24−14

@@ -527,13 +527,13 @@ void prep_transhuge_page(struct page *page) · 526 unmodified lines
527	set_compound_page_dtor(page, TRANSHUGE_PAGE_DTOR);	527	set_compound_page_dtor(page, TRANSHUGE_PAGE_DTOR);
528	}	528	}
529		529
530	static unsigned long __thp_get_unmapped_area(struct file *filp, unsigned long len,	530	static unsigned long __thp_get_unmapped_area(struct file *filp,
		531	unsigned long addr, unsigned long len,
531	loff_t off, unsigned long flags, unsigned long size)	532	loff_t off, unsigned long flags, unsigned long size)
532	{	533	{
533	unsigned long addr;
534	loff_t off_end = off + len;	534	loff_t off_end = off + len;
535	loff_t off_align = round_up(off, size);	535	loff_t off_align = round_up(off, size);
536	unsigned long len_pad;	536	unsigned long len_pad, ret;
537		537
538	if (off_end <= off_align \|\| (off_end - off_align) < size)	538	if (off_end <= off_align \|\| (off_end - off_align) < size)
539	return 0;	539	return 0;
@@ -542,30 +542,40 @@ static unsigned long __thp_get_unmapped_area(struct file *filp, unsigned long le · 2 unmodified lines
542	if (len_pad < len \|\| (off + len_pad) < off)	542	if (len_pad < len \|\| (off + len_pad) < off)
543	return 0;	543	return 0;
544		544
545	addr = current->mm->get_unmapped_area(filp, 0, len_pad,	545	ret = current->mm->get_unmapped_area(filp, addr, len_pad,
546	off >> PAGE_SHIFT, flags);	546	off >> PAGE_SHIFT, flags);
547	if (IS_ERR_VALUE(addr))	547
		548	/*
		549	* The failure might be due to length padding. The caller will retry
		550	* without the padding.
		551	*/
		552	if (IS_ERR_VALUE(ret))
548	return 0;	553	return 0;
549		554
550	addr += (off - addr) & (size - 1);	555	/*
551	return addr;	556	* Do not try to align to THP boundary if allocation at the address
		557	* hint succeeds.
		558	*/
		559	if (ret == addr)
		560	return addr;
		561
		562	ret += (off - ret) & (size - 1);
		563	return ret;
552	}	564	}
553		565
554	unsigned long thp_get_unmapped_area(struct file *filp, unsigned long addr,	566	unsigned long thp_get_unmapped_area(struct file *filp, unsigned long addr,
555	unsigned long len, unsigned long pgoff, unsigned long flags)	567	unsigned long len, unsigned long pgoff, unsigned long flags)
556	{	568	{
		569	unsigned long ret;
557	loff_t off = (loff_t)pgoff << PAGE_SHIFT;	570	loff_t off = (loff_t)pgoff << PAGE_SHIFT;
558		571
559	if (addr)
560	goto out;
561	if (!IS_DAX(filp->f_mapping->host) \|\| !IS_ENABLED(CONFIG_FS_DAX_PMD))	572	if (!IS_DAX(filp->f_mapping->host) \|\| !IS_ENABLED(CONFIG_FS_DAX_PMD))
562	goto out;	573	goto out;
563		574
564	addr = __thp_get_unmapped_area(filp, len, off, flags, PMD_SIZE);	575	ret = __thp_get_unmapped_area(filp, addr, len, off, flags, PMD_SIZE);
565	if (addr)	576	if (ret)
566	return addr;	577	return ret;
567		578	out:
568	out:
569	return current->mm->get_unmapped_area(filp, addr, len, pgoff, flags);	579	return current->mm->get_unmapped_area(filp, addr, len, pgoff, flags);
570	}	580	}
571	EXPORT_SYMBOL_GPL(thp_get_unmapped_area);	581	EXPORT_SYMBOL_GPL(thp_get_unmapped_area);

mm/memcontrol.c+9−28

 	}
 }
-static void memcg_flush_percpu_vmstats(struct mem_cgroup *memcg, bool slab_only)
+static void memcg_flush_percpu_vmstats(struct mem_cgroup *memcg)
 {
-	unsigned long stat[MEMCG_NR_STAT];
+	unsigned long stat[MEMCG_NR_STAT] = {0};
 	struct mem_cgroup *mi;
 	int node, cpu, i;
-	int min_idx, max_idx;
-	if (slab_only) {
-		min_idx = NR_SLAB_RECLAIMABLE;
-		max_idx = NR_SLAB_UNRECLAIMABLE;
-	} else {
-		min_idx = 0;
-		max_idx = MEMCG_NR_STAT;
-	}
-	for (i = min_idx; i < max_idx; i++)
-		stat[i] = 0;
 	for_each_online_cpu(cpu)
-		for (i = min_idx; i < max_idx; i++)
+		for (i = 0; i < MEMCG_NR_STAT; i++)
 			stat[i] += per_cpu(memcg->vmstats_percpu->stat[i], cpu);
 	for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
-		for (i = min_idx; i < max_idx; i++)
+		for (i = 0; i < MEMCG_NR_STAT; i++)
 			atomic_long_add(stat[i], &mi->vmstats[i]);
-	if (!slab_only)
-		max_idx = NR_VM_NODE_STAT_ITEMS;
 	for_each_node(node) {
 		struct mem_cgroup_per_node *pn = memcg->nodeinfo[node];
 		struct mem_cgroup_per_node *pi;
-		for (i = min_idx; i < max_idx; i++)
+		for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
 			stat[i] = 0;
 		for_each_online_cpu(cpu)
-			for (i = min_idx; i < max_idx; i++)
+			for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
 				stat[i] += per_cpu(
 					pn->lruvec_stat_cpu->count[i], cpu);
 		for (pi = pn; pi; pi = parent_nodeinfo(pi, node))
-			for (i = min_idx; i < max_idx; i++)
+			for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
 				atomic_long_add(stat[i], &pi->lruvec_stat[i]);
 	}
 }
 		parent = root_mem_cgroup;
 	/*
-	 * Deactivate and reparent kmem_caches. Then flush percpu
+	 * Deactivate and reparent kmem_caches.
-	 * slab statistics to have precise values at the parent and
-	 * all ancestor levels. It's required to keep slab stats
-	 * accurate after the reparenting of kmem_caches.
 	 */
 	memcg_deactivate_kmem_caches(memcg, parent);
-	memcg_flush_percpu_vmstats(memcg, true);
 	kmemcg_id = memcg->kmemcg_id;
 	BUG_ON(kmemcg_id < 0);
 	 * Flush percpu vmstats and vmevents to guarantee the value correctness
 	 * on parent's and all ancestor levels.
 	 */
-	memcg_flush_percpu_vmstats(memcg, false);
+	memcg_flush_percpu_vmstats(memcg);
 	memcg_flush_percpu_vmevents(memcg);
 	__mem_cgroup_free(memcg);
 }

mm/mempolicy.c+7−3

 		nmask = policy_nodemask(gfp, pol);
 		if (!nmask || node_isset(hpage_node, *nmask)) {
 			mpol_cond_put(pol);
+			/*
+			 * First, try to allocate THP only on local node, but
+			 * don't reclaim unnecessarily, just compact.
+			 */
 			page = __alloc_pages_node(hpage_node,
-						gfp | __GFP_THISNODE, order);
+				gfp | __GFP_THISNODE | __GFP_NORETRY, order);
 			/*
 			 * If hugepage allocations are configured to always
 			 * synchronous compact or the vma has been madvised
 			 * to prefer hugepage backing, retry allowing remote
-			 * memory as well.
+			 * memory with both reclaim and compact as well.
 			 */
 			if (!page && (gfp & __GFP_DIRECT_RECLAIM))
 				page = __alloc_pages_node(hpage_node,
-						gfp | __GFP_NORETRY, order);
+								gfp, order);
 			goto out;
 		}

mm/page-writeback.c+5−5

@@ -201,11 +201,11 @@ static void wb_min_max_ratio(struct bdi_writeback *wb, · 200 unmodified lines
201	if (this_bw < tot_bw) {	201	if (this_bw < tot_bw) {
202	if (min) {	202	if (min) {
203	min *= this_bw;	203	min *= this_bw;
204	do_div(min, tot_bw);	204	min = div64_ul(min, tot_bw);
205	}	205	}
206	if (max < 100) {	206	if (max < 100) {
207	max *= this_bw;	207	max *= this_bw;
208	do_div(max, tot_bw);	208	max = div64_ul(max, tot_bw);
209	}	209	}
210	}	210	}
211		211
@@ -766,7 +766,7 @@ static unsigned long __wb_calc_thresh(struct dirty_throttle_control *dtc) · 554 unmodified lines
766	struct wb_domain *dom = dtc_dom(dtc);	766	struct wb_domain *dom = dtc_dom(dtc);
767	unsigned long thresh = dtc->thresh;	767	unsigned long thresh = dtc->thresh;
768	u64 wb_thresh;	768	u64 wb_thresh;
769	long numerator, denominator;	769	unsigned long numerator, denominator;
770	unsigned long wb_min_ratio, wb_max_ratio;	770	unsigned long wb_min_ratio, wb_max_ratio;
771		771
772	/*	772	/*
@@ -777,7 +777,7 @@ static unsigned long __wb_calc_thresh(struct dirty_throttle_control *dtc) · 4 unmodified lines
777		777
778	wb_thresh = (thresh * (100 - bdi_min_ratio)) / 100;	778	wb_thresh = (thresh * (100 - bdi_min_ratio)) / 100;
779	wb_thresh *= numerator;	779	wb_thresh *= numerator;
780	do_div(wb_thresh, denominator);	780	wb_thresh = div64_ul(wb_thresh, denominator);
781		781
782	wb_min_max_ratio(dtc->wb, &wb_min_ratio, &wb_max_ratio);	782	wb_min_max_ratio(dtc->wb, &wb_min_ratio, &wb_max_ratio);
783		783
@@ -1102,7 +1102,7 @@ static void wb_update_write_bandwidth(struct bdi_writeback *wb, · 318 unmodified lines
1102	bw = written - min(written, wb->written_stamp);	1102	bw = written - min(written, wb->written_stamp);
1103	bw *= HZ;	1103	bw *= HZ;
1104	if (unlikely(elapsed > period)) {	1104	if (unlikely(elapsed > period)) {
1105	do_div(bw, elapsed);	1105	bw = div64_ul(bw, elapsed);
1106	avg = bw;	1106	avg = bw;
1107	goto out;	1107	goto out;
1108	}	1108	}

mm/page_alloc.c+18−43

 #ifdef CONFIG_DEBUG_PAGEALLOC
 unsigned int _debug_guardpage_minorder;
-#ifdef CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT
+bool _debug_pagealloc_enabled_early __read_mostly
-DEFINE_STATIC_KEY_TRUE(_debug_pagealloc_enabled);
+			= IS_ENABLED(CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT);
-#else
+EXPORT_SYMBOL(_debug_pagealloc_enabled_early);
 DEFINE_STATIC_KEY_FALSE(_debug_pagealloc_enabled);
-#endif
 EXPORT_SYMBOL(_debug_pagealloc_enabled);
 DEFINE_STATIC_KEY_FALSE(_debug_guardpage_enabled);
 static int __init early_debug_pagealloc(char *buf)
 {
-	bool enable = false;
+	return kstrtobool(buf, &_debug_pagealloc_enabled_early);
-	if (kstrtobool(buf, &enable))
-		return -EINVAL;
-	if (enable)
-		static_branch_enable(&_debug_pagealloc_enabled);
-	return 0;
 }
 early_param("debug_pagealloc", early_debug_pagealloc);
-static void init_debug_guardpage(void)
+void init_debug_pagealloc(void)
 {
 	if (!debug_pagealloc_enabled())
 		return;
+	static_branch_enable(&_debug_pagealloc_enabled);
 	if (!debug_guardpage_minorder())
 		return;
 	 */
 	arch_free_page(page, order);
-	if (debug_pagealloc_enabled())
+	if (debug_pagealloc_enabled_static())
 		kernel_map_pages(page, 1 << order, 0);
 	kasan_free_nondeferred_pages(page, order);
 static bool bulkfree_pcp_prepare(struct page *page)
 {
-	if (debug_pagealloc_enabled())
+	if (debug_pagealloc_enabled_static())
 		return free_pages_check(page);
 	else
 		return false;
  */
 static bool free_pcp_prepare(struct page *page)
 {
-	if (debug_pagealloc_enabled())
+	if (debug_pagealloc_enabled_static())
 		return free_pages_prepare(page, 0, true);
 	else
 		return free_pages_prepare(page, 0, false);
 	for_each_populated_zone(zone)
 		set_zone_contiguous(zone);
-#ifdef CONFIG_DEBUG_PAGEALLOC
-	init_debug_guardpage();
-#endif
 }
 #ifdef CONFIG_CMA
  */
 static inline bool check_pcp_refill(struct page *page)
 {
-	if (debug_pagealloc_enabled())
+	if (debug_pagealloc_enabled_static())
 		return check_new_page(page);
 	else
 		return false;
 }
 static inline bool check_new_pcp(struct page *page)
 {
-	if (debug_pagealloc_enabled())
+	if (debug_pagealloc_enabled_static())
 		return check_new_page(page);
 	else
 		return false;
 	set_page_refcounted(page);
 	arch_alloc_page(page, order);
-	if (debug_pagealloc_enabled())
+	if (debug_pagealloc_enabled_static())
 		kernel_map_pages(page, 1 << order, 1);
 	kasan_alloc_pages(page, order);
 	kernel_poison_pages(page, 1 << order, 1);
 		if (page)
 			goto got_pg;
-		 if (order >= pageblock_order && (gfp_mask & __GFP_IO) &&
+		/*
-		     !(gfp_mask & __GFP_RETRY_MAYFAIL)) {
+		 * Checks for costly allocations with __GFP_NORETRY, which
+		 * includes some THP page fault allocations
+		 */
+		if (costly_order && (gfp_mask & __GFP_NORETRY)) {
 			/*
 			 * If allocating entire pageblock(s) and compaction
 			 * failed because all zones are below low watermarks
 			if (compact_result == COMPACT_SKIPPED ||
 			    compact_result == COMPACT_DEFERRED)
 				goto nopage;
-		}
-		/*
-		 * Checks for costly allocations with __GFP_NORETRY, which
-		 * includes THP page fault allocations
-		 */
-		if (costly_order && (gfp_mask & __GFP_NORETRY)) {
-			/*
-			 * If compaction is deferred for high-order allocations,
-			 * it is because sync compaction recently failed. If
-			 * this is the case and the caller requested a THP
-			 * allocation, we do not want to heavily disrupt the
-			 * system, so we fail the allocation instead of entering
-			 * direct reclaim.
-			 */
-			if (compact_result == COMPACT_DEFERRED)
-				goto nopage;
 			/*
 			 * Looks like reclaim/compaction is worth trying, but

mm/shmem.c+4−3

 	/*
 	 * Our priority is to support MAP_SHARED mapped hugely;
 	 * and support MAP_PRIVATE mapped hugely too, until it is COWed.
-	 * But if caller specified an address hint, respect that as before.
+	 * But if caller specified an address hint and we allocated area there
+	 * successfully, respect that as before.
 	 */
-	if (uaddr)
+	if (uaddr == addr)
 		return addr;
 	if (shmem_huge != SHMEM_HUGE_FORCE) {
 	if (inflated_len < len)
 		return addr;
-	inflated_addr = get_area(NULL, 0, inflated_len, 0, flags);
+	inflated_addr = get_area(NULL, uaddr, inflated_len, 0, flags);
 	if (IS_ERR_VALUE(inflated_addr))
 		return addr;
 	if (inflated_addr & ~PAGE_MASK)

mm/slab.c+2−2

@@ -1416,7 +1416,7 @@ static void kmem_rcu_free(struct rcu_head *head) · 1415 unmodified lines
1416	#if DEBUG	1416	#if DEBUG
1417	static bool is_debug_pagealloc_cache(struct kmem_cache *cachep)	1417	static bool is_debug_pagealloc_cache(struct kmem_cache *cachep)
1418	{	1418	{
1419	if (debug_pagealloc_enabled() && OFF_SLAB(cachep) &&	1419	if (debug_pagealloc_enabled_static() && OFF_SLAB(cachep) &&
1420	(cachep->size % PAGE_SIZE) == 0)	1420	(cachep->size % PAGE_SIZE) == 0)
1421	return true;	1421	return true;
1422		1422
@@ -2008,7 +2008,7 @@ int __kmem_cache_create(struct kmem_cache *cachep, slab_flags_t flags) · 585 unmodified lines
2008	* to check size >= 256. It guarantees that all necessary small	2008	* to check size >= 256. It guarantees that all necessary small
2009	* sized slab is initialized in current slab initialization sequence.	2009	* sized slab is initialized in current slab initialization sequence.
2010	*/	2010	*/
2011	if (debug_pagealloc_enabled() && (flags & SLAB_POISON) &&	2011	if (debug_pagealloc_enabled_static() && (flags & SLAB_POISON) &&
2012	size >= 256 && cachep->object_size > cache_line_size()) {	2012	size >= 256 && cachep->object_size > cache_line_size()) {
2013	if (size < PAGE_SIZE \|\| size % PAGE_SIZE == 0) {	2013	if (size < PAGE_SIZE \|\| size % PAGE_SIZE == 0) {
2014	size_t tmp_size = ALIGN(size, PAGE_SIZE);	2014	size_t tmp_size = ALIGN(size, PAGE_SIZE);

mm/slab_common.c+2−1

@@ -903,7 +903,8 @@ static void flush_memcg_workqueue(struct kmem_cache *s) · 902 unmodified lines
903	* deactivates the memcg kmem_caches through workqueue. Make sure all	903	* deactivates the memcg kmem_caches through workqueue. Make sure all
904	* previous workitems on workqueue are processed.	904	* previous workitems on workqueue are processed.
905	*/	905	*/
906	flush_workqueue(memcg_kmem_cache_wq);	906	if (likely(memcg_kmem_cache_wq))
		907	flush_workqueue(memcg_kmem_cache_wq);
907		908
908	/*	909	/*
909	* If we're racing with children kmem_cache deactivation, it might	910	* If we're racing with children kmem_cache deactivation, it might

mm/slub.c+1−1

@@ -288,7 +288,7 @@ static inline void get_freepointer_safe(struct kmem_cache s, void *object) · 287 unmodified lines
288	unsigned long freepointer_addr;	288	unsigned long freepointer_addr;
289	void *p;	289	void *p;
290		290
291	if (!debug_pagealloc_enabled())	291	if (!debug_pagealloc_enabled_static())
292	return get_freepointer(s, object);	292	return get_freepointer(s, object);
293		293
294	freepointer_addr = (unsigned long)object + s->offset;	294	freepointer_addr = (unsigned long)object + s->offset;

mm/sparse.c+8−1

 	if (bitmap_empty(subsection_map, SUBSECTIONS_PER_SECTION)) {
 		unsigned long section_nr = pfn_to_section_nr(pfn);
-		if (!section_is_early) {
+		/*
+		 * When removing an early section, the usage map is kept (as the
+		 * usage maps of other sections fall into the same page). It
+		 * will be re-used when re-adding the section - which is then no
+		 * longer an early section. If the usage map is PageReserved, it
+		 * was allocated during boot.
+		 */
+		if (!PageReserved(virt_to_page(ms->usage))) {
 			kfree(ms->usage);
 			ms->usage = NULL;
 		}

mm/vmalloc.c+2−2

@@ -1383,7 +1383,7 @@ static void free_unmap_vmap_area(struct vmap_area *va) · 1382 unmodified lines
1383	{	1383	{
1384	flush_cache_vunmap(va->va_start, va->va_end);	1384	flush_cache_vunmap(va->va_start, va->va_end);
1385	unmap_vmap_area(va);	1385	unmap_vmap_area(va);
1386	if (debug_pagealloc_enabled())	1386	if (debug_pagealloc_enabled_static())
1387	flush_tlb_kernel_range(va->va_start, va->va_end);	1387	flush_tlb_kernel_range(va->va_start, va->va_end);
1388		1388
1389	free_vmap_area_noflush(va);	1389	free_vmap_area_noflush(va);
@@ -1681,7 +1681,7 @@ static void vb_free(const void *addr, unsigned long size) · 291 unmodified lines
1681		1681
1682	vunmap_page_range((unsigned long)addr, (unsigned long)addr + size);	1682	vunmap_page_range((unsigned long)addr, (unsigned long)addr + size);
1683		1683
1684	if (debug_pagealloc_enabled())	1684	if (debug_pagealloc_enabled_static())
1685	flush_tlb_kernel_range((unsigned long)addr,	1685	flush_tlb_kernel_range((unsigned long)addr,
1686	(unsigned long)addr + size);	1686	(unsigned long)addr + size);
1687		1687

net/batman-adv/distributed-arp-table.c+3−1

 	u32 hash = 0;
 	const struct batadv_dat_entry *dat = data;
 	const unsigned char *key;
+	__be16 vid;
 	u32 i;
 	key = (const unsigned char *)&dat->ip;
 		hash ^= (hash >> 6);
 	}
-	key = (const unsigned char *)&dat->vid;
+	vid = htons(dat->vid);
+	key = (__force const unsigned char *)&vid;
 	for (i = 0; i < sizeof(dat->vid); i++) {
 		hash += key[i];
 		hash += (hash << 10);

net/core/dev.c+0−12

@@ -9177,22 +9177,10 @@ static void netdev_unregister_lockdep_key(struct net_device *dev) · 9176 unmodified lines
9177		9177
9178	void netdev_update_lockdep_key(struct net_device *dev)	9178	void netdev_update_lockdep_key(struct net_device *dev)
9179	{	9179	{
9180	struct netdev_queue *queue;
9181	int i;
9182
9183	lockdep_unregister_key(&dev->qdisc_xmit_lock_key);
9184	lockdep_unregister_key(&dev->addr_list_lock_key);	9180	lockdep_unregister_key(&dev->addr_list_lock_key);
9185
9186	lockdep_register_key(&dev->qdisc_xmit_lock_key);
9187	lockdep_register_key(&dev->addr_list_lock_key);	9181	lockdep_register_key(&dev->addr_list_lock_key);
9188		9182
9189	lockdep_set_class(&dev->addr_list_lock, &dev->addr_list_lock_key);	9183	lockdep_set_class(&dev->addr_list_lock, &dev->addr_list_lock_key);
9190	for (i = 0; i < dev->num_tx_queues; i++) {
9191	queue = netdev_get_tx_queue(dev, i);
9192
9193	lockdep_set_class(&queue->_xmit_lock,
9194	&dev->qdisc_xmit_lock_key);
9195	}
9196	}	9184	}
9197	EXPORT_SYMBOL(netdev_update_lockdep_key);	9185	EXPORT_SYMBOL(netdev_update_lockdep_key);
9198		9186

net/core/devlink.c+4−4

@@ -6406,7 +6406,7 @@ static bool devlink_port_type_should_warn(struct devlink_port *devlink_port) · 6405 unmodified lines
6406	devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_DSA;	6406	devlink_port->attrs.flavour != DEVLINK_PORT_FLAVOUR_DSA;
6407	}	6407	}
6408		6408
6409	#define DEVLINK_PORT_TYPE_WARN_TIMEOUT (HZ * 30)	6409	#define DEVLINK_PORT_TYPE_WARN_TIMEOUT (HZ * 3600)
6410		6410
6411	static void devlink_port_type_warn_schedule(struct devlink_port *devlink_port)	6411	static void devlink_port_type_warn_schedule(struct devlink_port *devlink_port)
6412	{	6412	{
@@ -7563,7 +7563,7 @@ void devlink_region_destroy(struct devlink_region *region) · 1150 unmodified lines
7563	EXPORT_SYMBOL_GPL(devlink_region_destroy);	7563	EXPORT_SYMBOL_GPL(devlink_region_destroy);
7564		7564
7565	/**	7565	/**
7566	* devlink_region_shapshot_id_get - get snapshot ID	7566	* devlink_region_snapshot_id_get - get snapshot ID
7567	*	7567	*
7568	* This callback should be called when adding a new snapshot,	7568	* This callback should be called when adding a new snapshot,
7569	* Driver should use the same id for multiple snapshots taken	7569	* Driver should use the same id for multiple snapshots taken
@@ -7571,7 +7571,7 @@ EXPORT_SYMBOL_GPL(devlink_region_destroy); · 1 unmodified line
7571	*	7571	*
7572	* @devlink: devlink	7572	* @devlink: devlink
7573	*/	7573	*/
7574	u32 devlink_region_shapshot_id_get(struct devlink *devlink)	7574	u32 devlink_region_snapshot_id_get(struct devlink *devlink)
7575	{	7575	{
7576	u32 id;	7576	u32 id;
7577		7577
@@ -7581,7 +7581,7 @@ u32 devlink_region_shapshot_id_get(struct devlink *devlink) · 3 unmodified lines
7581		7581
7582	return id;	7582	return id;
7583	}	7583	}
7584	EXPORT_SYMBOL_GPL(devlink_region_shapshot_id_get);	7584	EXPORT_SYMBOL_GPL(devlink_region_snapshot_id_get);
7585		7585
7586	/**	7586	/**
7587	* devlink_region_snapshot_create - create a new snapshot	7587	* devlink_region_snapshot_create - create a new snapshot

net/core/filter.c+10−10

 	/* First find the starting scatterlist element */
 	i = msg->sg.start;
 	do {
+		offset += len;
 		len = sk_msg_elem(msg, i)->length;
 		if (start < offset + len)
 			break;
-		offset += len;
 		sk_msg_iter_var_next(i);
 	} while (i != msg->sg.end);
 	   u32, len, u64, flags)
 {
 	struct scatterlist sge, nsge, nnsge, rsge = {0}, *psge;
-	u32 new, i = 0, l, space, copy = 0, offset = 0;
+	u32 new, i = 0, l = 0, space, copy = 0, offset = 0;
 	u8 *raw, *to, *from;
 	struct page *page;
 	/* First find the starting scatterlist element */
 	i = msg->sg.start;
 	do {
+		offset += l;
 		l = sk_msg_elem(msg, i)->length;
 		if (start < offset + l)
 			break;
-		offset += l;
 		sk_msg_iter_var_next(i);
 	} while (i != msg->sg.end);
 		sk_msg_iter_var_next(i);
 		sg_unmark_end(psge);
+		sg_unmark_end(&rsge);
 		sk_msg_iter_next(msg, end);
 	}
 BPF_CALL_4(bpf_msg_pop_data, struct sk_msg *, msg, u32, start,
 	   u32, len, u64, flags)
 {
-	u32 i = 0, l, space, offset = 0;
+	u32 i = 0, l = 0, space, offset = 0;
 	u64 last = start + len;
 	int pop;
 	/* First find the starting scatterlist element */
 	i = msg->sg.start;
 	do {
+		offset += l;
 		l = sk_msg_elem(msg, i)->length;
 		if (start < offset + l)
 			break;
-		offset += l;
 		sk_msg_iter_var_next(i);
 	} while (i != msg->sg.end);
 	if (sk) {
 		sk = sk_to_full_sk(sk);
 		if (!sk_fullsock(sk)) {
-			if (!sock_flag(sk, SOCK_RCU_FREE))
+			sock_gen_put(sk);
-				sock_gen_put(sk);
 			return NULL;
 		}
 	}
 	if (sk) {
 		sk = sk_to_full_sk(sk);
 		if (!sk_fullsock(sk)) {
-			if (!sock_flag(sk, SOCK_RCU_FREE))
+			sock_gen_put(sk);
-				sock_gen_put(sk);
 			return NULL;
 		}
 	}
 BPF_CALL_1(bpf_sk_release, struct sock *, sk)
 {
-	if (!sock_flag(sk, SOCK_RCU_FREE))
+	/* Only full sockets have sk->sk_flags. */
+	if (!sk_fullsock(sk) || !sock_flag(sk, SOCK_RCU_FREE))
 		sock_gen_put(sk);
 	return 0;
 }

net/core/skmsg.c+2−0

@@ -594,6 +594,8 @@ EXPORT_SYMBOL_GPL(sk_psock_destroy); · 593 unmodified lines
594		594
595	void sk_psock_drop(struct sock sk, struct sk_psock psock)	595	void sk_psock_drop(struct sock sk, struct sk_psock psock)
596	{	596	{
		597	sock_owned_by_me(sk);
		598
597	sk_psock_cork_free(psock);	599	sk_psock_cork_free(psock);
598	sk_psock_zap_ingress(psock);	600	sk_psock_zap_ingress(psock);
599		601

net/core/sock_map.c+6−1

 		struct sock *sk;
 		sk = xchg(psk, NULL);
-		if (sk)
+		if (sk) {
+			lock_sock(sk);
 			sock_map_unref(sk, psk);
+			release_sock(sk);
+		}
 	}
 	raw_spin_unlock_bh(&stab->lock);
 	rcu_read_unlock();
 		raw_spin_lock_bh(&bucket->lock);
 		hlist_for_each_entry_safe(elem, node, &bucket->head, node) {
 			hlist_del_rcu(&elem->node);
+			lock_sock(elem->sk);
 			sock_map_unref(elem->sk, elem);
+			release_sock(elem->sk);
 		}
 		raw_spin_unlock_bh(&bucket->lock);
 	}

net/dsa/tag_gswip.c+1−1

@@ -104,7 +104,7 @@ static struct sk_buff gswip_tag_rcv(struct sk_buff skb, · 103 unmodified lines
104	}	104	}
105		105
106	static const struct dsa_device_ops gswip_netdev_ops = {	106	static const struct dsa_device_ops gswip_netdev_ops = {
107	.name = "gwsip",	107	.name = "gswip",
108	.proto = DSA_TAG_PROTO_GSWIP,	108	.proto = DSA_TAG_PROTO_GSWIP,
109	.xmit = gswip_tag_xmit,	109	.xmit = gswip_tag_xmit,
110	.rcv = gswip_tag_rcv,	110	.rcv = gswip_tag_rcv,

net/dsa/tag_qca.c+0−3

@@ -33,9 +33,6 @@ static struct sk_buff qca_tag_xmit(struct sk_buff skb, struct net_device *dev) · 32 unmodified lines
33	struct dsa_port *dp = dsa_slave_to_port(dev);	33	struct dsa_port *dp = dsa_slave_to_port(dev);
34	u16 *phdr, hdr;	34	u16 *phdr, hdr;
35		35
36	dev->stats.tx_packets++;
37	dev->stats.tx_bytes += skb->len;
38
39	if (skb_cow_head(skb, 0) < 0)	36	if (skb_cow_head(skb, 0) < 0)
40	return NULL;	37	return NULL;
41		38

net/ipv4/fib_trie.c+6−0

 	int count = cb->args[2];
 	t_key key = cb->args[3];
+	/* First time here, count and key are both always 0. Count > 0
+	 * and key == 0 means the dump has wrapped around and we are done.
+	 */
+	if (count && !key)
+		return skb->len;
 	while ((l = leaf_walk_rcu(&tp, key)) != NULL) {
 		int err;

net/ipv4/netfilter/arp_tables.c+10−9

 	return 0;
 }
-static inline void cleanup_entry(struct arpt_entry *e)
+static void cleanup_entry(struct arpt_entry *e, struct net *net)
 {
 	struct xt_tgdtor_param par;
 	struct xt_entry_target *t;
 	t = arpt_get_target(e);
+	par.net      = net;
 	par.target   = t->u.kernel.target;
 	par.targinfo = t->data;
 	par.family   = NFPROTO_ARP;
 		xt_entry_foreach(iter, entry0, newinfo->size) {
 			if (i-- == 0)
 				break;
-			cleanup_entry(iter);
+			cleanup_entry(iter, net);
 		}
 		return ret;
 	}
 	/* Decrease module usage counts and free resource */
 	loc_cpu_old_entry = oldinfo->entries;
 	xt_entry_foreach(iter, loc_cpu_old_entry, oldinfo->size)
-		cleanup_entry(iter);
+		cleanup_entry(iter, net);
 	xt_free_table_info(oldinfo);
 	if (copy_to_user(counters_ptr, counters,
  free_newinfo_untrans:
 	xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)
-		cleanup_entry(iter);
+		cleanup_entry(iter, net);
  free_newinfo:
 	xt_free_table_info(newinfo);
 	return ret;
  free_newinfo_untrans:
 	xt_entry_foreach(iter, loc_cpu_entry, newinfo->size)
-		cleanup_entry(iter);
+		cleanup_entry(iter, net);
  free_newinfo:
 	xt_free_table_info(newinfo);
 	return ret;
 	return ret;
 }
-static void __arpt_unregister_table(struct xt_table *table)
+static void __arpt_unregister_table(struct net *net, struct xt_table *table)
 {
 	struct xt_table_info *private;
 	void *loc_cpu_entry;
 	/* Decrease module usage counts and free resources */
 	loc_cpu_entry = private->entries;
 	xt_entry_foreach(iter, loc_cpu_entry, private->size)
-		cleanup_entry(iter);
+		cleanup_entry(iter, net);
 	if (private->number > private->initial_entries)
 		module_put(table_owner);
 	xt_free_table_info(private);
 	ret = nf_register_net_hooks(net, ops, hweight32(table->valid_hooks));
 	if (ret != 0) {
-		__arpt_unregister_table(new_table);
+		__arpt_unregister_table(net, new_table);
 		*res = NULL;
 	}
 			   const struct nf_hook_ops *ops)
 {
 	nf_unregister_net_hooks(net, ops, hweight32(table->valid_hooks));
-	__arpt_unregister_table(table);
+	__arpt_unregister_table(net, table);
 }
 /* The built-in targets: standard (NULL) and error. */

net/ipv4/tcp_bpf.c+7−10

 	struct sk_psock *psock;
 	int copied, ret;
-	if (unlikely(flags & MSG_ERRQUEUE))
-		return inet_recv_error(sk, msg, len, addr_len);
-	if (!skb_queue_empty(&sk->sk_receive_queue))
-		return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len);
 	psock = sk_psock_get(sk);
 	if (unlikely(!psock))
 		return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len);
+	if (unlikely(flags & MSG_ERRQUEUE))
+		return inet_recv_error(sk, msg, len, addr_len);
+	if (!skb_queue_empty(&sk->sk_receive_queue) &&
+	    sk_psock_queue_empty(psock))
+		return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len);
 	lock_sock(sk);
 msg_bytes_ready:
 	copied = __tcp_bpf_recvmsg(sk, psock, msg, len, flags);
 		timeo = sock_rcvtimeo(sk, nonblock);
 		data = tcp_bpf_wait_data(sk, psock, flags, timeo, &err);
 		if (data) {
-			if (skb_queue_empty(&sk->sk_receive_queue))
+			if (!sk_psock_queue_empty(psock))
 				goto msg_bytes_ready;
 			release_sock(sk);
 			sk_psock_put(sk, psock);
 		 */
 		delta = msg->sg.size;
 		psock->eval = sk_psock_msg_verdict(sk, psock, msg);
-		if (msg->sg.size < delta)
+		delta -= msg->sg.size;
-			delta -= msg->sg.size;
-		else
-			delta = 0;
 	}
 	if (msg->cork_bytes &&

net/ipv4/tcp_input.c+4−3

 /* This must be called before lost_out is incremented */
 static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
 {
-	if (!tp->retransmit_skb_hint ||
+	if ((!tp->retransmit_skb_hint && tp->retrans_out >= tp->lost_out) ||
-	    before(TCP_SKB_CB(skb)->seq,
+	    (tp->retransmit_skb_hint &&
-		   TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
+	     before(TCP_SKB_CB(skb)->seq,
+		    TCP_SKB_CB(tp->retransmit_skb_hint)->seq)))
 		tp->retransmit_skb_hint = skb;
 }

net/ipv4/tcp_ulp.c+4−2

 	rcu_read_unlock();
 }
-void tcp_update_ulp(struct sock *sk, struct proto *proto)
+void tcp_update_ulp(struct sock *sk, struct proto *proto,
+		    void (*write_space)(struct sock *sk))
 {
 	struct inet_connection_sock *icsk = inet_csk(sk);
 	if (!icsk->icsk_ulp_ops) {
+		sk->sk_write_space = write_space;
 		sk->sk_prot = proto;
 		return;
 	}
 	if (icsk->icsk_ulp_ops->update)
-		icsk->icsk_ulp_ops->update(sk, proto);
+		icsk->icsk_ulp_ops->update(sk, proto, write_space);
 }
 void tcp_cleanup_ulp(struct sock *sk)

net/mac80211/cfg.c+23−0

@@ -2954,6 +2954,28 @@ static int ieee80211_start_radar_detection(struct wiphy *wiphy, · 2953 unmodified lines
2954	return err;	2954	return err;
2955	}	2955	}
2956		2956
		2957	static void ieee80211_end_cac(struct wiphy *wiphy,
		2958	struct net_device *dev)
		2959	{
		2960	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
		2961	struct ieee80211_local *local = sdata->local;
		2962
		2963	mutex_lock(&local->mtx);
		2964	list_for_each_entry(sdata, &local->interfaces, list) {
		2965	/* it might be waiting for the local->mtx, but then
		2966	* by the time it gets it, sdata->wdev.cac_started
		2967	* will no longer be true
		2968	*/
		2969	cancel_delayed_work(&sdata->dfs_cac_timer_work);
		2970
		2971	if (sdata->wdev.cac_started) {
		2972	ieee80211_vif_release_channel(sdata);
		2973	sdata->wdev.cac_started = false;
		2974	}
		2975	}
		2976	mutex_unlock(&local->mtx);
		2977	}
		2978
2957	static struct cfg80211_beacon_data *	2979	static struct cfg80211_beacon_data *
2958	cfg80211_beacon_dup(struct cfg80211_beacon_data *beacon)	2980	cfg80211_beacon_dup(struct cfg80211_beacon_data *beacon)
2959	{	2981	{
@@ -4023,6 +4045,7 @@ const struct cfg80211_ops mac80211_config_ops = { · 1063 unmodified lines
4023	#endif	4045	#endif
4024	.get_channel = ieee80211_cfg_get_channel,	4046	.get_channel = ieee80211_cfg_get_channel,
4025	.start_radar_detection = ieee80211_start_radar_detection,	4047	.start_radar_detection = ieee80211_start_radar_detection,
		4048	.end_cac = ieee80211_end_cac,
4026	.channel_switch = ieee80211_channel_switch,	4049	.channel_switch = ieee80211_channel_switch,
4027	.set_qos_map = ieee80211_set_qos_map,	4050	.set_qos_map = ieee80211_set_qos_map,
4028	.set_ap_chanwidth = ieee80211_set_ap_chanwidth,	4051	.set_ap_chanwidth = ieee80211_set_ap_chanwidth,

net/mac80211/mesh_hwmp.c+3−0

@@ -328,6 +328,9 @@ u32 airtime_link_metric_get(struct ieee80211_local *local, · 327 unmodified lines
328	unsigned long fail_avg =	328	unsigned long fail_avg =
329	ewma_mesh_fail_avg_read(&sta->mesh->fail_avg);	329	ewma_mesh_fail_avg_read(&sta->mesh->fail_avg);
330		330
		331	if (sta->mesh->plink_state != NL80211_PLINK_ESTAB)
		332	return MAX_METRIC;
		333
331	/* Try to get rate based on HW/SW RC algorithm.	334	/* Try to get rate based on HW/SW RC algorithm.
332	* Rate is returned in units of Kbps, correct this	335	* Rate is returned in units of Kbps, correct this
333	* to comply with airtime calculation units	336	* to comply with airtime calculation units

net/mac80211/tkip.c+15−3

@@ -263,9 +263,21 @@ int ieee80211_tkip_decrypt_data(struct arc4_ctx *ctx, · 262 unmodified lines
263	if ((keyid >> 6) != key->conf.keyidx)	263	if ((keyid >> 6) != key->conf.keyidx)
264	return TKIP_DECRYPT_INVALID_KEYIDX;	264	return TKIP_DECRYPT_INVALID_KEYIDX;
265		265
266	if (rx_ctx->ctx.state != TKIP_STATE_NOT_INIT &&	266	/* Reject replays if the received TSC is smaller than or equal to the
267	(iv32 < rx_ctx->iv32 \|\|	267	* last received value in a valid message, but with an exception for
268	(iv32 == rx_ctx->iv32 && iv16 <= rx_ctx->iv16)))	268	* the case where a new key has been set and no valid frame using that
		269	* key has yet received and the local RSC was initialized to 0. This
		270	* exception allows the very first frame sent by the transmitter to be
		271	* accepted even if that transmitter were to use TSC 0 (IEEE 802.11
		272	* described TSC to be initialized to 1 whenever a new key is taken into
		273	* use).
		274	*/
		275	if (iv32 < rx_ctx->iv32 \|\|
		276	(iv32 == rx_ctx->iv32 &&
		277	(iv16 < rx_ctx->iv16 \|\|
		278	(iv16 == rx_ctx->iv16 &&
		279	(rx_ctx->iv32 \|\| rx_ctx->iv16 \|\|
		280	rx_ctx->ctx.state != TKIP_STATE_NOT_INIT)))))
269	return TKIP_DECRYPT_REPLAY;	281	return TKIP_DECRYPT_REPLAY;
270		282
271	if (only_iv) {	283	if (only_iv) {

net/netfilter/ipset/ip_set_bitmap_gen.h+1−1

 	if (SET_WITH_TIMEOUT(set))
 		del_timer_sync(&map->gc);
-	ip_set_free(map->members);
 	if (set->dsize && set->extensions & IPSET_EXT_DESTROY)
 		mtype_ext_cleanup(set);
+	ip_set_free(map->members);
 	ip_set_free(map);
 	set->data = NULL;

net/netfilter/nf_nat_proto.c+13−0

@@ -233,6 +233,19 @@ icmp_manip_pkt(struct sk_buff *skb, · 232 unmodified lines
233	return false;	233	return false;
234		234
235	hdr = (struct icmphdr *)(skb->data + hdroff);	235	hdr = (struct icmphdr *)(skb->data + hdroff);
		236	switch (hdr->type) {
		237	case ICMP_ECHO:
		238	case ICMP_ECHOREPLY:
		239	case ICMP_TIMESTAMP:
		240	case ICMP_TIMESTAMPREPLY:
		241	case ICMP_INFO_REQUEST:
		242	case ICMP_INFO_REPLY:
		243	case ICMP_ADDRESS:
		244	case ICMP_ADDRESSREPLY:
		245	break;
		246	default:
		247	return true;
		248	}
236	inet_proto_csum_replace2(&hdr->checksum, skb,	249	inet_proto_csum_replace2(&hdr->checksum, skb,
237	hdr->un.echo.id, tuple->src.u.icmp.id, false);	250	hdr->un.echo.id, tuple->src.u.icmp.id, false);
238	hdr->un.echo.id = tuple->src.u.icmp.id;	251	hdr->un.echo.id = tuple->src.u.icmp.id;

net/netfilter/nf_tables_api.c+26−13

 #include <net/net_namespace.h>
 #include <net/sock.h>
+#define NFT_MODULE_AUTOLOAD_LIMIT (MODULE_NAME_LEN - sizeof("nft-expr-255-"))
 static LIST_HEAD(nf_tables_expressions);
 static LIST_HEAD(nf_tables_objects);
 static LIST_HEAD(nf_tables_flowtables);
 }
 /*
- * Loading a module requires dropping mutex that guards the
+ * Loading a module requires dropping mutex that guards the transaction.
- * transaction.
+ * A different client might race to start a new transaction meanwhile. Zap the
- * We first need to abort any pending transactions as once
+ * list of pending transaction and then restore it once the mutex is grabbed
- * mutex is unlocked a different client could start a new
+ * again. Users of this function return EAGAIN which implicitly triggers the
- * transaction.  It must not see any 'future generation'
+ * transaction abort path to clean up the list of pending transactions.
- * changes * as these changes will never happen.
  */
 #ifdef CONFIG_MODULES
-static int __nf_tables_abort(struct net *net);
 static void nft_request_module(struct net *net, const char *fmt, ...)
 {
 	char module_name[MODULE_NAME_LEN];
+	LIST_HEAD(commit_list);
 	va_list args;
 	int ret;
-	__nf_tables_abort(net);
+	list_splice_init(&net->nft.commit_list, &commit_list);
 	va_start(args, fmt);
 	ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args);
 	va_end(args);
-	if (WARN(ret >= MODULE_NAME_LEN, "truncated: '%s' (len %d)", module_name, ret))
+	if (ret >= MODULE_NAME_LEN)
 		return;
 	mutex_unlock(&net->nft.commit_mutex);
 	request_module("%s", module_name);
 	mutex_lock(&net->nft.commit_mutex);
+	WARN_ON_ONCE(!list_empty(&net->nft.commit_list));
+	list_splice(&commit_list, &net->nft.commit_list);
 }
 #endif
 	}
 	list_for_each_entry_safe(flowtable, nft, &ctx->table->flowtables, list) {
+		if (!nft_is_active_next(ctx->net, flowtable))
+			continue;
 		err = nft_delflowtable(ctx, flowtable);
 		if (err < 0)
 			goto out;
 	}
 	list_for_each_entry_safe(obj, ne, &ctx->table->objects, list) {
+		if (!nft_is_active_next(ctx->net, obj))
+			continue;
 		err = nft_delobj(ctx, obj);
 		if (err < 0)
 			goto out;
 				    .len = NFT_CHAIN_MAXNAMELEN - 1 },
 	[NFTA_CHAIN_HOOK]	= { .type = NLA_NESTED },
 	[NFTA_CHAIN_POLICY]	= { .type = NLA_U32 },
-	[NFTA_CHAIN_TYPE]	= { .type = NLA_STRING },
+	[NFTA_CHAIN_TYPE]	= { .type = NLA_STRING,
+				    .len = NFT_MODULE_AUTOLOAD_LIMIT },
 	[NFTA_CHAIN_COUNTERS]	= { .type = NLA_NESTED },
 	[NFTA_CHAIN_FLAGS]	= { .type = NLA_U32 },
 };
 			goto err_hook;
 		}
 		if (nft_hook_list_find(hook_list, hook)) {
+			kfree(hook);
 			err = -EEXIST;
 			goto err_hook;
 		}
 }
 static const struct nla_policy nft_expr_policy[NFTA_EXPR_MAX + 1] = {
-	[NFTA_EXPR_NAME]	= { .type = NLA_STRING },
+	[NFTA_EXPR_NAME]	= { .type = NLA_STRING,
+				    .len = NFT_MODULE_AUTOLOAD_LIMIT },
 	[NFTA_EXPR_DATA]	= { .type = NLA_NESTED },
 };
 	[NFTA_SET_ELEM_USERDATA]	= { .type = NLA_BINARY,
 					    .len = NFT_USERDATA_MAXLEN },
 	[NFTA_SET_ELEM_EXPR]		= { .type = NLA_NESTED },
-	[NFTA_SET_ELEM_OBJREF]		= { .type = NLA_STRING },
+	[NFTA_SET_ELEM_OBJREF]		= { .type = NLA_STRING,
+					    .len = NFT_OBJ_MAXNAMELEN - 1 },
 };
 static const struct nla_policy nft_set_elem_list_policy[NFTA_SET_ELEM_LIST_MAX + 1] = {

net/netfilter/nft_tunnel.c+4−1

 	struct nft_tunnel *priv = nft_expr_priv(expr);
 	u32 len;
-	if (!tb[NFTA_TUNNEL_KEY] &&
+	if (!tb[NFTA_TUNNEL_KEY] ||
 	    !tb[NFTA_TUNNEL_DREG])
 		return -EINVAL;
 	if (err < 0)
 		return err;
+	if (!tb[NFTA_TUNNEL_KEY_ERSPAN_VERSION])
+		 return -EINVAL;
 	version = ntohl(nla_get_be32(tb[NFTA_TUNNEL_KEY_ERSPAN_VERSION]));
 	switch (version) {
 	case ERSPAN_VERSION:

net/sched/act_ctinfo.c+11−0

 	return tcf_idr_search(tn, a, index);
 }
+static void tcf_ctinfo_cleanup(struct tc_action *a)
+{
+	struct tcf_ctinfo *ci = to_ctinfo(a);
+	struct tcf_ctinfo_params *cp;
+	cp = rcu_dereference_protected(ci->params, 1);
+	if (cp)
+		kfree_rcu(cp, rcu);
+}
 static struct tc_action_ops act_ctinfo_ops = {
 	.kind	= "ctinfo",
 	.id	= TCA_ID_CTINFO,
 	.act	= tcf_ctinfo_act,
 	.dump	= tcf_ctinfo_dump,
 	.init	= tcf_ctinfo_init,
+	.cleanup= tcf_ctinfo_cleanup,
 	.walk	= tcf_ctinfo_walker,
 	.lookup	= tcf_ctinfo_search,
 	.size	= sizeof(struct tcf_ctinfo),

net/sched/act_ife.c+3−4

 	}
 	ife = to_ife(*a);
+	if (ret == ACT_P_CREATED)
+		INIT_LIST_HEAD(&ife->metalist);
 	err = tcf_action_check_ctrlact(parm->action, tp, &goto_ch, extack);
 	if (err < 0)
 		goto release_idr;
 		p->eth_type = ife_type;
 	}
-	if (ret == ACT_P_CREATED)
-		INIT_LIST_HEAD(&ife->metalist);
 	if (tb[TCA_IFE_METALST]) {
 		err = nla_parse_nested_deprecated(tb2, IFE_META_MAX,
 						  tb[TCA_IFE_METALST], NULL,

net/sunrpc/xprtrdma/verbs.c+22−7

@@ -77,7 +77,7 @@ · 76 unmodified lines
77	static void rpcrdma_sendctx_put_locked(struct rpcrdma_xprt *r_xprt,	77	static void rpcrdma_sendctx_put_locked(struct rpcrdma_xprt *r_xprt,
78	struct rpcrdma_sendctx *sc);	78	struct rpcrdma_sendctx *sc);
79	static void rpcrdma_reqs_reset(struct rpcrdma_xprt *r_xprt);	79	static void rpcrdma_reqs_reset(struct rpcrdma_xprt *r_xprt);
80	static void rpcrdma_reps_destroy(struct rpcrdma_buffer *buf);	80	static void rpcrdma_reps_unmap(struct rpcrdma_xprt *r_xprt);
81	static void rpcrdma_mrs_create(struct rpcrdma_xprt *r_xprt);	81	static void rpcrdma_mrs_create(struct rpcrdma_xprt *r_xprt);
82	static void rpcrdma_mrs_destroy(struct rpcrdma_xprt *r_xprt);	82	static void rpcrdma_mrs_destroy(struct rpcrdma_xprt *r_xprt);
83	static struct rpcrdma_regbuf *	83	static struct rpcrdma_regbuf *
@@ -244,6 +244,7 @@ rpcrdma_cm_event_handler(struct rdma_cm_id id, struct rdma_cm_event event) · 160 unmodified lines
244	ia->ri_id->device->name,	244	ia->ri_id->device->name,
245	rpcrdma_addrstr(r_xprt), rpcrdma_portstr(r_xprt));	245	rpcrdma_addrstr(r_xprt), rpcrdma_portstr(r_xprt));
246	#endif	246	#endif
		247	init_completion(&ia->ri_remove_done);
247	set_bit(RPCRDMA_IAF_REMOVING, &ia->ri_flags);	248	set_bit(RPCRDMA_IAF_REMOVING, &ia->ri_flags);
248	ep->rep_connected = -ENODEV;	249	ep->rep_connected = -ENODEV;
249	xprt_force_disconnect(xprt);	250	xprt_force_disconnect(xprt);
@@ -297,7 +298,6 @@ rpcrdma_create_id(struct rpcrdma_xprt xprt, struct rpcrdma_ia ia) · 47 unmodified lines
297	int rc;	298	int rc;
298		299
299	init_completion(&ia->ri_done);	300	init_completion(&ia->ri_done);
300	init_completion(&ia->ri_remove_done);
301		301
302	id = rdma_create_id(xprt->rx_xprt.xprt_net, rpcrdma_cm_event_handler,	302	id = rdma_create_id(xprt->rx_xprt.xprt_net, rpcrdma_cm_event_handler,
303	xprt, RDMA_PS_TCP, IB_QPT_RC);	303	xprt, RDMA_PS_TCP, IB_QPT_RC);
@@ -421,7 +421,7 @@ rpcrdma_ia_remove(struct rpcrdma_ia *ia) · 117 unmodified lines
421	/* The ULP is responsible for ensuring all DMA	421	/* The ULP is responsible for ensuring all DMA
422	* mappings and MRs are gone.	422	* mappings and MRs are gone.
423	*/	423	*/
424	rpcrdma_reps_destroy(buf);	424	rpcrdma_reps_unmap(r_xprt);
425	list_for_each_entry(req, &buf->rb_allreqs, rl_all) {	425	list_for_each_entry(req, &buf->rb_allreqs, rl_all) {
426	rpcrdma_regbuf_dma_unmap(req->rl_rdmabuf);	426	rpcrdma_regbuf_dma_unmap(req->rl_rdmabuf);
427	rpcrdma_regbuf_dma_unmap(req->rl_sendbuf);	427	rpcrdma_regbuf_dma_unmap(req->rl_sendbuf);
@@ -599,6 +599,7 @@ static int rpcrdma_ep_recreate_xprt(struct rpcrdma_xprt *r_xprt, · 171 unmodified lines
599	struct ib_qp_init_attr *qp_init_attr)	599	struct ib_qp_init_attr *qp_init_attr)
600	{	600	{
601	struct rpcrdma_ia *ia = &r_xprt->rx_ia;	601	struct rpcrdma_ia *ia = &r_xprt->rx_ia;
		602	struct rpcrdma_ep *ep = &r_xprt->rx_ep;
602	int rc, err;	603	int rc, err;
603		604
604	trace_xprtrdma_reinsert(r_xprt);	605	trace_xprtrdma_reinsert(r_xprt);
@@ -613,6 +614,7 @@ static int rpcrdma_ep_recreate_xprt(struct rpcrdma_xprt *r_xprt, · 8 unmodified lines
613	pr_err("rpcrdma: rpcrdma_ep_create returned %d\n", err);	614	pr_err("rpcrdma: rpcrdma_ep_create returned %d\n", err);
614	goto out2;	615	goto out2;
615	}	616	}
		617	memcpy(qp_init_attr, &ep->rep_attr, sizeof(*qp_init_attr));
616		618
617	rc = -ENETUNREACH;	619	rc = -ENETUNREACH;
618	err = rdma_create_qp(ia->ri_id, ia->ri_pd, qp_init_attr);	620	err = rdma_create_qp(ia->ri_id, ia->ri_pd, qp_init_attr);
@@ -1090,6 +1092,7 @@ static struct rpcrdma_rep rpcrdma_rep_create(struct rpcrdma_xprt r_xprt, · 471 unmodified lines
1090	rep->rr_recv_wr.sg_list = &rep->rr_rdmabuf->rg_iov;	1092	rep->rr_recv_wr.sg_list = &rep->rr_rdmabuf->rg_iov;
1091	rep->rr_recv_wr.num_sge = 1;	1093	rep->rr_recv_wr.num_sge = 1;
1092	rep->rr_temp = temp;	1094	rep->rr_temp = temp;
		1095	list_add(&rep->rr_all, &r_xprt->rx_buf.rb_all_reps);
1093	return rep;	1096	return rep;
1094		1097
1095	out_free:	1098	out_free:
@@ -1100,6 +1103,7 @@ out: · 4 unmodified lines
1100		1103
1101	static void rpcrdma_rep_destroy(struct rpcrdma_rep *rep)	1104	static void rpcrdma_rep_destroy(struct rpcrdma_rep *rep)
1102	{	1105	{
		1106	list_del(&rep->rr_all);
1103	rpcrdma_regbuf_free(rep->rr_rdmabuf);	1107	rpcrdma_regbuf_free(rep->rr_rdmabuf);
1104	kfree(rep);	1108	kfree(rep);
1105	}	1109	}
@@ -1118,10 +1122,16 @@ static struct rpcrdma_rep rpcrdma_rep_get_locked(struct rpcrdma_buffer buf) · 12 unmodified lines
1118	static void rpcrdma_rep_put(struct rpcrdma_buffer *buf,	1122	static void rpcrdma_rep_put(struct rpcrdma_buffer *buf,
1119	struct rpcrdma_rep *rep)	1123	struct rpcrdma_rep *rep)
1120	{	1124	{
1121	if (!rep->rr_temp)	1125	llist_add(&rep->rr_node, &buf->rb_free_reps);
1122	llist_add(&rep->rr_node, &buf->rb_free_reps);	1126	}
1123	else	1127
1124	rpcrdma_rep_destroy(rep);	1128	static void rpcrdma_reps_unmap(struct rpcrdma_xprt *r_xprt)
		1129	{
		1130	struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
		1131	struct rpcrdma_rep *rep;
		1132
		1133	list_for_each_entry(rep, &buf->rb_all_reps, rr_all)
		1134	rpcrdma_regbuf_dma_unmap(rep->rr_rdmabuf);
1125	}	1135	}
1126		1136
1127	static void rpcrdma_reps_destroy(struct rpcrdma_buffer *buf)	1137	static void rpcrdma_reps_destroy(struct rpcrdma_buffer *buf)
@@ -1152,6 +1162,7 @@ int rpcrdma_buffer_create(struct rpcrdma_xprt *r_xprt) · 24 unmodified lines
1152		1162
1153	INIT_LIST_HEAD(&buf->rb_send_bufs);	1163	INIT_LIST_HEAD(&buf->rb_send_bufs);
1154	INIT_LIST_HEAD(&buf->rb_allreqs);	1164	INIT_LIST_HEAD(&buf->rb_allreqs);
		1165	INIT_LIST_HEAD(&buf->rb_all_reps);
1155		1166
1156	rc = -ENOMEM;	1167	rc = -ENOMEM;
1157	for (i = 0; i < buf->rb_max_requests; i++) {	1168	for (i = 0; i < buf->rb_max_requests; i++) {
@@ -1504,6 +1515,10 @@ void rpcrdma_post_recvs(struct rpcrdma_xprt *r_xprt, bool temp) · 346 unmodified lines
1504	wr = NULL;	1515	wr = NULL;
1505	while (needed) {	1516	while (needed) {
1506	rep = rpcrdma_rep_get_locked(buf);	1517	rep = rpcrdma_rep_get_locked(buf);
		1518	if (rep && rep->rr_temp) {
		1519	rpcrdma_rep_destroy(rep);
		1520	continue;
		1521	}
1507	if (!rep)	1522	if (!rep)
1508	rep = rpcrdma_rep_create(r_xprt, temp);	1523	rep = rpcrdma_rep_create(r_xprt, temp);
1509	if (!rep)	1524	if (!rep)

net/sunrpc/xprtrdma/xprt_rdma.h+2−0

 	struct xdr_stream	rr_stream;
 	struct llist_node	rr_node;
 	struct ib_recv_wr	rr_recv_wr;
+	struct list_head	rr_all;
 };
 /* To reduce the rate at which a transport invokes ib_post_recv
 	struct list_head	rb_allreqs;
 	struct list_head	rb_all_mrs;
+	struct list_head	rb_all_reps;
 	struct llist_head	rb_free_reps;

net/tls/tls_main.c+7−3

 	return rc;
 }
-static void tls_update(struct sock *sk, struct proto *p)
+static void tls_update(struct sock *sk, struct proto *p,
+		       void (*write_space)(struct sock *sk))
 {
 	struct tls_context *ctx;
 	ctx = tls_get_ctx(sk);
-	if (likely(ctx))
+	if (likely(ctx)) {
+		ctx->sk_write_space = write_space;
 		ctx->sk_proto = p;
-	else
+	} else {
 		sk->sk_prot = p;
+		sk->sk_write_space = write_space;
+	}
 }
 static int tls_get_info(const struct sock *sk, struct sk_buff *skb)

net/tls/tls_sw.c+32−9

@@ -256,8 +256,6 @@ static int tls_do_decryption(struct sock *sk, · 255 unmodified lines
256	return ret;	256	return ret;
257		257
258	ret = crypto_wait_req(ret, &ctx->async_wait);	258	ret = crypto_wait_req(ret, &ctx->async_wait);
259	} else if (ret == -EBADMSG) {
260	TLS_INC_STATS(sock_net(sk), LINUX_MIB_TLSDECRYPTERROR);
261	}	259	}
262		260
263	if (async)	261	if (async)
@@ -682,12 +680,32 @@ static int tls_push_record(struct sock *sk, int flags, · 418 unmodified lines
682		680
683	split_point = msg_pl->apply_bytes;	681	split_point = msg_pl->apply_bytes;
684	split = split_point && split_point < msg_pl->sg.size;	682	split = split_point && split_point < msg_pl->sg.size;
		683	if (unlikely((!split &&
		684	msg_pl->sg.size +
		685	prot->overhead_size > msg_en->sg.size) \|\|
		686	(split &&
		687	split_point +
		688	prot->overhead_size > msg_en->sg.size))) {
		689	split = true;
		690	split_point = msg_en->sg.size;
		691	}
685	if (split) {	692	if (split) {
686	rc = tls_split_open_record(sk, rec, &tmp, msg_pl, msg_en,	693	rc = tls_split_open_record(sk, rec, &tmp, msg_pl, msg_en,
687	split_point, prot->overhead_size,	694	split_point, prot->overhead_size,
688	&orig_end);	695	&orig_end);
689	if (rc < 0)	696	if (rc < 0)
690	return rc;	697	return rc;
		698	/* This can happen if above tls_split_open_record allocates
		699	* a single large encryption buffer instead of two smaller
		700	* ones. In this case adjust pointers and continue without
		701	* split.
		702	*/
		703	if (!msg_pl->sg.size) {
		704	tls_merge_open_record(sk, rec, tmp, orig_end);
		705	msg_pl = &rec->msg_plaintext;
		706	msg_en = &rec->msg_encrypted;
		707	split = false;
		708	}
691	sk_msg_trim(sk, msg_en, msg_pl->sg.size +	709	sk_msg_trim(sk, msg_en, msg_pl->sg.size +
692	prot->overhead_size);	710	prot->overhead_size);
693	}	711	}
@@ -709,6 +727,12 @@ static int tls_push_record(struct sock *sk, int flags, · 15 unmodified lines
709	sg_mark_end(sk_msg_elem(msg_pl, i));	727	sg_mark_end(sk_msg_elem(msg_pl, i));
710	}	728	}
711		729
		730	if (msg_pl->sg.end < msg_pl->sg.start) {
		731	sg_chain(&msg_pl->sg.data[msg_pl->sg.start],
		732	MAX_SKB_FRAGS - msg_pl->sg.start + 1,
		733	msg_pl->sg.data);
		734	}
		735
712	i = msg_pl->sg.start;	736	i = msg_pl->sg.start;
713	sg_chain(rec->sg_aead_in, 2, &msg_pl->sg.data[i]);	737	sg_chain(rec->sg_aead_in, 2, &msg_pl->sg.data[i]);
714		738
@@ -772,7 +796,7 @@ static int bpf_exec_tx_verdict(struct sk_msg msg, struct sock sk, · 57 unmodified lines
772	psock = sk_psock_get(sk);	796	psock = sk_psock_get(sk);
773	if (!psock \|\| !policy) {	797	if (!psock \|\| !policy) {
774	err = tls_push_record(sk, flags, record_type);	798	err = tls_push_record(sk, flags, record_type);
775	if (err) {	799	if (err && err != -EINPROGRESS) {
776	*copied -= sk_msg_free(sk, msg);	800	*copied -= sk_msg_free(sk, msg);
777	tls_free_open_rec(sk);	801	tls_free_open_rec(sk);
778	}	802	}
@@ -783,10 +807,7 @@ more_data: · 4 unmodified lines
783	if (psock->eval == __SK_NONE) {	807	if (psock->eval == __SK_NONE) {
784	delta = msg->sg.size;	808	delta = msg->sg.size;
785	psock->eval = sk_psock_msg_verdict(sk, psock, msg);	809	psock->eval = sk_psock_msg_verdict(sk, psock, msg);
786	if (delta < msg->sg.size)	810	delta -= msg->sg.size;
787	delta -= msg->sg.size;
788	else
789	delta = 0;
790	}	811	}
791	if (msg->cork_bytes && msg->cork_bytes > msg->sg.size &&	812	if (msg->cork_bytes && msg->cork_bytes > msg->sg.size &&
792	!enospc && !full_record) {	813	!enospc && !full_record) {
@@ -801,7 +822,7 @@ more_data: · 8 unmodified lines
801	switch (psock->eval) {	822	switch (psock->eval) {
802	case __SK_PASS:	823	case __SK_PASS:
803	err = tls_push_record(sk, flags, record_type);	824	err = tls_push_record(sk, flags, record_type);
804	if (err < 0) {	825	if (err && err != -EINPROGRESS) {
805	*copied -= sk_msg_free(sk, msg);	826	*copied -= sk_msg_free(sk, msg);
806	tls_free_open_rec(sk);	827	tls_free_open_rec(sk);
807	goto out_err;	828	goto out_err;
@@ -1515,7 +1536,9 @@ static int decrypt_skb_update(struct sock sk, struct sk_buff skb, · 707 unmodified lines
1515	if (err == -EINPROGRESS)	1536	if (err == -EINPROGRESS)
1516	tls_advance_record_sn(sk, prot,	1537	tls_advance_record_sn(sk, prot,
1517	&tls_ctx->rx);	1538	&tls_ctx->rx);
1518		1539	else if (err == -EBADMSG)
		1540	TLS_INC_STATS(sock_net(sk),
		1541	LINUX_MIB_TLSDECRYPTERROR);
1519	return err;	1542	return err;
1520	}	1543	}
1521	} else {	1544	} else {

net/vmw_vsock/hyperv_transport.c+6−59

@@ -138,28 +138,15 @@ struct hvsock { · 137 unmodified lines
138	****************************************************************************	138	****************************************************************************
139	* The only valid Service GUIDs, from the perspectives of both the host and *	139	* The only valid Service GUIDs, from the perspectives of both the host and *
140	* Linux VM, that can be connected by the other end, must conform to this *	140	* Linux VM, that can be connected by the other end, must conform to this *
141	* format: <port>-facb-11e6-bd58-64006a7986d3, and the "port" must be in *	141	* format: <port>-facb-11e6-bd58-64006a7986d3. *
142	* this range [0, 0x7FFFFFFF]. *
143	****************************************************************************	142	****************************************************************************
144	*	143	*
145	* When we write apps on the host to connect(), the GUID ServiceID is used.	144	* When we write apps on the host to connect(), the GUID ServiceID is used.
146	* When we write apps in Linux VM to connect(), we only need to specify the	145	* When we write apps in Linux VM to connect(), we only need to specify the
147	* port and the driver will form the GUID and use that to request the host.	146	* port and the driver will form the GUID and use that to request the host.
148	*	147	*
149	* From the perspective of Linux VM:
150	* 1. the local ephemeral port (i.e. the local auto-bound port when we call
151	* connect() without explicit bind()) is generated by __vsock_bind_stream(),
152	* and the range is [1024, 0xFFFFFFFF).
153	* 2. the remote ephemeral port (i.e. the auto-generated remote port for
154	* a connect request initiated by the host's connect()) is generated by
155	* hvs_remote_addr_init() and the range is [0x80000000, 0xFFFFFFFF).
156	*/	148	*/
157		149
158	#define MAX_LISTEN_PORT ((u32)0x7FFFFFFF)
159	#define MAX_VM_LISTEN_PORT MAX_LISTEN_PORT
160	#define MAX_HOST_LISTEN_PORT MAX_LISTEN_PORT
161	#define MIN_HOST_EPHEMERAL_PORT (MAX_HOST_LISTEN_PORT + 1)
162
163	/* 00000000-facb-11e6-bd58-64006a7986d3 */	150	/* 00000000-facb-11e6-bd58-64006a7986d3 */
164	static const guid_t srv_id_template =	151	static const guid_t srv_id_template =
165	GUID_INIT(0x00000000, 0xfacb, 0x11e6, 0xbd, 0x58,	152	GUID_INIT(0x00000000, 0xfacb, 0x11e6, 0xbd, 0x58,
@@ -184,34 +171,6 @@ static void hvs_addr_init(struct sockaddr_vm addr, const guid_t svr_id) · 18 unmodified lines
184	vsock_addr_init(addr, VMADDR_CID_ANY, port);	171	vsock_addr_init(addr, VMADDR_CID_ANY, port);
185	}	172	}
186		173
187	static void hvs_remote_addr_init(struct sockaddr_vm *remote,
188	struct sockaddr_vm *local)
189	{
190	static u32 host_ephemeral_port = MIN_HOST_EPHEMERAL_PORT;
191	struct sock *sk;
192
193	/* Remote peer is always the host */
194	vsock_addr_init(remote, VMADDR_CID_HOST, VMADDR_PORT_ANY);
195
196	while (1) {
197	/* Wrap around ? */
198	if (host_ephemeral_port < MIN_HOST_EPHEMERAL_PORT \|\|
199	host_ephemeral_port == VMADDR_PORT_ANY)
200	host_ephemeral_port = MIN_HOST_EPHEMERAL_PORT;
201
202	remote->svm_port = host_ephemeral_port++;
203
204	sk = vsock_find_connected_socket(remote, local);
205	if (!sk) {
206	/* Found an available ephemeral port */
207	return;
208	}
209
210	/* Release refcnt got in vsock_find_connected_socket */
211	sock_put(sk);
212	}
213	}
214
215	static void hvs_set_channel_pending_send_size(struct vmbus_channel *chan)	174	static void hvs_set_channel_pending_send_size(struct vmbus_channel *chan)
216	{	175	{
217	set_channel_pending_send_size(chan,	176	set_channel_pending_send_size(chan,
@@ -341,12 +300,7 @@ static void hvs_open_connection(struct vmbus_channel *chan) · 123 unmodified lines
341	if_type = &chan->offermsg.offer.if_type;	300	if_type = &chan->offermsg.offer.if_type;
342	if_instance = &chan->offermsg.offer.if_instance;	301	if_instance = &chan->offermsg.offer.if_instance;
343	conn_from_host = chan->offermsg.offer.u.pipe.user_def[0];	302	conn_from_host = chan->offermsg.offer.u.pipe.user_def[0];
344		303	if (!is_valid_srv_id(if_type))
345	/* The host or the VM should only listen on a port in
346	* [0, MAX_LISTEN_PORT]
347	*/
348	if (!is_valid_srv_id(if_type) \|\|
349	get_port_by_srv_id(if_type) > MAX_LISTEN_PORT)
350	return;	304	return;
351		305
352	hvs_addr_init(&addr, conn_from_host ? if_type : if_instance);	306	hvs_addr_init(&addr, conn_from_host ? if_type : if_instance);
@@ -371,8 +325,11 @@ static void hvs_open_connection(struct vmbus_channel *chan) · 18 unmodified lines
371	vnew = vsock_sk(new);	325	vnew = vsock_sk(new);
372		326
373	hvs_addr_init(&vnew->local_addr, if_type);	327	hvs_addr_init(&vnew->local_addr, if_type);
374	hvs_remote_addr_init(&vnew->remote_addr, &vnew->local_addr);
375		328
		329	/* Remote peer is always the host */
		330	vsock_addr_init(&vnew->remote_addr,
		331	VMADDR_CID_HOST, VMADDR_PORT_ANY);
		332	vnew->remote_addr.svm_port = get_port_by_srv_id(if_instance);
376	ret = vsock_assign_transport(vnew, vsock_sk(sk));	333	ret = vsock_assign_transport(vnew, vsock_sk(sk));
377	/* Transport assigned (looking at remote_addr) must be the	334	/* Transport assigned (looking at remote_addr) must be the
378	* same where we received the request.	335	* same where we received the request.
@@ -766,16 +723,6 @@ static bool hvs_stream_is_active(struct vsock_sock *vsk) · 387 unmodified lines
766		723
767	static bool hvs_stream_allow(u32 cid, u32 port)	724	static bool hvs_stream_allow(u32 cid, u32 port)
768	{	725	{
769	/* The host's port range [MIN_HOST_EPHEMERAL_PORT, 0xFFFFFFFF) is
770	* reserved as ephemeral ports, which are used as the host's ports
771	* when the host initiates connections.
772	*
773	* Perform this check in the guest so an immediate error is produced
774	* instead of a timeout.
775	*/
776	if (port > MAX_HOST_LISTEN_PORT)
777	return false;
778
779	if (cid == VMADDR_CID_HOST)	726	if (cid == VMADDR_CID_HOST)
780	return true;	727	return true;
781		728

net/wireless/nl80211.c+3−0

 		if (err)
 			return err;
+		cfg80211_sinfo_release_content(&sinfo);
 		if (sinfo.filled & BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
 			wdev->cqm_config->last_rssi_event_value =
 				(s8) sinfo.rx_beacon_signal_avg;
 	if (err)
 		return err;
+	cfg80211_sinfo_release_content(&sinfo);
 	return rdev_probe_mesh_link(rdev, dev, dest, buf, len);
 }

net/wireless/rdev-ops.h+14−0

@@ -538,6 +538,10 @@ static inline int · 537 unmodified lines
538	rdev_set_wiphy_params(struct cfg80211_registered_device *rdev, u32 changed)	538	rdev_set_wiphy_params(struct cfg80211_registered_device *rdev, u32 changed)
539	{	539	{
540	int ret;	540	int ret;
		541
		542	if (!rdev->ops->set_wiphy_params)
		543	return -EOPNOTSUPP;
		544
541	trace_rdev_set_wiphy_params(&rdev->wiphy, changed);	545	trace_rdev_set_wiphy_params(&rdev->wiphy, changed);
542	ret = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);	546	ret = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
543	trace_rdev_return_int(&rdev->wiphy, ret);	547	trace_rdev_return_int(&rdev->wiphy, ret);
@@ -1167,6 +1171,16 @@ rdev_start_radar_detection(struct cfg80211_registered_device *rdev, · 623 unmodified lines
1167	return ret;	1171	return ret;
1168	}	1172	}
1169		1173
		1174	static inline void
		1175	rdev_end_cac(struct cfg80211_registered_device *rdev,
		1176	struct net_device *dev)
		1177	{
		1178	trace_rdev_end_cac(&rdev->wiphy, dev);
		1179	if (rdev->ops->end_cac)
		1180	rdev->ops->end_cac(&rdev->wiphy, dev);
		1181	trace_rdev_return_void(&rdev->wiphy);
		1182	}
		1183
1170	static inline int	1184	static inline int
1171	rdev_set_mcast_rate(struct cfg80211_registered_device *rdev,	1185	rdev_set_mcast_rate(struct cfg80211_registered_device *rdev,
1172	struct net_device *dev,	1186	struct net_device *dev,

net/wireless/reg.c+32−4

 static void handle_channel_custom(struct wiphy *wiphy,
 				  struct ieee80211_channel *chan,
-				  const struct ieee80211_regdomain *regd)
+				  const struct ieee80211_regdomain *regd,
+				  u32 min_bw)
 {
 	u32 bw_flags = 0;
 	const struct ieee80211_reg_rule *reg_rule = NULL;
 	const struct ieee80211_power_rule *power_rule = NULL;
 	u32 bw;
-	for (bw = MHZ_TO_KHZ(20); bw >= MHZ_TO_KHZ(5); bw = bw / 2) {
+	for (bw = MHZ_TO_KHZ(20); bw >= min_bw; bw = bw / 2) {
 		reg_rule = freq_reg_info_regd(MHZ_TO_KHZ(chan->center_freq),
 					      regd, bw);
 		if (!IS_ERR(reg_rule))
 	if (!sband)
 		return;
+	/*
+	 * We currently assume that you always want at least 20 MHz,
+	 * otherwise channel 12 might get enabled if this rule is
+	 * compatible to US, which permits 2402 - 2472 MHz.
+	 */
 	for (i = 0; i < sband->n_channels; i++)
-		handle_channel_custom(wiphy, &sband->channels[i], regd);
+		handle_channel_custom(wiphy, &sband->channels[i], regd,
+				      MHZ_TO_KHZ(20));
 }
 /* Used by drivers prior to wiphy registration */
 }
 EXPORT_SYMBOL(regulatory_pre_cac_allowed);
+static void cfg80211_check_and_end_cac(struct cfg80211_registered_device *rdev)
+{
+	struct wireless_dev *wdev;
+	/* If we finished CAC or received radar, we should end any
+	 * CAC running on the same channels.
+	 * the check !cfg80211_chandef_dfs_usable contain 2 options:
+	 * either all channels are available - those the CAC_FINISHED
+	 * event has effected another wdev state, or there is a channel
+	 * in unavailable state in wdev chandef - those the RADAR_DETECTED
+	 * event has effected another wdev state.
+	 * In both cases we should end the CAC on the wdev.
+	 */
+	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
+		if (wdev->cac_started &&
+		    !cfg80211_chandef_dfs_usable(&rdev->wiphy, &wdev->chandef))
+			rdev_end_cac(rdev, wdev->netdev);
+	}
+}
 void regulatory_propagate_dfs_state(struct wiphy *wiphy,
 				    struct cfg80211_chan_def *chandef,
 				    enum nl80211_dfs_state dfs_state,
 		cfg80211_set_dfs_state(&rdev->wiphy, chandef, dfs_state);
 		if (event == NL80211_RADAR_DETECTED ||
-		    event == NL80211_RADAR_CAC_FINISHED)
+		    event == NL80211_RADAR_CAC_FINISHED) {
 			cfg80211_sched_dfs_chan_update(rdev);
+			cfg80211_check_and_end_cac(rdev);
+		}
 		nl80211_radar_notify(rdev, chandef, event, NULL, GFP_KERNEL);
 	}

net/wireless/sme.c+3−3

@@ -1307,14 +1307,14 @@ void cfg80211_autodisconnect_wk(struct work_struct *work) · 1306 unmodified lines
1307	if (wdev->conn_owner_nlportid) {	1307	if (wdev->conn_owner_nlportid) {
1308	switch (wdev->iftype) {	1308	switch (wdev->iftype) {
1309	case NL80211_IFTYPE_ADHOC:	1309	case NL80211_IFTYPE_ADHOC:
1310	cfg80211_leave_ibss(rdev, wdev->netdev, false);	1310	__cfg80211_leave_ibss(rdev, wdev->netdev, false);
1311	break;	1311	break;
1312	case NL80211_IFTYPE_AP:	1312	case NL80211_IFTYPE_AP:
1313	case NL80211_IFTYPE_P2P_GO:	1313	case NL80211_IFTYPE_P2P_GO:
1314	cfg80211_stop_ap(rdev, wdev->netdev, false);	1314	__cfg80211_stop_ap(rdev, wdev->netdev, false);
1315	break;	1315	break;
1316	case NL80211_IFTYPE_MESH_POINT:	1316	case NL80211_IFTYPE_MESH_POINT:
1317	cfg80211_leave_mesh(rdev, wdev->netdev);	1317	__cfg80211_leave_mesh(rdev, wdev->netdev);
1318	break;	1318	break;
1319	case NL80211_IFTYPE_STATION:	1319	case NL80211_IFTYPE_STATION:
1320	case NL80211_IFTYPE_P2P_CLIENT:	1320	case NL80211_IFTYPE_P2P_CLIENT:

net/wireless/trace.h+5−0

 	TP_ARGS(wiphy, netdev)
 );
+DEFINE_EVENT(wiphy_netdev_evt, rdev_end_cac,
+	     TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
+	     TP_ARGS(wiphy, netdev)
+);
 DECLARE_EVENT_CLASS(station_add_change,
 	TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
 		 struct station_parameters *params),

net/wireless/util.c+1−1

@@ -564,7 +564,7 @@ __frame_add_frag(struct sk_buff skb, struct page page, · 563 unmodified lines
564	struct skb_shared_info *sh = skb_shinfo(skb);	564	struct skb_shared_info *sh = skb_shinfo(skb);
565	int page_offset;	565	int page_offset;
566		566
567	page_ref_inc(page);	567	get_page(page);
568	page_offset = ptr - page_address(page);	568	page_offset = ptr - page_address(page);
569	skb_add_rx_frag(skb, sh->nr_frags, page, page_offset, len, size);	569	skb_add_rx_frag(skb, sh->nr_frags, page, page_offset, len, size);
570	}	570	}

net/wireless/wext-core.c+2−1

@@ -657,7 +657,8 @@ struct iw_statistics get_wireless_stats(struct net_device dev) · 656 unmodified lines
657	return NULL;	657	return NULL;
658	}	658	}
659		659
660	static int iw_handler_get_iwstats(struct net_device * dev,	660	/* noinline to avoid a bogus warning with -O3 */
		661	static noinline int iw_handler_get_iwstats(struct net_device * dev,
661	struct iw_request_info * info,	662	struct iw_request_info * info,
662	union iwreq_data * wrqu,	663	union iwreq_data * wrqu,
663	char * extra)	664	char * extra)

net/x25/af_x25.c+5−1

 	if (sk->sk_state == TCP_ESTABLISHED)
 		goto out;
+	rc = -EALREADY;	/* Do nothing if call is already in progress */
+	if (sk->sk_state == TCP_SYN_SENT)
+		goto out;
 	sk->sk_state   = TCP_CLOSE;
 	sock->state = SS_UNCONNECTED;
 	/* Now the loop */
 	rc = -EINPROGRESS;
 	if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
-		goto out_put_neigh;
+		goto out;
 	rc = x25_wait_for_connection_establishment(sk);
 	if (rc)

sound/core/seq/seq_timer.c+9−5

 		q = queueptr(idx);
 		if (q == NULL)
 			continue;
-		if ((tmr = q->timer) == NULL ||
+		mutex_lock(&q->timer_mutex);
-		    (ti = tmr->timeri) == NULL) {
+		tmr = q->timer;
-			queuefree(q);
+		if (!tmr)
-			continue;
+			goto unlock;
-		}
+		ti = tmr->timeri;
+		if (!ti)
+			goto unlock;
 		snd_iprintf(buffer, "Timer for queue %i : %s\n", q->queue, ti->timer->name);
 		resolution = snd_timer_resolution(ti) * tmr->ticks;
 		snd_iprintf(buffer, "  Period time : %lu.%09lu\n", resolution / 1000000000, resolution % 1000000000);
 		snd_iprintf(buffer, "  Skew : %u / %u\n", tmr->skew, tmr->skew_base);
+unlock:
+		mutex_unlock(&q->timer_mutex);
 		queuefree(q);
  	}
 }

sound/firewire/dice/dice-extension.c+4−1

 		int j;
 		for (j = i + 1; j < 9; ++j) {
-			if (pointers[i * 2] == pointers[j * 2])
+			if (pointers[i * 2] == pointers[j * 2]) {
+				// Fallback to limited functionality.
+				err = -ENXIO;
 				goto end;
+			}
 		}
 	}

sound/firewire/tascam/amdtp-tascam.c+3−2

 			if ((before ^ after) & mask) {
 				struct snd_firewire_tascam_change *entry =
 						&tscm->queue[tscm->push_pos];
+				unsigned long flag;
-				spin_lock_irq(&tscm->lock);
+				spin_lock_irqsave(&tscm->lock, flag);
 				entry->index = index;
 				entry->before = before;
 				entry->after = after;
 				if (++tscm->push_pos >= SND_TSCM_QUEUE_COUNT)
 					tscm->push_pos = 0;
-				spin_unlock_irq(&tscm->lock);
+				spin_unlock_irqrestore(&tscm->lock, flag);
 				wake_up(&tscm->hwdep_wait);
 			}

sound/pci/hda/hda_intel.c+8−5

 static bool beep_mode[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] =
 					CONFIG_SND_HDA_INPUT_BEEP_MODE};
 #endif
-static bool dsp_driver = 1;
+static bool dmic_detect = 1;
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for Intel HD audio interface.");
 MODULE_PARM_DESC(beep_mode, "Select HDA Beep registration mode "
 			    "(0=off, 1=on) (default=1).");
 #endif
-module_param(dsp_driver, bool, 0444);
+module_param(dmic_detect, bool, 0444);
-MODULE_PARM_DESC(dsp_driver, "Allow DSP driver selection (bypass this driver) "
+MODULE_PARM_DESC(dmic_detect, "Allow DSP driver selection (bypass this driver) "
-			     "(0=off, 1=on) (default=1)");
+			     "(0=off, 1=on) (default=1); "
+		 "deprecated, use snd-intel-dspcfg.dsp_driver option instead");
 #ifdef CONFIG_PM
 static int param_set_xint(const char *val, const struct kernel_param *kp);
 	/*
 	 * stop probe if another Intel's DSP driver should be activated
 	 */
-	if (dsp_driver) {
+	if (dmic_detect) {
 		err = snd_intel_dsp_driver_probe(pci);
 		if (err != SND_INTEL_DSP_DRIVER_ANY &&
 		    err != SND_INTEL_DSP_DRIVER_LEGACY)
 			return -ENODEV;
+	} else {
+		dev_warn(&pci->dev, "dmic_detect option is deprecated, pass snd-intel-dspcfg.dsp_driver=1 option instead\n");
 	}
 	err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,

sound/soc/codecs/cros_ec_codec.c+8−0

 #include <crypto/hash.h>
 #include <crypto/sha.h>
+#include <linux/acpi.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/io.h>
 MODULE_DEVICE_TABLE(of, cros_ec_codec_of_match);
 #endif
+static const struct acpi_device_id cros_ec_codec_acpi_id[] = {
+	{ "GOOG0013", 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(acpi, cros_ec_codec_acpi_id);
 static struct platform_driver cros_ec_codec_platform_driver = {
 	.driver = {
 		.name = "cros-ec-codec",
 		.of_match_table = of_match_ptr(cros_ec_codec_of_match),
+		.acpi_match_table = ACPI_PTR(cros_ec_codec_acpi_id),
 	},
 	.probe = cros_ec_codec_platform_probe,
 };

sound/soc/codecs/hdac_hda.c+3−1

@@ -588,7 +588,9 @@ static int hdac_hda_dev_remove(struct hdac_device *hdev) · 587 unmodified lines
588	struct hdac_hda_priv *hda_pvt;	588	struct hdac_hda_priv *hda_pvt;
589		589
590	hda_pvt = dev_get_drvdata(&hdev->dev);	590	hda_pvt = dev_get_drvdata(&hdev->dev);
591	cancel_delayed_work_sync(&hda_pvt->codec.jackpoll_work);	591	if (hda_pvt && hda_pvt->codec.registered)
		592	cancel_delayed_work_sync(&hda_pvt->codec.jackpoll_work);
		593
592	return 0;	594	return 0;
593	}	595	}
594		596

sound/soc/codecs/msm8916-wcd-analog.c+15−5

 	switch (event) {
 	case SND_SOC_DAPM_PRE_PMU:
-		snd_soc_component_update_bits(component, CDC_A_MICB_1_INT_RBIAS,
-				    MICB_1_INT_TX2_INT_RBIAS_EN_MASK,
-				    MICB_1_INT_TX2_INT_RBIAS_EN_ENABLE);
 		snd_soc_component_update_bits(component, reg, MICB_1_EN_PULL_DOWN_EN_MASK, 0);
 		snd_soc_component_update_bits(component, CDC_A_MICB_1_EN,
 				    MICB_1_EN_OPA_STG2_TAIL_CURR_MASK,
 	struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 	struct pm8916_wcd_analog_priv *wcd = snd_soc_component_get_drvdata(component);
+	switch (event) {
+	case SND_SOC_DAPM_PRE_PMU:
+		snd_soc_component_update_bits(component, CDC_A_MICB_1_INT_RBIAS,
+				    MICB_1_INT_TX1_INT_RBIAS_EN_MASK,
+				    MICB_1_INT_TX1_INT_RBIAS_EN_ENABLE);
+		break;
+	}
 	return pm8916_wcd_analog_enable_micbias_int(component, event, w->reg,
 						     wcd->micbias1_cap_mode);
 }
 	struct pm8916_wcd_analog_priv *wcd = snd_soc_component_get_drvdata(component);
 	switch (event) {
+	case SND_SOC_DAPM_PRE_PMU:
+		snd_soc_component_update_bits(component, CDC_A_MICB_1_INT_RBIAS,
+				    MICB_1_INT_TX2_INT_RBIAS_EN_MASK,
+				    MICB_1_INT_TX2_INT_RBIAS_EN_ENABLE);
+		break;
 	case SND_SOC_DAPM_POST_PMU:
 		pm8916_mbhc_configure_bias(wcd, true);
 		break;
 	SND_SOC_DAPM_SUPPLY("MIC BIAS External1", CDC_A_MICB_1_EN, 7, 0,
 			    pm8916_wcd_analog_enable_micbias_ext1,
-			    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
+			    SND_SOC_DAPM_POST_PMU),
 	SND_SOC_DAPM_SUPPLY("MIC BIAS External2", CDC_A_MICB_2_EN, 7, 0,
 			    pm8916_wcd_analog_enable_micbias_ext2,
-			    SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+			    SND_SOC_DAPM_POST_PMU),
 	SND_SOC_DAPM_ADC_E("ADC1", NULL, CDC_A_TX_1_EN, 7, 0,
 			   pm8916_wcd_analog_enable_adc,

sound/soc/codecs/msm8916-wcd-digital.c+6−0

 		snd_soc_component_write(component, rx_gain_reg[w->shift],
 			      snd_soc_component_read32(component, rx_gain_reg[w->shift]));
 		break;
+	case SND_SOC_DAPM_POST_PMD:
+		snd_soc_component_update_bits(component, LPASS_CDC_CLK_RX_RESET_CTL,
+					      1 << w->shift, 1 << w->shift);
+		snd_soc_component_update_bits(component, LPASS_CDC_CLK_RX_RESET_CTL,
+					      1 << w->shift, 0x0);
+		break;
 	}
 	return 0;
 }

sound/soc/codecs/rt5640.c+7−0

@@ -2432,6 +2432,13 @@ static void rt5640_disable_jack_detect(struct snd_soc_component *component) · 2431 unmodified lines
2432	{	2432	{
2433	struct rt5640_priv *rt5640 = snd_soc_component_get_drvdata(component);	2433	struct rt5640_priv *rt5640 = snd_soc_component_get_drvdata(component);
2434		2434
		2435	/*
		2436	* soc_remove_component() force-disables jack and thus rt5640->jack
		2437	* could be NULL at the time of driver's module unloading.
		2438	*/
		2439	if (!rt5640->jack)
		2440	return;
		2441
2435	disable_irq(rt5640->irq);	2442	disable_irq(rt5640->irq);
2436	rt5640_cancel_work(rt5640);	2443	rt5640_cancel_work(rt5640);
2437		2444

sound/soc/intel/boards/bytcht_es8316.c+2−1

 			DMI_MATCH(DMI_SYS_VENDOR, "IRBIS"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "NB41"),
 		},
-		.driver_data = (void *)(BYT_CHT_ES8316_INTMIC_IN2_MAP
+		.driver_data = (void *)(BYT_CHT_ES8316_SSP0
+					| BYT_CHT_ES8316_INTMIC_IN2_MAP
 					| BYT_CHT_ES8316_JD_INVERTED),
 	},
 	{	/* Teclast X98 Plus II */

sound/soc/soc-component.c+3−0

@@ -539,6 +539,9 @@ void snd_soc_pcm_component_free(struct snd_soc_pcm_runtime *rtd) · 538 unmodified lines
539	struct snd_soc_rtdcom_list *rtdcom;	539	struct snd_soc_rtdcom_list *rtdcom;
540	struct snd_soc_component *component;	540	struct snd_soc_component *component;
541		541
		542	if (!rtd->pcm)
		543	return;
		544
542	for_each_rtd_components(rtd, rtdcom, component)	545	for_each_rtd_components(rtd, rtdcom, component)
543	if (component->driver->pcm_destruct)	546	if (component->driver->pcm_destruct)
544	component->driver->pcm_destruct(component, rtd->pcm);	547	component->driver->pcm_destruct(component, rtd->pcm);

sound/soc/sof/intel/hda-codec.c+12−7

 #define IDISP_VID_INTEL	0x80860000
 /* load the legacy HDA codec driver */
-#ifdef MODULE
+static int hda_codec_load_module(struct hda_codec *codec)
-static void hda_codec_load_module(struct hda_codec *codec)
 {
+#ifdef MODULE
 	char alias[MODULE_NAME_LEN];
 	const char *module = alias;
 	snd_hdac_codec_modalias(&codec->core, alias, sizeof(alias));
 	dev_dbg(&codec->core.dev, "loading codec module: %s\n", module);
 	request_module(module);
-}
-#else
-static void hda_codec_load_module(struct hda_codec *codec) {}
 #endif
+	return device_attach(hda_codec_dev(codec));
+}
 /* enable controller wake up event for all codecs with jack connectors */
 void hda_codec_jack_wake_enable(struct snd_sof_dev *sdev)
 	if ((mach_params && mach_params->common_hdmi_codec_drv) ||
 	    (resp & 0xFFFF0000) != IDISP_VID_INTEL) {
 		hdev->type = HDA_DEV_LEGACY;
-		hda_codec_load_module(&hda_priv->codec);
+		ret = hda_codec_load_module(&hda_priv->codec);
+		/*
+		 * handle ret==0 (no driver bound) as an error, but pass
+		 * other return codes without modification
+		 */
+		if (ret == 0)
+			ret = -ENOENT;
 	}
-	return 0;
+	return ret;
 #else
 	hdev = devm_kzalloc(sdev->dev, sizeof(*hdev), GFP_KERNEL);
 	if (!hdev)

sound/soc/sof/intel/hda-loader.c+3−3

 		if (!ret)
 			break;
-		dev_err(sdev->dev, "error: Error code=0x%x: FW status=0x%x\n",
+		dev_dbg(sdev->dev, "iteration %d of Core En/ROM load failed: %d\n",
+			i, ret);
+		dev_dbg(sdev->dev, "Error code=0x%x: FW status=0x%x\n",
 			snd_sof_dsp_read(sdev, HDA_DSP_BAR,
 					 HDA_DSP_SRAM_REG_ROM_ERROR),
 			snd_sof_dsp_read(sdev, HDA_DSP_BAR,
 					 HDA_DSP_SRAM_REG_ROM_STATUS));
-		dev_err(sdev->dev, "error: iteration %d of Core En/ROM load failed: %d\n",
-			i, ret);
 	}
 	if (i == HDA_FW_BOOT_ATTEMPTS) {

sound/soc/sti/uniperif_player.c+4−3

 	 * sampling frequency. If no sample rate is already specified, then
 	 * set one.
 	 */
-	mutex_lock(&player->ctrl_lock);
 	if (runtime) {
 		switch (runtime->rate) {
 		case 22050:
 		player->stream_settings.iec958.status[3 + (n * 4)] << 24;
 		SET_UNIPERIF_CHANNEL_STA_REGN(player, n, status);
 	}
-	mutex_unlock(&player->ctrl_lock);
 	/* Update the channel status */
 	if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
 	SET_UNIPERIF_CTRL_ZERO_STUFF_HW(player);
+	mutex_lock(&player->ctrl_lock);
 	/* Update the channel status */
 	uni_player_set_channel_status(player, runtime);
+	mutex_unlock(&player->ctrl_lock);
 	/* Clear the user validity user bits */
 	SET_UNIPERIF_USER_VALIDITY_VALIDITY_LR(player, 0);
 	iec958->status[1] = ucontrol->value.iec958.status[1];
 	iec958->status[2] = ucontrol->value.iec958.status[2];
 	iec958->status[3] = ucontrol->value.iec958.status[3];
-	mutex_unlock(&player->ctrl_lock);
 	spin_lock_irqsave(&player->irq_lock, flags);
 	if (player->substream && player->substream->runtime)
 		uni_player_set_channel_status(player, NULL);
 	spin_unlock_irqrestore(&player->irq_lock, flags);
+	mutex_unlock(&player->ctrl_lock);
 	return 0;
 }

sound/soc/stm/stm32_adfsdm.c+6−6

@@ -153,13 +153,13 @@ static const struct snd_soc_component_driver stm32_adfsdm_dai_component = { · 152 unmodified lines
153	.name = "stm32_dfsdm_audio",	153	.name = "stm32_dfsdm_audio",
154	};	154	};
155		155
156	static void memcpy_32to16(void dest, const void src, size_t n)	156	static void stm32_memcpy_32to16(void dest, const void src, size_t n)
157	{	157	{
158	unsigned int i = 0;	158	unsigned int i = 0;
159	u16 d = (u16 )dest, s = (u16 )src;	159	u16 d = (u16 )dest, s = (u16 )src;
160		160
161	s++;	161	s++;
162	for (i = n; i > 0; i--) {	162	for (i = n >> 1; i > 0; i--) {
163	d++ = s++;	163	d++ = s++;
164	s++;	164	s++;
165	}	165	}
@@ -186,8 +186,8 @@ static int stm32_afsdm_pcm_cb(const void data, size_t size, void private) · 20 unmodified lines
186		186
187	if ((priv->pos + src_size) > buff_size) {	187	if ((priv->pos + src_size) > buff_size) {
188	if (format == SNDRV_PCM_FORMAT_S16_LE)	188	if (format == SNDRV_PCM_FORMAT_S16_LE)
189	memcpy_32to16(&pcm_buff[priv->pos], src_buff,	189	stm32_memcpy_32to16(&pcm_buff[priv->pos], src_buff,
190	buff_size - priv->pos);	190	buff_size - priv->pos);
191	else	191	else
192	memcpy(&pcm_buff[priv->pos], src_buff,	192	memcpy(&pcm_buff[priv->pos], src_buff,
193	buff_size - priv->pos);	193	buff_size - priv->pos);
@@ -196,8 +196,8 @@ static int stm32_afsdm_pcm_cb(const void data, size_t size, void private) · 2 unmodified lines
196	}	196	}
197		197
198	if (format == SNDRV_PCM_FORMAT_S16_LE)	198	if (format == SNDRV_PCM_FORMAT_S16_LE)
199	memcpy_32to16(&pcm_buff[priv->pos],	199	stm32_memcpy_32to16(&pcm_buff[priv->pos],
200	&src_buff[src_size - cur_size], cur_size);	200	&src_buff[src_size - cur_size], cur_size);
201	else	201	else
202	memcpy(&pcm_buff[priv->pos], &src_buff[src_size - cur_size],	202	memcpy(&pcm_buff[priv->pos], &src_buff[src_size - cur_size],
203	cur_size);	203	cur_size);

sound/soc/stm/stm32_sai_sub.c+140−54

 	}
 }
+static int stm32_sai_sub_reg_up(struct stm32_sai_sub_data *sai,
+				unsigned int reg, unsigned int mask,
+				unsigned int val)
+{
+	int ret;
+	ret = clk_enable(sai->pdata->pclk);
+	if (ret < 0)
+		return ret;
+	ret = regmap_update_bits(sai->regmap, reg, mask, val);
+	clk_disable(sai->pdata->pclk);
+	return ret;
+}
+static int stm32_sai_sub_reg_wr(struct stm32_sai_sub_data *sai,
+				unsigned int reg, unsigned int mask,
+				unsigned int val)
+{
+	int ret;
+	ret = clk_enable(sai->pdata->pclk);
+	if (ret < 0)
+		return ret;
+	ret = regmap_write_bits(sai->regmap, reg, mask, val);
+	clk_disable(sai->pdata->pclk);
+	return ret;
+}
+static int stm32_sai_sub_reg_rd(struct stm32_sai_sub_data *sai,
+				unsigned int reg, unsigned int *val)
+{
+	int ret;
+	ret = clk_enable(sai->pdata->pclk);
+	if (ret < 0)
+		return ret;
+	ret = regmap_read(sai->regmap, reg, val);
+	clk_disable(sai->pdata->pclk);
+	return ret;
+}
 static const struct regmap_config stm32_sai_sub_regmap_config_f4 = {
 	.reg_bits = 32,
 	.reg_stride = 4,
 	mask = SAI_XCR1_MCKDIV_MASK(SAI_XCR1_MCKDIV_WIDTH(version));
 	cr1 = SAI_XCR1_MCKDIV_SET(div);
-	ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, mask, cr1);
+	ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX, mask, cr1);
 	if (ret < 0)
 		dev_err(&sai->pdev->dev, "Failed to update CR1 register\n");
 	dev_dbg(&sai->pdev->dev, "Enable master clock\n");
-	return regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+	return stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
-				  SAI_XCR1_MCKEN, SAI_XCR1_MCKEN);
+				    SAI_XCR1_MCKEN, SAI_XCR1_MCKEN);
 }
 static void stm32_sai_mclk_disable(struct clk_hw *hw)
 	dev_dbg(&sai->pdev->dev, "Disable master clock\n");
-	regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, SAI_XCR1_MCKEN, 0);
+	stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX, SAI_XCR1_MCKEN, 0);
 }
 static const struct clk_ops mclk_ops = {
 	unsigned int sr, imr, flags;
 	snd_pcm_state_t status = SNDRV_PCM_STATE_RUNNING;
-	regmap_read(sai->regmap, STM_SAI_IMR_REGX, &imr);
+	stm32_sai_sub_reg_rd(sai, STM_SAI_IMR_REGX, &imr);
-	regmap_read(sai->regmap, STM_SAI_SR_REGX, &sr);
+	stm32_sai_sub_reg_rd(sai, STM_SAI_SR_REGX, &sr);
 	flags = sr & imr;
 	if (!flags)
 		return IRQ_NONE;
-	regmap_write_bits(sai->regmap, STM_SAI_CLRFR_REGX, SAI_XCLRFR_MASK,
+	stm32_sai_sub_reg_wr(sai, STM_SAI_CLRFR_REGX, SAI_XCLRFR_MASK,
-			  SAI_XCLRFR_MASK);
+			     SAI_XCLRFR_MASK);
 	if (!sai->substream) {
 		dev_err(&pdev->dev, "Device stopped. Spurious IRQ 0x%x\n", sr);
 	int ret;
 	if (dir == SND_SOC_CLOCK_OUT && sai->sai_mclk) {
-		ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+		ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
-					 SAI_XCR1_NODIV,
+					   SAI_XCR1_NODIV,
 					 freq ? 0 : SAI_XCR1_NODIV);
 		if (ret < 0)
 			return ret;
 	slotr_mask |= SAI_XSLOTR_SLOTEN_MASK;
-	regmap_update_bits(sai->regmap, STM_SAI_SLOTR_REGX, slotr_mask, slotr);
+	stm32_sai_sub_reg_up(sai, STM_SAI_SLOTR_REGX, slotr_mask, slotr);
 	sai->slot_width = slot_width;
 	sai->slots = slots;
 	cr1_mask |= SAI_XCR1_CKSTR;
 	frcr_mask |= SAI_XFRCR_FSPOL;
-	regmap_update_bits(sai->regmap, STM_SAI_FRCR_REGX, frcr_mask, frcr);
+	stm32_sai_sub_reg_up(sai, STM_SAI_FRCR_REGX, frcr_mask, frcr);
 	/* DAI clock master masks */
 	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 	cr1_mask |= SAI_XCR1_SLAVE;
 conf_update:
-	ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1);
+	ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX, cr1_mask, cr1);
 	if (ret < 0) {
 		dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
 		return ret;
 	}
 	/* Enable ITs */
-	regmap_write_bits(sai->regmap, STM_SAI_CLRFR_REGX,
+	stm32_sai_sub_reg_wr(sai, STM_SAI_CLRFR_REGX,
-			  SAI_XCLRFR_MASK, SAI_XCLRFR_MASK);
+			     SAI_XCLRFR_MASK, SAI_XCLRFR_MASK);
 	imr = SAI_XIMR_OVRUDRIE;
 	if (STM_SAI_IS_CAPTURE(sai)) {
-		regmap_read(sai->regmap, STM_SAI_CR2_REGX, &cr2);
+		stm32_sai_sub_reg_rd(sai, STM_SAI_CR2_REGX, &cr2);
 		if (cr2 & SAI_XCR2_MUTECNT_MASK)
 			imr |= SAI_XIMR_MUTEDETIE;
 	}
 	else
 		imr |= SAI_XIMR_AFSDETIE | SAI_XIMR_LFSDETIE;
-	regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX,
+	stm32_sai_sub_reg_up(sai, STM_SAI_IMR_REGX,
-			   SAI_XIMR_MASK, imr);
+			     SAI_XIMR_MASK, imr);
 	return 0;
 }
 	 * SAI fifo threshold is set to half fifo, to keep enough space
 	 * for DMA incoming bursts.
 	 */
-	regmap_write_bits(sai->regmap, STM_SAI_CR2_REGX,
+	stm32_sai_sub_reg_wr(sai, STM_SAI_CR2_REGX,
-			  SAI_XCR2_FFLUSH | SAI_XCR2_FTH_MASK,
+			     SAI_XCR2_FFLUSH | SAI_XCR2_FTH_MASK,
-			  SAI_XCR2_FFLUSH |
+			     SAI_XCR2_FFLUSH |
-			  SAI_XCR2_FTH_SET(STM_SAI_FIFO_TH_HALF));
+			     SAI_XCR2_FTH_SET(STM_SAI_FIFO_TH_HALF));
 	/* DS bits in CR1 not set for SPDIF (size forced to 24 bits).*/
 	if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
 	if ((sai->slots == 2) && (params_channels(params) == 1))
 		cr1 |= SAI_XCR1_MONO;
-	ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1);
+	ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX, cr1_mask, cr1);
 	if (ret < 0) {
 		dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
 		return ret;
 	struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 	int slotr, slot_sz;
-	regmap_read(sai->regmap, STM_SAI_SLOTR_REGX, &slotr);
+	stm32_sai_sub_reg_rd(sai, STM_SAI_SLOTR_REGX, &slotr);
 	/*
 	 * If SLOTSZ is set to auto in SLOTR, align slot width on data size
 		sai->slots = 2;
 	/* The number of slots in the audio frame is equal to NBSLOT[3:0] + 1*/
-	regmap_update_bits(sai->regmap, STM_SAI_SLOTR_REGX,
+	stm32_sai_sub_reg_up(sai, STM_SAI_SLOTR_REGX,
-			   SAI_XSLOTR_NBSLOT_MASK,
+			     SAI_XSLOTR_NBSLOT_MASK,
-			   SAI_XSLOTR_NBSLOT_SET((sai->slots - 1)));
+			     SAI_XSLOTR_NBSLOT_SET((sai->slots - 1)));
 	/* Set default slots mask if not already set from DT */
 	if (!(slotr & SAI_XSLOTR_SLOTEN_MASK)) {
 		sai->slot_mask = (1 << sai->slots) - 1;
-		regmap_update_bits(sai->regmap,
+		stm32_sai_sub_reg_up(sai,
-				   STM_SAI_SLOTR_REGX, SAI_XSLOTR_SLOTEN_MASK,
+				     STM_SAI_SLOTR_REGX, SAI_XSLOTR_SLOTEN_MASK,
-				   SAI_XSLOTR_SLOTEN_SET(sai->slot_mask));
+				     SAI_XSLOTR_SLOTEN_SET(sai->slot_mask));
 	}
 	dev_dbg(cpu_dai->dev, "Slots %d, slot width %d\n",
 	dev_dbg(cpu_dai->dev, "Frame length %d, frame active %d\n",
 		sai->fs_length, fs_active);
-	regmap_update_bits(sai->regmap, STM_SAI_FRCR_REGX, frcr_mask, frcr);
+	stm32_sai_sub_reg_up(sai, STM_SAI_FRCR_REGX, frcr_mask, frcr);
 	if ((sai->fmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_LSB) {
 		offset = sai->slot_width - sai->data_size;
-		regmap_update_bits(sai->regmap, STM_SAI_SLOTR_REGX,
+		stm32_sai_sub_reg_up(sai, STM_SAI_SLOTR_REGX,
-				   SAI_XSLOTR_FBOFF_MASK,
+				     SAI_XSLOTR_FBOFF_MASK,
-				   SAI_XSLOTR_FBOFF_SET(offset));
+				     SAI_XSLOTR_FBOFF_SET(offset));
 	}
 }
 					return -EINVAL;
 				}
-				regmap_update_bits(sai->regmap,
+				stm32_sai_sub_reg_up(sai,
-						   STM_SAI_CR1_REGX,
+						     STM_SAI_CR1_REGX,
-						   SAI_XCR1_OSR, cr1);
+						     SAI_XCR1_OSR, cr1);
 				div = stm32_sai_get_clk_div(sai, sai_clk_rate,
 							    sai->mclk_rate);
 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 		dev_dbg(cpu_dai->dev, "Enable DMA and SAI\n");
-		regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+		stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
-				   SAI_XCR1_DMAEN, SAI_XCR1_DMAEN);
+				     SAI_XCR1_DMAEN, SAI_XCR1_DMAEN);
 		/* Enable SAI */
-		ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+		ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
-					 SAI_XCR1_SAIEN, SAI_XCR1_SAIEN);
+					   SAI_XCR1_SAIEN, SAI_XCR1_SAIEN);
 		if (ret < 0)
 			dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
 		break;
 	case SNDRV_PCM_TRIGGER_STOP:
 		dev_dbg(cpu_dai->dev, "Disable DMA and SAI\n");
-		regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX,
+		stm32_sai_sub_reg_up(sai, STM_SAI_IMR_REGX,
-				   SAI_XIMR_MASK, 0);
+				     SAI_XIMR_MASK, 0);
-		regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+		stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
-				   SAI_XCR1_SAIEN,
+				     SAI_XCR1_SAIEN,
-				   (unsigned int)~SAI_XCR1_SAIEN);
+				     (unsigned int)~SAI_XCR1_SAIEN);
-		ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
+		ret = stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX,
-					 SAI_XCR1_DMAEN,
+					   SAI_XCR1_DMAEN,
-					 (unsigned int)~SAI_XCR1_DMAEN);
+					   (unsigned int)~SAI_XCR1_DMAEN);
 		if (ret < 0)
 			dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
 	struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 	unsigned long flags;
-	regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX, SAI_XIMR_MASK, 0);
+	stm32_sai_sub_reg_up(sai, STM_SAI_IMR_REGX, SAI_XIMR_MASK, 0);
 	clk_disable_unprepare(sai->sai_ck);
 	cr1_mask |= SAI_XCR1_SYNCEN_MASK;
 	cr1 |= SAI_XCR1_SYNCEN_SET(sai->sync);
-	return regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1);
+	return stm32_sai_sub_reg_up(sai, STM_SAI_CR1_REGX, cr1_mask, cr1);
 }
 static const struct snd_soc_dai_ops stm32_sai_pcm_dai_ops = {
 	if (STM_SAI_HAS_PDM(sai) && STM_SAI_IS_SUB_A(sai))
 		sai->regmap_config = &stm32_sai_sub_regmap_config_h7;
-	sai->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "sai_ck",
+	/*
-						base, sai->regmap_config);
+	 * Do not manage peripheral clock through regmap framework as this
+	 * can lead to circular locking issue with sai master clock provider.
+	 * Manage peripheral clock directly in driver instead.
+	 */
+	sai->regmap = devm_regmap_init_mmio(&pdev->dev, base,
+					    sai->regmap_config);
 	if (IS_ERR(sai->regmap)) {
 		dev_err(&pdev->dev, "Failed to initialize MMIO\n");
 		return PTR_ERR(sai->regmap);
 		return PTR_ERR(sai->sai_ck);
 	}
+	ret = clk_prepare(sai->pdata->pclk);
+	if (ret < 0)
+		return ret;
 	if (STM_SAI_IS_F4(sai->pdata))
 		return 0;
 	return 0;
 }
+static int stm32_sai_sub_remove(struct platform_device *pdev)
+{
+	struct stm32_sai_sub_data *sai = dev_get_drvdata(&pdev->dev);
+	clk_unprepare(sai->pdata->pclk);
+	return 0;
+}
 #ifdef CONFIG_PM_SLEEP
 static int stm32_sai_sub_suspend(struct device *dev)
 {
 	struct stm32_sai_sub_data *sai = dev_get_drvdata(dev);
+	int ret;
+	ret = clk_enable(sai->pdata->pclk);
+	if (ret < 0)
+		return ret;
 	regcache_cache_only(sai->regmap, true);
 	regcache_mark_dirty(sai->regmap);
+	clk_disable(sai->pdata->pclk);
 	return 0;
 }
 static int stm32_sai_sub_resume(struct device *dev)
 {
 	struct stm32_sai_sub_data *sai = dev_get_drvdata(dev);
+	int ret;
+	ret = clk_enable(sai->pdata->pclk);
+	if (ret < 0)
+		return ret;
 	regcache_cache_only(sai->regmap, false);
-	return regcache_sync(sai->regmap);
+	ret = regcache_sync(sai->regmap);
+	clk_disable(sai->pdata->pclk);
+	return ret;
 }
 #endif /* CONFIG_PM_SLEEP */
 		.pm = &stm32_sai_sub_pm_ops,
 	},
 	.probe = stm32_sai_sub_probe,
+	.remove = stm32_sai_sub_remove,
 };
 module_platform_driver(stm32_sai_sub_driver);

sound/usb/pcm.c+1−1

@@ -370,7 +370,7 @@ static int set_sync_ep_implicit_fb_quirk(struct snd_usb_substream *subs, · 369 unmodified lines
370	add_sync_ep_from_ifnum:	370	add_sync_ep_from_ifnum:
371	iface = usb_ifnum_to_if(dev, ifnum);	371	iface = usb_ifnum_to_if(dev, ifnum);
372		372
373	if (!iface \|\| iface->num_altsetting == 0)	373	if (!iface \|\| iface->num_altsetting < 2)
374	return -EINVAL;	374	return -EINVAL;
375		375
376	alts = &iface->altsetting[1];	376	alts = &iface->altsetting[1];

tools/bpf/bpftool/btf_dumper.c+1−1

@@ -26,7 +26,7 @@ static void btf_dumper_ptr(const void data, json_writer_t jw, · 25 unmodified lines
26	bool is_plain_text)	26	bool is_plain_text)
27	{	27	{
28	if (is_plain_text)	28	if (is_plain_text)
29	jsonw_printf(jw, "%p", data);	29	jsonw_printf(jw, "%p", (void *)data);
30	else	30	else
31	jsonw_printf(jw, "%lu", (unsigned long )data);	31	jsonw_printf(jw, "%lu", (unsigned long )data);
32	}	32	}

tools/lib/traceevent/parse-filter.c+3−1

 	}
 	filter_type = add_filter_type(filter, event->id);
-	if (filter_type == NULL)
+	if (filter_type == NULL) {
+		free_arg(arg);
 		return TEP_ERRNO__MEM_ALLOC_FAILED;
+	}
 	if (filter_type->filter)
 		free_arg(filter_type->filter);

tools/perf/builtin-report.c+4−1

 	struct stat st;
 	bool has_br_stack = false;
 	int branch_mode = -1;
+	int last_key = 0;
 	bool branch_call_mode = false;
 #define CALLCHAIN_DEFAULT_OPT  "graph,0.5,caller,function,percent"
 	static const char report_callchain_help[] = "Display call graph (stack chain/backtrace):\n\n"
 		sort_order = sort_tmp;
 	}
-	if (setup_sorting(session->evlist) < 0) {
+	if ((last_key != K_SWITCH_INPUT_DATA) &&
+	    (setup_sorting(session->evlist) < 0)) {
 		if (sort_order)
 			parse_options_usage(report_usage, options, "s", 1);
 		if (field_order)
 	ret = __cmd_report(&report);
 	if (ret == K_SWITCH_INPUT_DATA) {
 		perf_session__delete(session);
+		last_key = K_SWITCH_INPUT_DATA;
 		goto repeat;
 	} else
 		ret = 0;

tools/perf/util/hist.h+2−2

@@ -339,10 +339,10 @@ static inline void perf_hpp__prepend_sort_field(struct perf_hpp_fmt *format) · 338 unmodified lines
339	list_for_each_entry_safe(format, tmp, &(_list)->sorts, sort_list)	339	list_for_each_entry_safe(format, tmp, &(_list)->sorts, sort_list)
340		340
341	#define hists__for_each_format(hists, format) \	341	#define hists__for_each_format(hists, format) \
342	perf_hpp_list__for_each_format((hists)->hpp_list, fmt)	342	perf_hpp_list__for_each_format((hists)->hpp_list, format)
343		343
344	#define hists__for_each_sort_list(hists, format) \	344	#define hists__for_each_sort_list(hists, format) \
345	perf_hpp_list__for_each_sort_list((hists)->hpp_list, fmt)	345	perf_hpp_list__for_each_sort_list((hists)->hpp_list, format)
346		346
347	extern struct perf_hpp_fmt perf_hpp__format[];	347	extern struct perf_hpp_fmt perf_hpp__format[];
348		348

tools/perf/util/symbol-elf.c+3−0

@@ -920,6 +920,9 @@ static int dso__process_kernel_symbol(struct dso dso, struct map map, · 919 unmodified lines
920	if (curr_map == NULL)	920	if (curr_map == NULL)
921	return -1;	921	return -1;
922		922
		923	if (curr_dso->kernel)
		924	map__kmap(curr_map)->kmaps = kmaps;
		925
923	if (adjust_kernel_syms) {	926	if (adjust_kernel_syms) {
924	curr_map->start = shdr->sh_addr + ref_reloc(kmap);	927	curr_map->start = shdr->sh_addr + ref_reloc(kmap);
925	curr_map->end = curr_map->start + shdr->sh_size;	928	curr_map->end = curr_map->start + shdr->sh_size;

tools/testing/selftests/drivers/net/mlxsw/qos_mc_aware.sh+6−2

@@ -232,7 +232,7 @@ test_mc_aware() · 231 unmodified lines
232	stop_traffic	232	stop_traffic
233	local ucth1=${uc_rate[1]}	233	local ucth1=${uc_rate[1]}
234		234
235	start_traffic $h1 own bc bc	235	start_traffic $h1 192.0.2.65 bc bc
236		236
237	local d0=$(date +%s)	237	local d0=$(date +%s)
238	local t0=$(ethtool_stats_get $h3 rx_octets_prio_0)	238	local t0=$(ethtool_stats_get $h3 rx_octets_prio_0)
@@ -254,7 +254,11 @@ test_mc_aware() · 15 unmodified lines
254	ret = 100 * ($ucth1 - $ucth2) / $ucth1	254	ret = 100 * ($ucth1 - $ucth2) / $ucth1
255	if (ret > 0) { ret } else { 0 }	255	if (ret > 0) { ret } else { 0 }
256	")	256	")
257	check_err $(bc <<< "$deg > 25")	257
		258	# Minimum shaper of 200Mbps on MC TCs should cause about 20% of
		259	# degradation on 1Gbps link.
		260	check_err $(bc <<< "$deg < 15") "Minimum shaper not in effect"
		261	check_err $(bc <<< "$deg > 25") "MC traffic degrades UC performance too much"
258		262
259	local interval=$((d1 - d0))	263	local interval=$((d1 - d0))
260	local mc_ir=$(rate $u0 $u1 $interval)	264	local mc_ir=$(rate $u0 $u1 $interval)