lael-labs/linux

CREDITS+4−0

@@ -1637,6 +1637,10 @@ S: Panoramastrasse 18 · 1636 unmodified lines
1637	S: D-69126 Heidelberg	1637	S: D-69126 Heidelberg
1638	S: Germany	1638	S: Germany
1639		1639
		1640	N: Simon Horman
		1641	M: horms@verge.net.au
		1642	D: Renesas ARM/ARM64 SoC maintainer
		1643
1640	N: Christopher Horn	1644	N: Christopher Horn
1641	E: chorn@warwick.net	1645	E: chorn@warwick.net
1642	D: Miscellaneous sysctl hacks	1646	D: Miscellaneous sysctl hacks

Documentation/admin-guide/cgroup-v2.rst+14−6

 Protections
 -----------
-A cgroup is protected to be allocated upto the configured amount of
+A cgroup is protected upto the configured amount of the resource
-the resource if the usages of all its ancestors are under their
+as long as the usages of all its ancestors are under their
 protected levels.  Protections can be hard guarantees or best effort
 soft boundaries.  Protections can also be over-committed in which case
 only upto the amount available to the parent is protected among
 	is within its effective min boundary, the cgroup's memory
 	won't be reclaimed under any conditions. If there is no
 	unprotected reclaimable memory available, OOM killer
-	is invoked.
+	is invoked. Above the effective min boundary (or
+	effective low boundary if it is higher), pages are reclaimed
+	proportionally to the overage, reducing reclaim pressure for
+	smaller overages.
        Effective min boundary is limited by memory.min values of
 	all ancestor cgroups. If there is memory.min overcommitment
 	Best-effort memory protection.  If the memory usage of a
 	cgroup is within its effective low boundary, the cgroup's
 	memory won't be reclaimed unless memory can be reclaimed
-	from unprotected cgroups.
+	from unprotected cgroups.  Above the effective low boundary (or
+	effective min boundary if it is higher), pages are reclaimed
+	proportionally to the overage, reducing reclaim pressure for
+	smaller overages.
 	Effective low boundary is limited by memory.low values of
 	all ancestor cgroups. If there is memory.low overcommitment
 becomes self-defeating.
 The memory.low boundary on the other hand is a top-down allocated
-reserve.  A cgroup enjoys reclaim protection when it's within its low,
+reserve.  A cgroup enjoys reclaim protection when it's within its
-which makes delegation of subtrees possible.
+effective low, which makes delegation of subtrees possible. It also
+enjoys having reclaim pressure proportional to its overage when
+above its effective low.
 The original high boundary, the hard limit, is defined as a strict
 limit that can not budge, even if the OOM killer has to be called.

Documentation/admin-guide/kernel-parameters.txt+4−0

 				the unplug protocol
 			never -- do not unplug even if version check succeeds
+	xen_legacy_crash	[X86,XEN]
+			Crash from Xen panic notifier, without executing late
+			panic() code such as dumping handler.
 	xen_nopvspin	[X86,XEN]
 			Disables the ticketlock slowpath using Xen PV
 			optimizations.

Documentation/arm64/memory.rst+8−1

@@ -154,11 +154,18 @@ return virtual addresses to userspace from a 48-bit range. · 153 unmodified lines
154		154
155	Software can "opt-in" to receiving VAs from a 52-bit space by	155	Software can "opt-in" to receiving VAs from a 52-bit space by
156	specifying an mmap hint parameter that is larger than 48-bit.	156	specifying an mmap hint parameter that is larger than 48-bit.
		157
157	For example:	158	For example:
158	maybe_high_address = mmap(~0UL, size, prot, flags,...);	159
		160	.. code-block:: c
		161
		162	maybe_high_address = mmap(~0UL, size, prot, flags,...);
159		163
160	It is also possible to build a debug kernel that returns addresses	164	It is also possible to build a debug kernel that returns addresses
161	from a 52-bit space by enabling the following kernel config options:	165	from a 52-bit space by enabling the following kernel config options:
		166
		167	.. code-block:: sh
		168
162	CONFIG_EXPERT=y && CONFIG_ARM64_FORCE_52BIT=y	169	CONFIG_EXPERT=y && CONFIG_ARM64_FORCE_52BIT=y
163		170
164	Note that this option is only intended for debugging applications	171	Note that this option is only intended for debugging applications

Documentation/arm64/silicon-errata.rst+2−0

 +----------------+-----------------+-----------------+-----------------------------+
 | Cavium         | ThunderX2 SMMUv3| #126            | N/A                         |
 +----------------+-----------------+-----------------+-----------------------------+
+| Cavium         | ThunderX2 Core  | #219            | CAVIUM_TX2_ERRATUM_219      |
++----------------+-----------------+-----------------+-----------------------------+
 +----------------+-----------------+-----------------+-----------------------------+
 | Freescale/NXP  | LS2080A/LS1043A | A-008585        | FSL_ERRATUM_A008585         |
 +----------------+-----------------+-----------------+-----------------------------+

Documentation/core-api/index.rst+1−0

@@ -38,6 +38,7 @@ Core utilities · 37 unmodified lines
38	protection-keys	38	protection-keys
39	../RCU/index	39	../RCU/index
40	gcc-plugins	40	gcc-plugins
		41	symbol-namespaces
41		42
42		43
43	Interfaces for kernel debugging	44	Interfaces for kernel debugging

Documentation/core-api/memory-allocation.rst+4−0

@@ -98,6 +98,10 @@ limited. The actual limit depends on the hardware and the kernel · 97 unmodified lines
98	configuration, but it is a good practice to use `kmalloc` for objects	98	configuration, but it is a good practice to use `kmalloc` for objects
99	smaller than page size.	99	smaller than page size.
100		100
		101	The address of a chunk allocated with `kmalloc` is aligned to at least
		102	ARCH_KMALLOC_MINALIGN bytes. For sizes which are a power of two, the
		103	alignment is also guaranteed to be at least the respective size.
		104
101	For large allocations you can use :c:func:`vmalloc` and	105	For large allocations you can use :c:func:`vmalloc` and
102	:c:func:`vzalloc`, or directly request pages from the page	106	:c:func:`vzalloc`, or directly request pages from the page
103	allocator. The memory allocated by `vmalloc` and related functions is	107	allocator. The memory allocated by `vmalloc` and related functions is

Documentation/core-api/symbol-namespaces.rstrenamed from Documentation/kbuild/namespaces.rst+0−0

File renamed without changes.

Documentation/dev-tools/kasan.rst+3−0

@@ -41,6 +41,9 @@ smaller binary while the latter is 1.1 - 2 times faster. · 40 unmodified lines
41	Both KASAN modes work with both SLUB and SLAB memory allocators.	41	Both KASAN modes work with both SLUB and SLAB memory allocators.
42	For better bug detection and nicer reporting, enable CONFIG_STACKTRACE.	42	For better bug detection and nicer reporting, enable CONFIG_STACKTRACE.
43		43
		44	To augment reports with last allocation and freeing stack of the physical page,
		45	it is recommended to enable also CONFIG_PAGE_OWNER and boot with page_owner=on.
		46
44	To disable instrumentation for specific files or directories, add a line	47	To disable instrumentation for specific files or directories, add a line
45	similar to the following to the respective kernel Makefile:	48	similar to the following to the respective kernel Makefile:
46		49

Documentation/dev-tools/kselftest.rst+16−0

@@ -89,6 +89,22 @@ To build, save output files in a separate directory with KBUILD_OUTPUT :: · 88 unmodified lines
89		89
90	$ export KBUILD_OUTPUT=/tmp/kselftest; make TARGETS="size timers" kselftest	90	$ export KBUILD_OUTPUT=/tmp/kselftest; make TARGETS="size timers" kselftest
91		91
		92	Additionally you can use the "SKIP_TARGETS" variable on the make command
		93	line to specify one or more targets to exclude from the TARGETS list.
		94
		95	To run all tests but a single subsystem::
		96
		97	$ make -C tools/testing/selftests SKIP_TARGETS=ptrace run_tests
		98
		99	You can specify multiple tests to skip::
		100
		101	$ make SKIP_TARGETS="size timers" kselftest
		102
		103	You can also specify a restricted list of tests to run together with a
		104	dedicated skiplist::
		105
		106	$ make TARGETS="bpf breakpoints size timers" SKIP_TARGETS=bpf kselftest
		107
92	See the top-level tools/testing/selftests/Makefile for the list of all	108	See the top-level tools/testing/selftests/Makefile for the list of all
93	possible targets.	109	possible targets.
94		110

Documentation/devicetree/bindings/interrupt-controller/atmel,aic.txt+5−2

 * Advanced Interrupt Controller (AIC)
 Required properties:
-- compatible: Should be "atmel,<chip>-aic"
+- compatible: Should be:
-  <chip> can be "at91rm9200", "sama5d2", "sama5d3" or "sama5d4"
+    - "atmel,<chip>-aic" where  <chip> can be "at91rm9200", "sama5d2",
+      "sama5d3" or "sama5d4"
+    - "microchip,<chip>-aic" where <chip> can be "sam9x60"
 - interrupt-controller: Identifies the node as an interrupt controller.
 - #interrupt-cells: The number of cells to define the interrupts. It should be 3.
   The first cell is the IRQ number (aka "Peripheral IDentifier" on datasheet).

Documentation/devicetree/bindings/serial/renesas,sci-serial.txt+2−0

     - "renesas,hscif-r8a77470" for R8A77470 (RZ/G1C) HSCIF compatible UART.
     - "renesas,scif-r8a774a1" for R8A774A1 (RZ/G2M) SCIF compatible UART.
     - "renesas,hscif-r8a774a1" for R8A774A1 (RZ/G2M) HSCIF compatible UART.
+    - "renesas,scif-r8a774b1" for R8A774B1 (RZ/G2N) SCIF compatible UART.
+    - "renesas,hscif-r8a774b1" for R8A774B1 (RZ/G2N) HSCIF compatible UART.
     - "renesas,scif-r8a774c0" for R8A774C0 (RZ/G2E) SCIF compatible UART.
     - "renesas,hscif-r8a774c0" for R8A774C0 (RZ/G2E) HSCIF compatible UART.
     - "renesas,scif-r8a7778" for R8A7778 (R-Car M1) SCIF compatible UART.

Documentation/devicetree/bindings/usb/amlogic,dwc3.txt+2−2

@@ -85,8 +85,8 @@ A child node must exist to represent the core DWC2 IP block. The name of · 84 unmodified lines
85	the node is not important. The content of the node is defined in dwc2.txt.	85	the node is not important. The content of the node is defined in dwc2.txt.
86		86
87	PHY documentation is provided in the following places:	87	PHY documentation is provided in the following places:
88	- Documentation/devicetree/bindings/phy/meson-g12a-usb2-phy.txt	88	- Documentation/devicetree/bindings/phy/amlogic,meson-g12a-usb2-phy.yaml
89	- Documentation/devicetree/bindings/phy/meson-g12a-usb3-pcie-phy.txt	89	- Documentation/devicetree/bindings/phy/amlogic,meson-g12a-usb3-pcie-phy.yaml
90		90
91	Example device nodes:	91	Example device nodes:
92	usb: usb@ffe09000 {	92	usb: usb@ffe09000 {

Documentation/devicetree/bindings/usb/generic-ehci.yaml+6−1

     description:
       Set this flag to force EHCI reset after resume.
-  phys: true
+  phys:
+    description: PHY specifier for the USB PHY
+  phy-names:
+    const: usb
 required:
   - compatible
         interrupts = <39>;
         clocks = <&ahb_gates 1>;
         phys = <&usbphy 1>;
+        phy-names = "usb";
     };
 ...

Documentation/devicetree/bindings/usb/generic-ohci.yaml+6−1

     description:
       Overrides the detected port count
-  phys: true
+  phys:
+    description: PHY specifier for the USB PHY
+  phy-names:
+    const: usb
 required:
   - compatible
           interrupts = <64>;
           clocks = <&usb_clk 6>, <&ahb_gates 2>;
           phys = <&usbphy 1>;
+          phy-names = "usb";
       };
 ...

Documentation/devicetree/bindings/usb/mediatek,mtk-xhci.txt+2−2

@@ -33,7 +33,7 @@ Required properties: · 32 unmodified lines
33	"dma_ck": dma_bus clock for data transfer by DMA,	33	"dma_ck": dma_bus clock for data transfer by DMA,
34	"xhci_ck": controller clock	34	"xhci_ck": controller clock
35		35
36	- phys : see usb-hcd.txt in the current directory	36	- phys : see usb-hcd.yaml in the current directory
37		37
38	Optional properties:	38	Optional properties:
39	- wakeup-source : enable USB remote wakeup;	39	- wakeup-source : enable USB remote wakeup;
@@ -53,7 +53,7 @@ Optional properties: · 13 unmodified lines
53	See: Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt	53	See: Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt
54	- imod-interval-ns: default interrupt moderation interval is 5000ns	54	- imod-interval-ns: default interrupt moderation interval is 5000ns
55		55
56	additionally the properties from usb-hcd.txt (in the current directory) are	56	additionally the properties from usb-hcd.yaml (in the current directory) are
57	supported.	57	supported.
58		58
59	Example:	59	Example:

Documentation/devicetree/bindings/usb/mediatek,mtu3.txt+2−2

@@ -17,7 +17,7 @@ Required properties: · 16 unmodified lines
17	- clock-names : must contain "sys_ck" for clock of controller,	17	- clock-names : must contain "sys_ck" for clock of controller,
18	the following clocks are optional:	18	the following clocks are optional:
19	"ref_ck", "mcu_ck" and "dma_ck";	19	"ref_ck", "mcu_ck" and "dma_ck";
20	- phys : see usb-hcd.txt in the current directory	20	- phys : see usb-hcd.yaml in the current directory
21	- dr_mode : should be one of "host", "peripheral" or "otg",	21	- dr_mode : should be one of "host", "peripheral" or "otg",
22	refer to usb/generic.txt	22	refer to usb/generic.txt
23		23
@@ -60,7 +60,7 @@ Optional properties: · 36 unmodified lines
60	- mediatek,u3p-dis-msk : mask to disable u3ports, bit0 for u3port0,	60	- mediatek,u3p-dis-msk : mask to disable u3ports, bit0 for u3port0,
61	bit1 for u3port1, ... etc;	61	bit1 for u3port1, ... etc;
62		62
63	additionally the properties from usb-hcd.txt (in the current directory) are	63	additionally the properties from usb-hcd.yaml (in the current directory) are
64	supported.	64	supported.
65		65
66	Sub-nodes:	66	Sub-nodes:

Documentation/devicetree/bindings/usb/usb-hcd.yaml+5−0

     description:
       List of all the USB PHYs on this HCD
+  phy-names:
+    description:
+      Name specifier for the USB PHY
 examples:
   - |
     usb {
         phys = <&usb2_phy1>, <&usb3_phy1>;
+        phy-names = "usb";
     };

Documentation/devicetree/bindings/usb/usb-uhci.txt+1−1

@@ -6,7 +6,7 @@ Required properties: · 5 unmodified lines
6	- reg : Should contain 1 register ranges(address and length)	6	- reg : Should contain 1 register ranges(address and length)
7	- interrupts : UHCI controller interrupt	7	- interrupts : UHCI controller interrupt
8		8
9	additionally the properties from usb-hcd.txt (in the current directory) are	9	additionally the properties from usb-hcd.yaml (in the current directory) are
10	supported.	10	supported.
11		11
12	Example:	12	Example:

Documentation/devicetree/bindings/usb/usb-xhci.txt+2−2

@@ -41,9 +41,9 @@ Optional properties: · 40 unmodified lines
41	- usb3-lpm-capable: determines if platform is USB3 LPM capable	41	- usb3-lpm-capable: determines if platform is USB3 LPM capable
42	- quirk-broken-port-ped: set if the controller has broken port disable mechanism	42	- quirk-broken-port-ped: set if the controller has broken port disable mechanism
43	- imod-interval-ns: default interrupt moderation interval is 5000ns	43	- imod-interval-ns: default interrupt moderation interval is 5000ns
44	- phys : see usb-hcd.txt in the current directory	44	- phys : see usb-hcd.yaml in the current directory
45		45
46	additionally the properties from usb-hcd.txt (in the current directory) are	46	additionally the properties from usb-hcd.yaml (in the current directory) are
47	supported.	47	supported.
48		48
49		49

Documentation/hwmon/index.rst+1−0

@@ -7,6 +7,7 @@ Linux Hardware Monitoring · 6 unmodified lines
7		7
8	hwmon-kernel-api	8	hwmon-kernel-api
9	pmbus-core	9	pmbus-core
		10	inspur-ipsps1
10	submitting-patches	11	submitting-patches
11	sysfs-interface	12	sysfs-interface
12	userspace-tools	13	userspace-tools

Documentation/hwmon/inspur-ipsps1.rst+1−1

@@ -1,5 +1,5 @@
1	Kernel driver inspur-ipsps1	1	Kernel driver inspur-ipsps1
2	=======================	2	===========================
3		3
4	Supported chips:	4	Supported chips:
5		5

Documentation/hwmon/k10temp.rst+17−1

@@ -21,10 +21,17 @@ Supported chips: · 20 unmodified lines
21		21
22	* AMD Family 14h processors: "Brazos" (C/E/G/Z-Series)	22	* AMD Family 14h processors: "Brazos" (C/E/G/Z-Series)
23		23
24	* AMD Family 15h processors: "Bulldozer" (FX-Series), "Trinity", "Kaveri", "Carrizo"	24	* AMD Family 15h processors: "Bulldozer" (FX-Series), "Trinity", "Kaveri",
		25	"Carrizo", "Stoney Ridge", "Bristol Ridge"
25		26
26	* AMD Family 16h processors: "Kabini", "Mullins"	27	* AMD Family 16h processors: "Kabini", "Mullins"
27		28
		29	* AMD Family 17h processors: "Zen", "Zen 2"
		30
		31	* AMD Family 18h processors: "Hygon Dhyana"
		32
		33	* AMD Family 19h processors: "Zen 3"
		34
28	Prefix: 'k10temp'	35	Prefix: 'k10temp'
29		36
30	Addresses scanned: PCI space	37	Addresses scanned: PCI space
@@ -110,3 +117,12 @@ The maximum value for Tctl is available in the file temp1_max. · 79 unmodified lines
110	If the BIOS has enabled hardware temperature control, the threshold at	117	If the BIOS has enabled hardware temperature control, the threshold at
111	which the processor will throttle itself to avoid damage is available in	118	which the processor will throttle itself to avoid damage is available in
112	temp1_crit and temp1_crit_hyst.	119	temp1_crit and temp1_crit_hyst.
		120
		121	On some AMD CPUs, there is a difference between the die temperature (Tdie) and
		122	the reported temperature (Tctl). Tdie is the real measured temperature, and
		123	Tctl is used for fan control. While Tctl is always available as temp1_input,
		124	the driver exports Tdie temperature as temp2_input for those CPUs which support
		125	it.
		126
		127	Models from 17h family report relative temperature, the driver aims to
		128	compensate and report the real temperature.

Documentation/networking/device_drivers/pensando/ionic.rst+3−1

@@ -36,8 +36,10 @@ Support · 35 unmodified lines
36	=======	36	=======
37	For general Linux networking support, please use the netdev mailing	37	For general Linux networking support, please use the netdev mailing
38	list, which is monitored by Pensando personnel::	38	list, which is monitored by Pensando personnel::
		39
39	netdev@vger.kernel.org	40	netdev@vger.kernel.org
40		41
41	For more specific support needs, please use the Pensando driver support	42	For more specific support needs, please use the Pensando driver support
42	email::	43	email::
43	drivers@pensando.io	44
		45	drivers@pensando.io

Documentation/networking/net_dim.txt+18−18

@@ -92,16 +92,16 @@ under some conditions. · 91 unmodified lines
92	Part III: Registering a Network Device to DIM	92	Part III: Registering a Network Device to DIM
93	==============================================	93	==============================================
94		94
95	Net DIM API exposes the main function net_dim(struct net_dim *dim,	95	Net DIM API exposes the main function net_dim(struct dim *dim,
96	struct net_dim_sample end_sample). This function is the entry point to the Net	96	struct dim_sample end_sample). This function is the entry point to the Net
97	DIM algorithm and has to be called every time the driver would like to check if	97	DIM algorithm and has to be called every time the driver would like to check if
98	it should change interrupt moderation parameters. The driver should provide two	98	it should change interrupt moderation parameters. The driver should provide two
99	data structures: struct net_dim and struct net_dim_sample. Struct net_dim	99	data structures: struct dim and struct dim_sample. Struct dim
100	describes the state of DIM for a specific object (RX queue, TX queue,	100	describes the state of DIM for a specific object (RX queue, TX queue,
101	other queues, etc.). This includes the current selected profile, previous data	101	other queues, etc.). This includes the current selected profile, previous data
102	samples, the callback function provided by the driver and more.	102	samples, the callback function provided by the driver and more.
103	Struct net_dim_sample describes a data sample, which will be compared to the	103	Struct dim_sample describes a data sample, which will be compared to the
104	data sample stored in struct net_dim in order to decide on the algorithm's next	104	data sample stored in struct dim in order to decide on the algorithm's next
105	step. The sample should include bytes, packets and interrupts, measured by	105	step. The sample should include bytes, packets and interrupts, measured by
106	the driver.	106	the driver.
107		107
@@ -110,9 +110,9 @@ main net_dim() function. The recommended method is to call net_dim() on each · 2 unmodified lines
110	interrupt. Since Net DIM has a built-in moderation and it might decide to skip	110	interrupt. Since Net DIM has a built-in moderation and it might decide to skip
111	iterations under certain conditions, there is no need to moderate the net_dim()	111	iterations under certain conditions, there is no need to moderate the net_dim()
112	calls as well. As mentioned above, the driver needs to provide an object of type	112	calls as well. As mentioned above, the driver needs to provide an object of type
113	struct net_dim to the net_dim() function call. It is advised for each entity	113	struct dim to the net_dim() function call. It is advised for each entity
114	using Net DIM to hold a struct net_dim as part of its data structure and use it	114	using Net DIM to hold a struct dim as part of its data structure and use it
115	as the main Net DIM API object. The struct net_dim_sample should hold the latest	115	as the main Net DIM API object. The struct dim_sample should hold the latest
116	bytes, packets and interrupts count. No need to perform any calculations, just	116	bytes, packets and interrupts count. No need to perform any calculations, just
117	include the raw data.	117	include the raw data.
118		118
@@ -132,19 +132,19 @@ usage is not complete but it should make the outline of the usage clear. · 13 unmodified lines
132		132
133	my_driver.c:	133	my_driver.c:
134		134
135	#include <linux/net_dim.h>	135	#include <linux/dim.h>
136		136
137	/* Callback for net DIM to schedule on a decision to change moderation */	137	/* Callback for net DIM to schedule on a decision to change moderation */
138	void my_driver_do_dim_work(struct work_struct *work)	138	void my_driver_do_dim_work(struct work_struct *work)
139	{	139	{
140	/* Get struct net_dim from struct work_struct */	140	/* Get struct dim from struct work_struct */
141	struct net_dim *dim = container_of(work, struct net_dim,	141	struct dim *dim = container_of(work, struct dim,
142	work);	142	work);
143	/* Do interrupt moderation related stuff */	143	/* Do interrupt moderation related stuff */
144	...	144	...
145		145
146	/* Signal net DIM work is done and it should move to next iteration */	146	/* Signal net DIM work is done and it should move to next iteration */
147	dim->state = NET_DIM_START_MEASURE;	147	dim->state = DIM_START_MEASURE;
148	}	148	}
149		149
150	/* My driver's interrupt handler */	150	/* My driver's interrupt handler */
@@ -152,13 +152,13 @@ int my_driver_handle_interrupt(struct my_driver_entity *my_entity, ...) · 1 unmodified line
152	{	152	{
153	...	153	...
154	/* A struct to hold current measured data */	154	/* A struct to hold current measured data */
155	struct net_dim_sample dim_sample;	155	struct dim_sample dim_sample;
156	...	156	...
157	/* Initiate data sample struct with current data */	157	/* Initiate data sample struct with current data */
158	net_dim_sample(my_entity->events,	158	dim_update_sample(my_entity->events,
159	my_entity->packets,	159	my_entity->packets,
160	my_entity->bytes,	160	my_entity->bytes,
161	&dim_sample);	161	&dim_sample);
162	/* Call net DIM */	162	/* Call net DIM */
163	net_dim(&my_entity->dim, dim_sample);	163	net_dim(&my_entity->dim, dim_sample);
164	...	164	...

Documentation/process/coding-style.rst+1−1

@@ -56,7 +56,7 @@ instead of ``double-indenting`` the ``case`` labels. E.g.: · 55 unmodified lines
56	case 'K':	56	case 'K':
57	case 'k':	57	case 'k':
58	mem <<= 10;	58	mem <<= 10;
59	/* fall through */	59	fallthrough;
60	default:	60	default:
61	break;	61	break;
62	}	62	}

Documentation/process/deprecated.rst+23−10

@@ -122,14 +122,27 @@ memory adjacent to the stack (when built without `CONFIG_VMAP_STACK=y`) · 121 unmodified lines
122		122
123	Implicit switch case fall-through	123	Implicit switch case fall-through
124	---------------------------------	124	---------------------------------
125	The C language allows switch cases to "fall through" when	125	The C language allows switch cases to "fall-through" when a "break" statement
126	a "break" statement is missing at the end of a case. This,	126	is missing at the end of a case. This, however, introduces ambiguity in the
127	however, introduces ambiguity in the code, as it's not always	127	code, as it's not always clear if the missing break is intentional or a bug.
128	clear if the missing break is intentional or a bug. As there	128
129	have been a long list of flaws `due to missing "break" statements	129	As there have been a long list of flaws `due to missing "break" statements
130	<https://cwe.mitre.org/data/definitions/484.html>`_, we no longer allow	130	<https://cwe.mitre.org/data/definitions/484.html>`_, we no longer allow
131	"implicit fall-through". In order to identify an intentional fall-through	131	"implicit fall-through".
132	case, we have adopted the marking used by static analyzers: a comment	132
133	saying `/* Fall through */`. Once the C++17 `__attribute__((fallthrough))`	133	In order to identify intentional fall-through cases, we have adopted a
134	is more widely handled by C compilers, static analyzers, and IDEs, we can	134	pseudo-keyword macro 'fallthrough' which expands to gcc's extension
135	switch to using that instead.	135	__attribute__((__fallthrough__)). `Statement Attributes
		136	<https://gcc.gnu.org/onlinedocs/gcc/Statement-Attributes.html>`_
		137
		138	When the C17/C18 [[fallthrough]] syntax is more commonly supported by
		139	C compilers, static analyzers, and IDEs, we can switch to using that syntax
		140	for the macro pseudo-keyword.
		141
		142	All switch/case blocks must end in one of:
		143
		144	break;
		145	fallthrough;
		146	continue;
		147	goto <label>;
		148	return [expression];

Documentation/usb/rio.rst+0−109

@@ -1,109 +0,0 @@
1	============
2	Diamonds Rio
3	============
4
5	Copyright (C) 1999, 2000 Bruce Tenison
6
7	Portions Copyright (C) 1999, 2000 David Nelson
8
9	Thanks to David Nelson for guidance and the usage of the scanner.txt
10	and scanner.c files to model our driver and this informative file.
11
12	Mar. 2, 2000
13
14	Changes
15	=======
16
17	- Initial Revision
18
19
20	Overview
21	========
22
23	This README will address issues regarding how to configure the kernel
24	to access a RIO 500 mp3 player.
25	Before I explain how to use this to access the Rio500 please be warned:
26
27	.. warning::
28
29	Please note that this software is still under development. The authors
30	are in no way responsible for any damage that may occur, no matter how
31	inconsequential.
32
33	It seems that the Rio has a problem when sending .mp3 with low batteries.
34	I suggest when the batteries are low and you want to transfer stuff that you
35	replace it with a fresh one. In my case, what happened is I lost two 16kb
36	blocks (they are no longer usable to store information to it). But I don't
37	know if that's normal or not; it could simply be a problem with the flash
38	memory.
39
40	In an extreme case, I left my Rio playing overnight and the batteries wore
41	down to nothing and appear to have corrupted the flash memory. My RIO
42	needed to be replaced as a result. Diamond tech support is aware of the
43	problem. Do NOT allow your batteries to wear down to nothing before
44	changing them. It appears RIO 500 firmware does not handle low battery
45	power well at all.
46
47	On systems with OHCI controllers, the kernel OHCI code appears to have
48	power on problems with some chipsets. If you are having problems
49	connecting to your RIO 500, try turning it on first and then plugging it
50	into the USB cable.
51
52	Contact Information
53	-------------------
54
55	The main page for the project is hosted at sourceforge.net in the following
56	URL: <http://rio500.sourceforge.net>. You can also go to the project's
57	sourceforge home page at: <http://sourceforge.net/projects/rio500/>.
58	There is also a mailing list: rio500-users@lists.sourceforge.net
59
60	Authors
61	-------
62
63	Most of the code was written by Cesar Miquel <miquel@df.uba.ar>. Keith
64	Clayton <kclayton@jps.net> is incharge of the PPC port and making sure
65	things work there. Bruce Tenison <btenison@dibbs.net> is adding support
66	for .fon files and also does testing. The program will mostly sure be
67	re-written and Pete Ikusz along with the rest will re-design it. I would
68	also like to thank Tri Nguyen <tmn_3022000@hotmail.com> who provided use
69	with some important information regarding the communication with the Rio.
70
71	Additional Information and userspace tools
72
73	http://rio500.sourceforge.net/
74
75
76	Requirements
77	============
78
79	A host with a USB port running a Linux kernel with RIO 500 support enabled.
80
81	The driver is a module called rio500, which should be automatically loaded
82	as you plug in your device. If that fails you can manually load it with
83
84	modprobe rio500
85
86	Udev should automatically create a device node as soon as plug in your device.
87	If that fails, you can manually add a device for the USB rio500::
88
89	mknod /dev/usb/rio500 c 180 64
90
91	In that case, set appropriate permissions for /dev/usb/rio500 (don't forget
92	about group and world permissions). Both read and write permissions are
93	required for proper operation.
94
95	That's it. The Rio500 Utils at: http://rio500.sourceforge.net should
96	be able to access the rio500.
97
98	Limits
99	======
100
101	You can use only a single rio500 device at a time with your computer.
102
103	Bugs
104	====
105
106	If you encounter any problems feel free to drop me an email.
107
108	Bruce Tenison
109	btenison@dibbs.net

MAINTAINERS+9−15

@@ -2167,12 +2167,10 @@ F: arch/arm64/boot/dts/realtek/ · 2166 unmodified lines
2167	F: Documentation/devicetree/bindings/arm/realtek.yaml	2167	F: Documentation/devicetree/bindings/arm/realtek.yaml
2168		2168
2169	ARM/RENESAS ARM64 ARCHITECTURE	2169	ARM/RENESAS ARM64 ARCHITECTURE
2170	M: Simon Horman <horms@verge.net.au>
2171	M: Geert Uytterhoeven <geert+renesas@glider.be>	2170	M: Geert Uytterhoeven <geert+renesas@glider.be>
2172	M: Magnus Damm <magnus.damm@gmail.com>	2171	M: Magnus Damm <magnus.damm@gmail.com>
2173	L: linux-renesas-soc@vger.kernel.org	2172	L: linux-renesas-soc@vger.kernel.org
2174	Q: http://patchwork.kernel.org/project/linux-renesas-soc/list/	2173	Q: http://patchwork.kernel.org/project/linux-renesas-soc/list/
2175	T: git git://git.kernel.org/pub/scm/linux/kernel/git/horms/renesas.git next
2176	T: git git://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-devel.git next	2174	T: git git://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-devel.git next
2177	S: Supported	2175	S: Supported
2178	F: arch/arm64/boot/dts/renesas/	2176	F: arch/arm64/boot/dts/renesas/
@@ -2284,12 +2282,10 @@ S: Maintained · 105 unmodified lines
2284	F: drivers/media/platform/s5p-mfc/	2282	F: drivers/media/platform/s5p-mfc/
2285		2283
2286	ARM/SHMOBILE ARM ARCHITECTURE	2284	ARM/SHMOBILE ARM ARCHITECTURE
2287	M: Simon Horman <horms@verge.net.au>
2288	M: Geert Uytterhoeven <geert+renesas@glider.be>	2285	M: Geert Uytterhoeven <geert+renesas@glider.be>
2289	M: Magnus Damm <magnus.damm@gmail.com>	2286	M: Magnus Damm <magnus.damm@gmail.com>
2290	L: linux-renesas-soc@vger.kernel.org	2287	L: linux-renesas-soc@vger.kernel.org
2291	Q: http://patchwork.kernel.org/project/linux-renesas-soc/list/	2288	Q: http://patchwork.kernel.org/project/linux-renesas-soc/list/
2292	T: git git://git.kernel.org/pub/scm/linux/kernel/git/horms/renesas.git next
2293	T: git git://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-devel.git next	2289	T: git git://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-devel.git next
2294	S: Supported	2290	S: Supported
2295	F: arch/arm/boot/dts/emev2*	2291	F: arch/arm/boot/dts/emev2*
@@ -9138,7 +9134,7 @@ F: drivers/auxdisplay/ks0108.c · 6842 unmodified lines
9138	F: include/linux/ks0108.h	9134	F: include/linux/ks0108.h
9139		9135
9140	L3MDEV	9136	L3MDEV
9141	M: David Ahern <dsa@cumulusnetworks.com>	9137	M: David Ahern <dsahern@kernel.org>
9142	L: netdev@vger.kernel.org	9138	L: netdev@vger.kernel.org
9143	S: Maintained	9139	S: Maintained
9144	F: net/l3mdev	9140	F: net/l3mdev
@@ -9199,6 +9195,7 @@ M: Pavel Machek <pavel@ucw.cz> · 54 unmodified lines
9199	R: Dan Murphy <dmurphy@ti.com>	9195	R: Dan Murphy <dmurphy@ti.com>
9200	L: linux-leds@vger.kernel.org	9196	L: linux-leds@vger.kernel.org
9201	T: git git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds.git	9197	T: git git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds.git
		9198	T: git git://git.kernel.org/pub/scm/linux/kernel/git/pavel/linux-leds.git
9202	S: Maintained	9199	S: Maintained
9203	F: Documentation/devicetree/bindings/leds/	9200	F: Documentation/devicetree/bindings/leds/
9204	F: drivers/leds/	9201	F: drivers/leds/
@@ -10270,7 +10267,7 @@ MEDIATEK ETHERNET DRIVER · 1065 unmodified lines
10270	M: Felix Fietkau <nbd@openwrt.org>	10267	M: Felix Fietkau <nbd@openwrt.org>
10271	M: John Crispin <john@phrozen.org>	10268	M: John Crispin <john@phrozen.org>
10272	M: Sean Wang <sean.wang@mediatek.com>	10269	M: Sean Wang <sean.wang@mediatek.com>
10273	M: Nelson Chang <nelson.chang@mediatek.com>	10270	M: Mark Lee <Mark-MC.Lee@mediatek.com>
10274	L: netdev@vger.kernel.org	10271	L: netdev@vger.kernel.org
10275	S: Maintained	10272	S: Maintained
10276	F: drivers/net/ethernet/mediatek/	10273	F: drivers/net/ethernet/mediatek/
@@ -11559,6 +11556,7 @@ NSDEPS · 1282 unmodified lines
11559	M: Matthias Maennich <maennich@google.com>	11556	M: Matthias Maennich <maennich@google.com>
11560	S: Maintained	11557	S: Maintained
11561	F: scripts/nsdeps	11558	F: scripts/nsdeps
		11559	F: Documentation/core-api/symbol-namespaces.rst
11562		11560
11563	NTB AMD DRIVER	11561	NTB AMD DRIVER
11564	M: Shyam Sundar S K <Shyam-sundar.S-k@amd.com>	11562	M: Shyam Sundar S K <Shyam-sundar.S-k@amd.com>
@@ -12326,12 +12324,15 @@ F: arch/parisc/ · 761 unmodified lines
12326	F: Documentation/parisc/	12324	F: Documentation/parisc/
12327	F: drivers/parisc/	12325	F: drivers/parisc/
12328	F: drivers/char/agp/parisc-agp.c	12326	F: drivers/char/agp/parisc-agp.c
		12327	F: drivers/input/misc/hp_sdc_rtc.c
12329	F: drivers/input/serio/gscps2.c	12328	F: drivers/input/serio/gscps2.c
		12329	F: drivers/input/serio/hp_sdc*
12330	F: drivers/parport/parport_gsc.*	12330	F: drivers/parport/parport_gsc.*
12331	F: drivers/tty/serial/8250/8250_gsc.c	12331	F: drivers/tty/serial/8250/8250_gsc.c
12332	F: drivers/video/fbdev/sti*	12332	F: drivers/video/fbdev/sti*
12333	F: drivers/video/console/sti*	12333	F: drivers/video/console/sti*
12334	F: drivers/video/logo/logo_parisc*	12334	F: drivers/video/logo/logo_parisc*
		12335	F: include/linux/hp_sdc.h
12335		12336
12336	PARMAN	12337	PARMAN
12337	M: Jiri Pirko <jiri@mellanox.com>	12338	M: Jiri Pirko <jiri@mellanox.com>
@@ -13375,7 +13376,7 @@ S: Maintained · 1037 unmodified lines
13375	F: drivers/scsi/qla1280.[ch]	13376	F: drivers/scsi/qla1280.[ch]
13376		13377
13377	QLOGIC QLA2XXX FC-SCSI DRIVER	13378	QLOGIC QLA2XXX FC-SCSI DRIVER
13378	M: qla2xxx-upstream@qlogic.com	13379	M: hmadhani@marvell.com
13379	L: linux-scsi@vger.kernel.org	13380	L: linux-scsi@vger.kernel.org
13380	S: Supported	13381	S: Supported
13381	F: Documentation/scsi/LICENSE.qla2xxx	13382	F: Documentation/scsi/LICENSE.qla2xxx
@@ -16778,13 +16779,6 @@ W: http://www.linux-usb.org/usbnet · 3396 unmodified lines
16778	S: Maintained	16779	S: Maintained
16779	F: drivers/net/usb/dm9601.c	16780	F: drivers/net/usb/dm9601.c
16780		16781
16781	USB DIAMOND RIO500 DRIVER
16782	M: Cesar Miquel <miquel@df.uba.ar>
16783	L: rio500-users@lists.sourceforge.net
16784	W: http://rio500.sourceforge.net
16785	S: Maintained
16786	F: drivers/usb/misc/rio500*
16787
16788	USB EHCI DRIVER	16782	USB EHCI DRIVER
16789	M: Alan Stern <stern@rowland.harvard.edu>	16783	M: Alan Stern <stern@rowland.harvard.edu>
16790	L: linux-usb@vger.kernel.org	16784	L: linux-usb@vger.kernel.org
@@ -17451,7 +17445,7 @@ F: include/linux/regulator/ · 660 unmodified lines
17451	K: regulator_get_optional	17445	K: regulator_get_optional
17452		17446
17453	VRF	17447	VRF
17454	M: David Ahern <dsa@cumulusnetworks.com>	17448	M: David Ahern <dsahern@kernel.org>
17455	M: Shrijeet Mukherjee <shrijeet@gmail.com>	17449	M: Shrijeet Mukherjee <shrijeet@gmail.com>
17456	L: netdev@vger.kernel.org	17450	L: netdev@vger.kernel.org
17457	S: Maintained	17451	S: Maintained

Makefile+5−6

 VERSION = 5
 PATCHLEVEL = 4
 SUBLEVEL = 0
-EXTRAVERSION = -rc2
+EXTRAVERSION = -rc4
 NAME = Nesting Opossum
 # *DOCUMENTATION*
 # in addition to whatever we do anyway.
 # Just "make" or "make all" shall build modules as well
-ifneq ($(filter all _all modules,$(MAKECMDGOALS)),)
+ifneq ($(filter all _all modules nsdeps,$(MAKECMDGOALS)),)
   KBUILD_MODULES := 1
 endif
 export KBUILD_VMLINUX_LIBS := $(libs-y1)
 export KBUILD_LDS          := arch/$(SRCARCH)/kernel/vmlinux.lds
 export LDFLAGS_vmlinux
-# used by scripts/package/Makefile
+# used by scripts/Makefile.package
 export KBUILD_ALLDIRS := $(sort $(filter-out arch/%,$(vmlinux-alldirs)) LICENSES arch include scripts tools)
 vmlinux-deps := $(KBUILD_LDS) $(KBUILD_VMLINUX_OBJS) $(KBUILD_VMLINUX_LIBS)
 kselftest:
 	$(Q)$(MAKE) -C $(srctree)/tools/testing/selftests run_tests
-PHONY += kselftest-clean
+kselftest-%: FORCE
-kselftest-clean:
+	$(Q)$(MAKE) -C $(srctree)/tools/testing/selftests $*
-	$(Q)$(MAKE) -C $(srctree)/tools/testing/selftests clean
 PHONY += kselftest-merge
 kselftest-merge:

arch/arm/boot/dts/mt7629-rfb.dts+12−1

 	pinctrl-1 = <&ephy_leds_pins>;
 	status = "okay";
+	gmac0: mac@0 {
+		compatible = "mediatek,eth-mac";
+		reg = <0>;
+		phy-mode = "2500base-x";
+		fixed-link {
+			speed = <2500>;
+			full-duplex;
+			pause;
+		};
+	};
 	gmac1: mac@1 {
 		compatible = "mediatek,eth-mac";
 		reg = <1>;
+		phy-mode = "gmii";
 		phy-handle = <&phy0>;
 	};
 		phy0: ethernet-phy@0 {
 			reg = <0>;
-			phy-mode = "gmii";
 		};
 	};
 };

arch/arm/boot/dts/mt7629.dtsi+0−2

 			compatible = "mediatek,mt7629-sgmiisys", "syscon";
 			reg = <0x1b128000 0x3000>;
 			#clock-cells = <1>;
-			mediatek,physpeed = "2500";
 		};
 		sgmiisys1: syscon@1b130000 {
 			compatible = "mediatek,mt7629-sgmiisys", "syscon";
 			reg = <0x1b130000 0x3000>;
 			#clock-cells = <1>;
-			mediatek,physpeed = "2500";
 		};
 	};
 };

arch/arm/boot/dts/sun4i-a10.dtsi+4−0

 			interrupts = <39>;
 			clocks = <&ccu CLK_AHB_EHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <64>;
 			clocks = <&ccu CLK_USB_OHCI0>, <&ccu CLK_AHB_OHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <40>;
 			clocks = <&ccu CLK_AHB_EHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <65>;
 			clocks = <&ccu CLK_USB_OHCI1>, <&ccu CLK_AHB_OHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun5i.dtsi+2−0

 			interrupts = <39>;
 			clocks = <&ccu CLK_AHB_EHCI>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <40>;
 			clocks = <&ccu CLK_USB_OHCI>, <&ccu CLK_AHB_OHCI>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun6i-a31.dtsi+4−0

 			clocks = <&ccu CLK_AHB1_EHCI0>;
 			resets = <&ccu RST_AHB1_EHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_AHB1_OHCI0>, <&ccu CLK_USB_OHCI0>;
 			resets = <&ccu RST_AHB1_OHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_AHB1_EHCI1>;
 			resets = <&ccu RST_AHB1_EHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_AHB1_OHCI1>, <&ccu CLK_USB_OHCI1>;
 			resets = <&ccu RST_AHB1_OHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun7i-a20.dtsi+4−0

 			interrupts = <GIC_SPI 39 IRQ_TYPE_LEVEL_HIGH>;
 			clocks = <&ccu CLK_AHB_EHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <GIC_SPI 64 IRQ_TYPE_LEVEL_HIGH>;
 			clocks = <&ccu CLK_USB_OHCI0>, <&ccu CLK_AHB_OHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <GIC_SPI 40 IRQ_TYPE_LEVEL_HIGH>;
 			clocks = <&ccu CLK_AHB_EHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			interrupts = <GIC_SPI 65 IRQ_TYPE_LEVEL_HIGH>;
 			clocks = <&ccu CLK_USB_OHCI1>, <&ccu CLK_AHB_OHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun8i-a23-a33.dtsi+2−0

 			clocks = <&ccu CLK_BUS_EHCI>;
 			resets = <&ccu RST_BUS_EHCI>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_OHCI>, <&ccu CLK_USB_OHCI>;
 			resets = <&ccu RST_BUS_OHCI>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun8i-a83t.dtsi+3−0

 			clocks = <&ccu CLK_BUS_EHCI0>;
 			resets = <&ccu RST_BUS_EHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_OHCI0>, <&ccu CLK_USB_OHCI0>;
 			resets = <&ccu RST_BUS_OHCI0>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_EHCI1>;
 			resets = <&ccu RST_BUS_EHCI1>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun8i-r40.dtsi+4−0

 			clocks = <&ccu CLK_BUS_EHCI1>;
 			resets = <&ccu RST_BUS_EHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI1>;
 			resets = <&ccu RST_BUS_OHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_EHCI2>;
 			resets = <&ccu RST_BUS_EHCI2>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI2>;
 			resets = <&ccu RST_BUS_OHCI2>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sun9i-a80.dtsi+5−0

 			clocks = <&usb_clocks CLK_BUS_HCI0>;
 			resets = <&usb_clocks RST_USB0_HCI>;
 			phys = <&usbphy1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&usb_clocks CLK_USB_OHCI0>;
 			resets = <&usb_clocks RST_USB0_HCI>;
 			phys = <&usbphy1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&usb_clocks CLK_BUS_HCI1>;
 			resets = <&usb_clocks RST_USB1_HCI>;
 			phys = <&usbphy2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&usb_clocks CLK_BUS_HCI2>;
 			resets = <&usb_clocks RST_USB2_HCI>;
 			phys = <&usbphy3>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&usb_clocks CLK_USB_OHCI2>;
 			resets = <&usb_clocks RST_USB2_HCI>;
 			phys = <&usbphy3>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/boot/dts/sunxi-h3-h5.dtsi+6−0

 			clocks = <&ccu CLK_BUS_EHCI1>, <&ccu CLK_BUS_OHCI1>;
 			resets = <&ccu RST_BUS_EHCI1>, <&ccu RST_BUS_OHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI1>;
 			resets = <&ccu RST_BUS_EHCI1>, <&ccu RST_BUS_OHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_EHCI2>, <&ccu CLK_BUS_OHCI2>;
 			resets = <&ccu RST_BUS_EHCI2>, <&ccu RST_BUS_OHCI2>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI2>;
 			resets = <&ccu RST_BUS_EHCI2>, <&ccu RST_BUS_OHCI2>;
 			phys = <&usbphy 2>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 			clocks = <&ccu CLK_BUS_EHCI3>, <&ccu CLK_BUS_OHCI3>;
 			resets = <&ccu RST_BUS_EHCI3>, <&ccu RST_BUS_OHCI3>;
 			phys = <&usbphy 3>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI3>;
 			resets = <&ccu RST_BUS_EHCI3>, <&ccu RST_BUS_OHCI3>;
 			phys = <&usbphy 3>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm/configs/badge4_defconfig+0−1

@@ -91,7 +91,6 @@ CONFIG_USB_SERIAL_PL2303=m · 90 unmodified lines
91	CONFIG_USB_SERIAL_CYBERJACK=m	91	CONFIG_USB_SERIAL_CYBERJACK=m
92	CONFIG_USB_SERIAL_XIRCOM=m	92	CONFIG_USB_SERIAL_XIRCOM=m
93	CONFIG_USB_SERIAL_OMNINET=m	93	CONFIG_USB_SERIAL_OMNINET=m
94	CONFIG_USB_RIO500=m
95	CONFIG_EXT2_FS=m	94	CONFIG_EXT2_FS=m
96	CONFIG_EXT3_FS=m	95	CONFIG_EXT3_FS=m
97	CONFIG_MSDOS_FS=y	96	CONFIG_MSDOS_FS=y

arch/arm/configs/corgi_defconfig+0−1

@@ -195,7 +195,6 @@ CONFIG_USB_SERIAL_XIRCOM=m · 194 unmodified lines
195	CONFIG_USB_SERIAL_OMNINET=m	195	CONFIG_USB_SERIAL_OMNINET=m
196	CONFIG_USB_EMI62=m	196	CONFIG_USB_EMI62=m
197	CONFIG_USB_EMI26=m	197	CONFIG_USB_EMI26=m
198	CONFIG_USB_RIO500=m
199	CONFIG_USB_LEGOTOWER=m	198	CONFIG_USB_LEGOTOWER=m
200	CONFIG_USB_LCD=m	199	CONFIG_USB_LCD=m
201	CONFIG_USB_CYTHERM=m	200	CONFIG_USB_CYTHERM=m

arch/arm/configs/pxa_defconfig+0−1

@@ -581,7 +581,6 @@ CONFIG_USB_SERIAL_XIRCOM=m · 580 unmodified lines
581	CONFIG_USB_SERIAL_OMNINET=m	581	CONFIG_USB_SERIAL_OMNINET=m
582	CONFIG_USB_EMI62=m	582	CONFIG_USB_EMI62=m
583	CONFIG_USB_EMI26=m	583	CONFIG_USB_EMI26=m
584	CONFIG_USB_RIO500=m
585	CONFIG_USB_LEGOTOWER=m	584	CONFIG_USB_LEGOTOWER=m
586	CONFIG_USB_LCD=m	585	CONFIG_USB_LCD=m
587	CONFIG_USB_CYTHERM=m	586	CONFIG_USB_CYTHERM=m

arch/arm/configs/s3c2410_defconfig+0−1

@@ -327,7 +327,6 @@ CONFIG_USB_EMI62=m · 326 unmodified lines
327	CONFIG_USB_EMI26=m	327	CONFIG_USB_EMI26=m
328	CONFIG_USB_ADUTUX=m	328	CONFIG_USB_ADUTUX=m
329	CONFIG_USB_SEVSEG=m	329	CONFIG_USB_SEVSEG=m
330	CONFIG_USB_RIO500=m
331	CONFIG_USB_LEGOTOWER=m	330	CONFIG_USB_LEGOTOWER=m
332	CONFIG_USB_LCD=m	331	CONFIG_USB_LCD=m
333	CONFIG_USB_CYPRESS_CY7C63=m	332	CONFIG_USB_CYPRESS_CY7C63=m

arch/arm/configs/spitz_defconfig+0−1

@@ -189,7 +189,6 @@ CONFIG_USB_SERIAL_XIRCOM=m · 188 unmodified lines
189	CONFIG_USB_SERIAL_OMNINET=m	189	CONFIG_USB_SERIAL_OMNINET=m
190	CONFIG_USB_EMI62=m	190	CONFIG_USB_EMI62=m
191	CONFIG_USB_EMI26=m	191	CONFIG_USB_EMI26=m
192	CONFIG_USB_RIO500=m
193	CONFIG_USB_LEGOTOWER=m	192	CONFIG_USB_LEGOTOWER=m
194	CONFIG_USB_LCD=m	193	CONFIG_USB_LCD=m
195	CONFIG_USB_CYTHERM=m	194	CONFIG_USB_CYTHERM=m

arch/arm/crypto/Kconfig+1−0

@@ -98,6 +98,7 @@ config CRYPTO_AES_ARM_CE · 97 unmodified lines
98	tristate "Accelerated AES using ARMv8 Crypto Extensions"	98	tristate "Accelerated AES using ARMv8 Crypto Extensions"
99	depends on KERNEL_MODE_NEON	99	depends on KERNEL_MODE_NEON
100	select CRYPTO_BLKCIPHER	100	select CRYPTO_BLKCIPHER
		101	select CRYPTO_LIB_AES
101	select CRYPTO_SIMD	102	select CRYPTO_SIMD
102	help	103	help
103	Use an implementation of AES in CBC, CTR and XTS modes that uses	104	Use an implementation of AES in CBC, CTR and XTS modes that uses

arch/arm/crypto/aes-ce-core.S+1−0

@@ -9,6 +9,7 @@ · 8 unmodified lines
9	#include <asm/assembler.h>	9	#include <asm/assembler.h>
10		10
11	.text	11	.text
		12	.arch armv8-a
12	.fpu crypto-neon-fp-armv8	13	.fpu crypto-neon-fp-armv8
13	.align 3	14	.align 3
14		15

arch/arm64/Kconfig+30−2

@@ -110,7 +110,6 @@ config ARM64 · 109 unmodified lines
110	select GENERIC_STRNLEN_USER	110	select GENERIC_STRNLEN_USER
111	select GENERIC_TIME_VSYSCALL	111	select GENERIC_TIME_VSYSCALL
112	select GENERIC_GETTIMEOFDAY	112	select GENERIC_GETTIMEOFDAY
113	select GENERIC_COMPAT_VDSO if (!CPU_BIG_ENDIAN && COMPAT)
114	select HANDLE_DOMAIN_IRQ	113	select HANDLE_DOMAIN_IRQ
115	select HARDIRQS_SW_RESEND	114	select HARDIRQS_SW_RESEND
116	select HAVE_PCI	115	select HAVE_PCI
@@ -617,6 +616,23 @@ config CAVIUM_ERRATUM_30115 · 500 unmodified lines
617		616
618	If unsure, say Y.	617	If unsure, say Y.
619		618
		619	config CAVIUM_TX2_ERRATUM_219
		620	bool "Cavium ThunderX2 erratum 219: PRFM between TTBR change and ISB fails"
		621	default y
		622	help
		623	On Cavium ThunderX2, a load, store or prefetch instruction between a
		624	TTBR update and the corresponding context synchronizing operation can
		625	cause a spurious Data Abort to be delivered to any hardware thread in
		626	the CPU core.
		627
		628	Work around the issue by avoiding the problematic code sequence and
		629	trapping KVM guest TTBRx_EL1 writes to EL2 when SMT is enabled. The
		630	trap handler performs the corresponding register access, skips the
		631	instruction and ensures context synchronization by virtue of the
		632	exception return.
		633
		634	If unsure, say Y.
		635
620	config QCOM_FALKOR_ERRATUM_1003	636	config QCOM_FALKOR_ERRATUM_1003
621	bool "Falkor E1003: Incorrect translation due to ASID change"	637	bool "Falkor E1003: Incorrect translation due to ASID change"
622	default y	638	default y
@@ -1159,7 +1175,7 @@ menuconfig COMPAT · 536 unmodified lines
1159	if COMPAT	1175	if COMPAT
1160		1176
1161	config KUSER_HELPERS	1177	config KUSER_HELPERS
1162	bool "Enable kuser helpers page for 32 bit applications"	1178	bool "Enable kuser helpers page for 32-bit applications"
1163	default y	1179	default y
1164	help	1180	help
1165	Warning: disabling this option may break 32-bit user programs.	1181	Warning: disabling this option may break 32-bit user programs.
@@ -1185,6 +1201,18 @@ config KUSER_HELPERS · 19 unmodified lines
1185	Say N here only if you are absolutely certain that you do not	1201	Say N here only if you are absolutely certain that you do not
1186	need these helpers; otherwise, the safe option is to say Y.	1202	need these helpers; otherwise, the safe option is to say Y.
1187		1203
		1204	config COMPAT_VDSO
		1205	bool "Enable vDSO for 32-bit applications"
		1206	depends on !CPU_BIG_ENDIAN && "$(CROSS_COMPILE_COMPAT)" != ""
		1207	select GENERIC_COMPAT_VDSO
		1208	default y
		1209	help
		1210	Place in the process address space of 32-bit applications an
		1211	ELF shared object providing fast implementations of gettimeofday
		1212	and clock_gettime.
		1213
		1214	You must have a 32-bit build of glibc 2.22 or later for programs
		1215	to seamlessly take advantage of this.
1188		1216
1189	menuconfig ARMV8_DEPRECATED	1217	menuconfig ARMV8_DEPRECATED
1190	bool "Emulate deprecated/obsolete ARMv8 instructions"	1218	bool "Emulate deprecated/obsolete ARMv8 instructions"

arch/arm64/Makefile+0−16

@@ -53,22 +53,6 @@ $(warning Detected assembler with broken .inst; disassembly will be unreliable) · 52 unmodified lines
53	endif	53	endif
54	endif	54	endif
55		55
56	ifeq ($(CONFIG_GENERIC_COMPAT_VDSO), y)
57	CROSS_COMPILE_COMPAT ?= $(CONFIG_CROSS_COMPILE_COMPAT_VDSO:"%"=%)
58
59	ifeq ($(CONFIG_CC_IS_CLANG), y)
60	$(warning CROSS_COMPILE_COMPAT is clang, the compat vDSO will not be built)
61	else ifeq ($(strip $(CROSS_COMPILE_COMPAT)),)
62	$(warning CROSS_COMPILE_COMPAT not defined or empty, the compat vDSO will not be built)
63	else ifeq ($(shell which $(CROSS_COMPILE_COMPAT)gcc 2> /dev/null),)
64	$(error $(CROSS_COMPILE_COMPAT)gcc not found, check CROSS_COMPILE_COMPAT)
65	else
66	export CROSS_COMPILE_COMPAT
67	export CONFIG_COMPAT_VDSO := y
68	compat_vdso := -DCONFIG_COMPAT_VDSO=1
69	endif
70	endif
71
72	KBUILD_CFLAGS += -mgeneral-regs-only $(lseinstr) $(brokengasinst) \	56	KBUILD_CFLAGS += -mgeneral-regs-only $(lseinstr) $(brokengasinst) \
73	$(compat_vdso) $(cc_has_k_constraint)	57	$(compat_vdso) $(cc_has_k_constraint)
74	KBUILD_CFLAGS += -fno-asynchronous-unwind-tables	58	KBUILD_CFLAGS += -fno-asynchronous-unwind-tables

arch/arm64/boot/dts/allwinner/sun50i-a64-pinebook.dts+2−0

 &ehci0 {
 	phys = <&usbphy 0>;
+	phy-names = "usb";
 	status = "okay";
 };
 &ohci0 {
 	phys = <&usbphy 0>;
+	phy-names = "usb";
 	status = "okay";
 };

arch/arm64/boot/dts/allwinner/sun50i-a64.dtsi+2−0

 			resets = <&ccu RST_BUS_OHCI1>,
 				 <&ccu RST_BUS_EHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI1>;
 			resets = <&ccu RST_BUS_OHCI1>;
 			phys = <&usbphy 1>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm64/boot/dts/allwinner/sun50i-h6.dtsi+2−0

 			resets = <&ccu RST_BUS_OHCI3>,
 				 <&ccu RST_BUS_EHCI3>;
 			phys = <&usb2phy 3>;
+			phy-names = "usb";
 			status = "disabled";
 		};
 				 <&ccu CLK_USB_OHCI3>;
 			resets = <&ccu RST_BUS_OHCI3>;
 			phys = <&usb2phy 3>;
+			phy-names = "usb";
 			status = "disabled";
 		};

arch/arm64/include/asm/asm-uaccess.h+3−4

 /*
  * Remove the address tag from a virtual address, if present.
  */
-	.macro	clear_address_tag, dst, addr
+	.macro	untagged_addr, dst, addr
-	tst	\addr, #(1 << 55)
+	sbfx	\dst, \addr, #0, #56
-	bic	\dst, \addr, #(0xff << 56)
+	and	\dst, \dst, \addr
-	csel	\dst, \dst, \addr, eq
 	.endm
 #endif

arch/arm64/include/asm/atomic_lse.h+4−2

 }
 #define __CMPXCHG_CASE(w, sfx, name, sz, mb, cl...)			\
-static inline u##sz __lse__cmpxchg_case_##name##sz(volatile void *ptr,	\
+static __always_inline u##sz						\
+__lse__cmpxchg_case_##name##sz(volatile void *ptr,			\
 					      u##sz old,		\
 					      u##sz new)		\
 {									\
 #undef __CMPXCHG_CASE
 #define __CMPXCHG_DBL(name, mb, cl...)					\
-static inline long __lse__cmpxchg_double##name(unsigned long old1,	\
+static __always_inline long						\
+__lse__cmpxchg_double##name(unsigned long old1,				\
 					 unsigned long old2,		\
 					 unsigned long new1,		\
 					 unsigned long new2,		\

arch/arm64/include/asm/cpucaps.h+3−1

@@ -52,7 +52,9 @@ · 51 unmodified lines
52	#define ARM64_HAS_IRQ_PRIO_MASKING 42	52	#define ARM64_HAS_IRQ_PRIO_MASKING 42
53	#define ARM64_HAS_DCPODP 43	53	#define ARM64_HAS_DCPODP 43
54	#define ARM64_WORKAROUND_1463225 44	54	#define ARM64_WORKAROUND_1463225 44
		55	#define ARM64_WORKAROUND_CAVIUM_TX2_219_TVM 45
		56	#define ARM64_WORKAROUND_CAVIUM_TX2_219_PRFM 46
55		57
56	#define ARM64_NCAPS 45	58	#define ARM64_NCAPS 47
57		59
58	#endif /* __ASM_CPUCAPS_H */	60	#endif /* __ASM_CPUCAPS_H */

arch/arm64/include/asm/memory.h+8−2

  * up with a tagged userland pointer. Clear the tag to get a sane pointer to
  * pass on to access_ok(), for instance.
  */
-#define untagged_addr(addr)	\
+#define __untagged_addr(addr)	\
 	((__force __typeof__(addr))sign_extend64((__force u64)(addr), 55))
+#define untagged_addr(addr)	({					\
+	u64 __addr = (__force u64)addr;					\
+	__addr &= __untagged_addr(__addr);				\
+	(__force __typeof__(addr))__addr;				\
+})
 #ifdef CONFIG_KASAN_SW_TAGS
 #define __tag_shifted(tag)	((u64)(tag) << 56)
-#define __tag_reset(addr)	untagged_addr(addr)
+#define __tag_reset(addr)	__untagged_addr(addr)
 #define __tag_get(addr)		(__u8)((u64)(addr) >> 56)
 #else
 #define __tag_shifted(tag)	0UL

arch/arm64/include/asm/pgtable.h+0−3

@@ -876,9 +876,6 @@ static inline void update_mmu_cache(struct vm_area_struct *vma, · 875 unmodified lines
876		876
877	#define update_mmu_cache_pmd(vma, address, pmd) do { } while (0)	877	#define update_mmu_cache_pmd(vma, address, pmd) do { } while (0)
878		878
879	#define kc_vaddr_to_offset(v) ((v) & ~PAGE_END)
880	#define kc_offset_to_vaddr(o) ((o) \| PAGE_END)
881
882	#ifdef CONFIG_ARM64_PA_BITS_52	879	#ifdef CONFIG_ARM64_PA_BITS_52
883	#define phys_to_ttbr(addr) (((addr) \| ((addr) >> 46)) & TTBR_BADDR_MASK_52)	880	#define phys_to_ttbr(addr) (((addr) \| ((addr) >> 46)) & TTBR_BADDR_MASK_52)
884	#else	881	#else

arch/arm64/include/asm/sysreg.h+1−1

@@ -212,7 +212,7 @@ · 211 unmodified lines
212	#define SYS_FAR_EL1 sys_reg(3, 0, 6, 0, 0)	212	#define SYS_FAR_EL1 sys_reg(3, 0, 6, 0, 0)
213	#define SYS_PAR_EL1 sys_reg(3, 0, 7, 4, 0)	213	#define SYS_PAR_EL1 sys_reg(3, 0, 7, 4, 0)
214		214
215	#define SYS_PAR_EL1_F BIT(1)	215	#define SYS_PAR_EL1_F BIT(0)
216	#define SYS_PAR_EL1_FST GENMASK(6, 1)	216	#define SYS_PAR_EL1_FST GENMASK(6, 1)
217		217
218	/* Statistical Profiling Extension */	218	/* Statistical Profiling Extension */

arch/arm64/include/asm/vdso/compat_barrier.h+1−1

@@ -20,7 +20,7 @@ · 19 unmodified lines
20		20
21	#define dmb(option) __asm__ __volatile__ ("dmb " #option : : : "memory")	21	#define dmb(option) __asm__ __volatile__ ("dmb " #option : : : "memory")
22		22
23	#if __LINUX_ARM_ARCH__ >= 8	23	#if __LINUX_ARM_ARCH__ >= 8 && defined(CONFIG_AS_DMB_ISHLD)
24	#define aarch32_smp_mb() dmb(ish)	24	#define aarch32_smp_mb() dmb(ish)
25	#define aarch32_smp_rmb() dmb(ishld)	25	#define aarch32_smp_rmb() dmb(ishld)
26	#define aarch32_smp_wmb() dmb(ishst)	26	#define aarch32_smp_wmb() dmb(ishst)

arch/arm64/include/asm/vdso_datapage.h+0−33

@@ -1,33 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0-only */
2	/*
3	* Copyright (C) 2012 ARM Limited
4	*/
5	#ifndef __ASM_VDSO_DATAPAGE_H
6	#define __ASM_VDSO_DATAPAGE_H
7
8	#ifndef __ASSEMBLY__
9
10	struct vdso_data {
11	__u64 cs_cycle_last; /* Timebase at clocksource init */
12	__u64 raw_time_sec; /* Raw time */
13	__u64 raw_time_nsec;
14	__u64 xtime_clock_sec; /* Kernel time */
15	__u64 xtime_clock_nsec;
16	__u64 xtime_coarse_sec; /* Coarse time */
17	__u64 xtime_coarse_nsec;
18	__u64 wtm_clock_sec; /* Wall to monotonic time */
19	__u64 wtm_clock_nsec;
20	__u32 tb_seq_count; /* Timebase sequence counter */
21	/* cs_* members must be adjacent and in this order (ldp accesses) */
22	__u32 cs_mono_mult; /* NTP-adjusted clocksource multiplier */
23	__u32 cs_shift; /* Clocksource shift (mono = raw) */
24	__u32 cs_raw_mult; /* Raw clocksource multiplier */
25	__u32 tz_minuteswest; /* Whacky timezone stuff */
26	__u32 tz_dsttime;
27	__u32 use_syscall;
28	__u32 hrtimer_res;
29	};
30
31	#endif /* !__ASSEMBLY__ */
32
33	#endif /* __ASM_VDSO_DATAPAGE_H */

arch/arm64/kernel/armv8_deprecated.c+5−0

 	struct insn_emulation *insn;
 	insn = kzalloc(sizeof(*insn), GFP_KERNEL);
+	if (!insn)
+		return;
 	insn->ops = ops;
 	insn->min = INSN_UNDEF;
 	insns_sysctl = kcalloc(nr_insn_emulated + 1, sizeof(*sysctl),
 			       GFP_KERNEL);
+	if (!insns_sysctl)
+		return;
 	raw_spin_lock_irqsave(&insn_emulation_lock, flags);
 	list_for_each_entry(insn, &insn_emulation, node) {

arch/arm64/kernel/cpu_errata.c+40−2

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <asm/cpu.h>	12	#include <asm/cpu.h>
13	#include <asm/cputype.h>	13	#include <asm/cputype.h>
14	#include <asm/cpufeature.h>	14	#include <asm/cpufeature.h>
		15	#include <asm/smp_plat.h>
15		16
16	static bool __maybe_unused	17	static bool __maybe_unused
17	is_affected_midr_range(const struct arm64_cpu_capabilities *entry, int scope)	18	is_affected_midr_range(const struct arm64_cpu_capabilities *entry, int scope)
@@ -128,8 +129,8 @@ static void install_bp_hardening_cb(bp_hardening_cb_t fn, · 110 unmodified lines
128	int cpu, slot = -1;	129	int cpu, slot = -1;
129		130
130	/*	131	/*
131	* enable_smccc_arch_workaround_1() passes NULL for the hyp_vecs	132	* detect_harden_bp_fw() passes NULL for the hyp_vecs start/end if
132	* start/end if we're a guest. Skip the hyp-vectors work.	133	* we're a guest. Skip the hyp-vectors work.
133	*/	134	*/
134	if (!hyp_vecs_start) {	135	if (!hyp_vecs_start) {
135	__this_cpu_write(bp_hardening_data.fn, fn);	136	__this_cpu_write(bp_hardening_data.fn, fn);
@@ -623,6 +624,30 @@ check_branch_predictor(const struct arm64_cpu_capabilities *entry, int scope) · 487 unmodified lines
623	return (need_wa > 0);	624	return (need_wa > 0);
624	}	625	}
625		626
		627	static const __maybe_unused struct midr_range tx2_family_cpus[] = {
		628	MIDR_ALL_VERSIONS(MIDR_BRCM_VULCAN),
		629	MIDR_ALL_VERSIONS(MIDR_CAVIUM_THUNDERX2),
		630	{},
		631	};
		632
		633	static bool __maybe_unused
		634	needs_tx2_tvm_workaround(const struct arm64_cpu_capabilities *entry,
		635	int scope)
		636	{
		637	int i;
		638
		639	if (!is_affected_midr_range_list(entry, scope) \|\|
		640	!is_hyp_mode_available())
		641	return false;
		642
		643	for_each_possible_cpu(i) {
		644	if (MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 0) != 0)
		645	return true;
		646	}
		647
		648	return false;
		649	}
		650
626	#ifdef CONFIG_HARDEN_EL2_VECTORS	651	#ifdef CONFIG_HARDEN_EL2_VECTORS
627		652
628	static const struct midr_range arm64_harden_el2_vectors[] = {	653	static const struct midr_range arm64_harden_el2_vectors[] = {
@@ -851,6 +876,19 @@ const struct arm64_cpu_capabilities arm64_errata[] = { · 222 unmodified lines
851	.type = ARM64_CPUCAP_LOCAL_CPU_ERRATUM,	876	.type = ARM64_CPUCAP_LOCAL_CPU_ERRATUM,
852	.matches = has_cortex_a76_erratum_1463225,	877	.matches = has_cortex_a76_erratum_1463225,
853	},	878	},
		879	#endif
		880	#ifdef CONFIG_CAVIUM_TX2_ERRATUM_219
		881	{
		882	.desc = "Cavium ThunderX2 erratum 219 (KVM guest sysreg trapping)",
		883	.capability = ARM64_WORKAROUND_CAVIUM_TX2_219_TVM,
		884	ERRATA_MIDR_RANGE_LIST(tx2_family_cpus),
		885	.matches = needs_tx2_tvm_workaround,
		886	},
		887	{
		888	.desc = "Cavium ThunderX2 erratum 219 (PRFM removal)",
		889	.capability = ARM64_WORKAROUND_CAVIUM_TX2_219_PRFM,
		890	ERRATA_MIDR_RANGE_LIST(tx2_family_cpus),
		891	},
854	#endif	892	#endif
855	{	893	{
856	}	894	}

arch/arm64/kernel/cpufeature.c+11−5

 static const struct arm64_ftr_bits ftr_id_aa64isar1[] = {
 	ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ISAR1_SB_SHIFT, 4, 0),
+	ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ISAR1_FRINTTS_SHIFT, 4, 0),
 	ARM64_FTR_BITS(FTR_VISIBLE_IF_IS_ENABLED(CONFIG_ARM64_PTR_AUTH),
 		       FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ISAR1_GPI_SHIFT, 4, 0),
 	ARM64_FTR_BITS(FTR_VISIBLE_IF_IS_ENABLED(CONFIG_ARM64_PTR_AUTH),
 };
 static const struct arm64_ftr_bits ftr_id_aa64zfr0[] = {
-	ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ZFR0_SM4_SHIFT, 4, 0),
+	ARM64_FTR_BITS(FTR_VISIBLE_IF_IS_ENABLED(CONFIG_ARM64_SVE),
-	ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ZFR0_SHA3_SHIFT, 4, 0),
+		       FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ZFR0_SM4_SHIFT, 4, 0),
-	ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ZFR0_BITPERM_SHIFT, 4, 0),
+	ARM64_FTR_BITS(FTR_VISIBLE_IF_IS_ENABLED(CONFIG_ARM64_SVE),
-	ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ZFR0_AES_SHIFT, 4, 0),
+		       FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ZFR0_SHA3_SHIFT, 4, 0),
-	ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ZFR0_SVEVER_SHIFT, 4, 0),
+	ARM64_FTR_BITS(FTR_VISIBLE_IF_IS_ENABLED(CONFIG_ARM64_SVE),
+		       FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ZFR0_BITPERM_SHIFT, 4, 0),
+	ARM64_FTR_BITS(FTR_VISIBLE_IF_IS_ENABLED(CONFIG_ARM64_SVE),
+		       FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ZFR0_AES_SHIFT, 4, 0),
+	ARM64_FTR_BITS(FTR_VISIBLE_IF_IS_ENABLED(CONFIG_ARM64_SVE),
+		       FTR_STRICT, FTR_LOWER_SAFE, ID_AA64ZFR0_SVEVER_SHIFT, 4, 0),
 	ARM64_FTR_END,
 };

arch/arm64/kernel/entry.S+6−3

 	 */
 	mrs	x3, far_el1
 	inherit_daif	pstate=x23, tmp=x2
-	clear_address_tag x0, x3
+	untagged_addr	x0, x3
 	mov	x2, sp				// struct pt_regs
 	bl	do_mem_abort
 	orr	x24, x24, x0
 alternative_else_nop_endif
 	cbnz	x24, 1f				// preempt count != 0 || NMI return path
-	bl	preempt_schedule_irq		// irq en/disable is done inside
+	bl	arm64_preempt_schedule_irq	// irq en/disable is done inside
 1:
 #endif
 	b.ge	el0_dbg
 	b	el0_inv
 el0_svc_compat:
+	gic_prio_kentry_setup tmp=x1
 	mov	x0, sp
 	bl	el0_svc_compat_handler
 	b	ret_to_user
 	mrs	x26, far_el1
 	ct_user_exit_irqoff
 	enable_daif
-	clear_address_tag x0, x26
+	untagged_addr	x0, x26
 	mov	x1, x25
 	mov	x2, sp
 	bl	do_mem_abort
 #else
 	ldr	x30, =vectors
 #endif
+alternative_if_not ARM64_WORKAROUND_CAVIUM_TX2_219_PRFM
 	prfm	plil1strm, [x30, #(1b - tramp_vectors)]
+alternative_else_nop_endif
 	msr	vbar_el1, x30
 	add	x30, x30, #(1b - tramp_vectors)
 	isb

arch/arm64/kernel/ftrace.c+9−3

 			/*
 			 * Ensure updated trampoline is visible to instruction
-			 * fetch before we patch in the branch.
+			 * fetch before we patch in the branch. Although the
+			 * architecture doesn't require an IPI in this case,
+			 * Neoverse-N1 erratum #1542419 does require one
+			 * if the TLB maintenance in module_enable_ro() is
+			 * skipped due to rodata_enabled. It doesn't seem worth
+			 * it to make it conditional given that this is
+			 * certainly not a fast-path.
 			 */
-			__flush_icache_range((unsigned long)&dst[0],
+			flush_icache_range((unsigned long)&dst[0],
-					     (unsigned long)&dst[1]);
+					   (unsigned long)&dst[1]);
 		}
 		addr = (unsigned long)dst;
 #else /* CONFIG_ARM64_MODULE_PLTS */

arch/arm64/kernel/hibernate.c+8−1

 				 gfp_t mask)
 {
 	int rc = 0;
+	pgd_t *trans_pgd;
 	pgd_t *pgdp;
 	pud_t *pudp;
 	pmd_t *pmdp;
 	memcpy((void *)dst, src_start, length);
 	__flush_icache_range(dst, dst + length);
-	pgdp = pgd_offset_raw(allocator(mask), dst_addr);
+	trans_pgd = allocator(mask);
+	if (!trans_pgd) {
+		rc = -ENOMEM;
+		goto out;
+	}
+	pgdp = pgd_offset_raw(trans_pgd, dst_addr);
 	if (pgd_none(READ_ONCE(*pgdp))) {
 		pudp = allocator(mask);
 		if (!pudp) {

arch/arm64/kernel/process.c+33−17

 #include <linux/sched/task.h>
 #include <linux/sched/task_stack.h>
 #include <linux/kernel.h>
+#include <linux/lockdep.h>
 #include <linux/mm.h>
 #include <linux/stddef.h>
 #include <linux/sysctl.h>
 #include <asm/alternative.h>
 #include <asm/arch_gicv3.h>
 #include <asm/compat.h>
+#include <asm/cpufeature.h>
 #include <asm/cacheflush.h>
 #include <asm/exec.h>
 #include <asm/fpsimd.h>
 	fpsimd_release_task(tsk);
 }
-/*
- * src and dst may temporarily have aliased sve_state after task_struct
- * is copied.  We cannot fix this properly here, because src may have
- * live SVE state and dst's thread_info may not exist yet, so tweaking
- * either src's or dst's TIF_SVE is not safe.
- *
- * The unaliasing is done in copy_thread() instead.  This works because
- * dst is not schedulable or traceable until both of these functions
- * have been called.
- */
 int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
 {
 	if (current->mm)
 		fpsimd_preserve_current_state();
 	*dst = *src;
+	/* We rely on the above assignment to initialize dst's thread_flags: */
+	BUILD_BUG_ON(!IS_ENABLED(CONFIG_THREAD_INFO_IN_TASK));
+	/*
+	 * Detach src's sve_state (if any) from dst so that it does not
+	 * get erroneously used or freed prematurely.  dst's sve_state
+	 * will be allocated on demand later on if dst uses SVE.
+	 * For consistency, also clear TIF_SVE here: this could be done
+	 * later in copy_process(), but to avoid tripping up future
+	 * maintainers it is best not to leave TIF_SVE and sve_state in
+	 * an inconsistent state, even temporarily.
+	 */
+	dst->thread.sve_state = NULL;
+	clear_tsk_thread_flag(dst, TIF_SVE);
 	return 0;
 }
 	memset(&p->thread.cpu_context, 0, sizeof(struct cpu_context));
-	/*
-	 * Unalias p->thread.sve_state (if any) from the parent task
-	 * and disable discard SVE state for p:
-	 */
-	clear_tsk_thread_flag(p, TIF_SVE);
-	p->thread.sve_state = NULL;
 	/*
 	 * In case p was allocated the same task_struct pointer as some
 	 * other recently-exited task, make sure p is disassociated from
 core_initcall(tagged_addr_init);
 #endif	/* CONFIG_ARM64_TAGGED_ADDR_ABI */
+asmlinkage void __sched arm64_preempt_schedule_irq(void)
+{
+	lockdep_assert_irqs_disabled();
+	/*
+	 * Preempting a task from an IRQ means we leave copies of PSTATE
+	 * on the stack. cpufeature's enable calls may modify PSTATE, but
+	 * resuming one of these preempted tasks would undo those changes.
+	 *
+	 * Only allow a task to be preempted once cpufeatures have been
+	 * enabled.
+	 */
+	if (static_branch_likely(&arm64_const_caps_ready))
+		preempt_schedule_irq();
+}

arch/arm64/kernel/vdso32/Makefile+28−16

 ARCH_REL_TYPE_ABS := R_ARM_JUMP_SLOT|R_ARM_GLOB_DAT|R_ARM_ABS32
 include $(srctree)/lib/vdso/Makefile
-COMPATCC := $(CROSS_COMPILE_COMPAT)gcc
+# Same as cc-*option, but using CC_COMPAT instead of CC
+ifeq ($(CONFIG_CC_IS_CLANG), y)
+CC_COMPAT ?= $(CC)
+else
+CC_COMPAT ?= $(CROSS_COMPILE_COMPAT)gcc
+endif
-# Same as cc-*option, but using COMPATCC instead of CC
 cc32-option = $(call try-run,\
-        $(COMPATCC) $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))
+        $(CC_COMPAT) $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))
 cc32-disable-warning = $(call try-run,\
-	$(COMPATCC) -W$(strip $(1)) -c -x c /dev/null -o "$$TMP",-Wno-$(strip $(1)))
+	$(CC_COMPAT) -W$(strip $(1)) -c -x c /dev/null -o "$$TMP",-Wno-$(strip $(1)))
 cc32-ldoption = $(call try-run,\
-        $(COMPATCC) $(1) -nostdlib -x c /dev/null -o "$$TMP",$(1),$(2))
+        $(CC_COMPAT) $(1) -nostdlib -x c /dev/null -o "$$TMP",$(1),$(2))
+cc32-as-instr = $(call try-run,\
+	printf "%b\n" "$(1)" | $(CC_COMPAT) $(VDSO_AFLAGS) -c -x assembler -o "$$TMP" -,$(2),$(3))
 # We cannot use the global flags to compile the vDSO files, the main reason
 # being that the 32-bit compiler may be older than the main (64-bit) compiler
 # arm64 one.
 # As a result we set our own flags here.
-# From top-level Makefile
+# KBUILD_CPPFLAGS and NOSTDINC_FLAGS from top-level Makefile
-# NOSTDINC_FLAGS
+VDSO_CPPFLAGS := -D__KERNEL__ -nostdinc -isystem $(shell $(CC_COMPAT) -print-file-name=include)
-VDSO_CPPFLAGS := -nostdinc -isystem $(shell $(COMPATCC) -print-file-name=include)
 VDSO_CPPFLAGS += $(LINUXINCLUDE)
-VDSO_CPPFLAGS += $(KBUILD_CPPFLAGS)
 # Common C and assembly flags
 # From top-level Makefile
 VDSO_CAFLAGS := $(VDSO_CPPFLAGS)
+ifneq ($(shell $(CC_COMPAT) --version 2>&1 | head -n 1 | grep clang),)
+VDSO_CAFLAGS += --target=$(notdir $(CROSS_COMPILE_COMPAT:%-=%))
+endif
 VDSO_CAFLAGS += $(call cc32-option,-fno-PIE)
 ifdef CONFIG_DEBUG_INFO
 VDSO_CAFLAGS += -g
 endif
-ifeq ($(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-goto.sh $(COMPATCC)), y)
-VDSO_CAFLAGS += -DCC_HAVE_ASM_GOTO
-endif
 # From arm Makefile
 VDSO_CAFLAGS += $(call cc32-option,-fno-dwarf2-cfi-asm)
 VDSO_CAFLAGS += -fPIC -fno-builtin -fno-stack-protector
 VDSO_CAFLAGS += -DDISABLE_BRANCH_PROFILING
 # Try to compile for ARMv8. If the compiler is too old and doesn't support it,
 # fall back to v7. There is no easy way to check for what architecture the code
 # is being compiled, so define a macro specifying that (see arch/arm/Makefile).
 VDSO_AFLAGS := $(VDSO_CAFLAGS)
 VDSO_AFLAGS += -D__ASSEMBLY__
+# Check for binutils support for dmb ishld
+dmbinstr := $(call cc32-as-instr,dmb ishld,-DCONFIG_AS_DMB_ISHLD=1)
+VDSO_CFLAGS += $(dmbinstr)
+VDSO_AFLAGS += $(dmbinstr)
 VDSO_LDFLAGS := $(VDSO_CPPFLAGS)
 # From arm vDSO Makefile
 VDSO_LDFLAGS += -Wl,-Bsymbolic -Wl,--no-undefined -Wl,-soname=linux-vdso.so.1
       cmd_vdsold_and_vdso_check = $(cmd_vdsold); $(cmd_vdso_check)
 quiet_cmd_vdsold = LD32    $@
-      cmd_vdsold = $(COMPATCC) -Wp,-MD,$(depfile) $(VDSO_LDFLAGS) \
+      cmd_vdsold = $(CC_COMPAT) -Wp,-MD,$(depfile) $(VDSO_LDFLAGS) \
                    -Wl,-T $(filter %.lds,$^) $(filter %.o,$^) -o $@
 quiet_cmd_vdsocc = CC32    $@
-      cmd_vdsocc = $(COMPATCC) -Wp,-MD,$(depfile) $(VDSO_CFLAGS) -c -o $@ $<
+      cmd_vdsocc = $(CC_COMPAT) -Wp,-MD,$(depfile) $(VDSO_CFLAGS) -c -o $@ $<
 quiet_cmd_vdsocc_gettimeofday = CC32    $@
-      cmd_vdsocc_gettimeofday = $(COMPATCC) -Wp,-MD,$(depfile) $(VDSO_CFLAGS) $(VDSO_CFLAGS_gettimeofday_o) -c -o $@ $<
+      cmd_vdsocc_gettimeofday = $(CC_COMPAT) -Wp,-MD,$(depfile) $(VDSO_CFLAGS) $(VDSO_CFLAGS_gettimeofday_o) -c -o $@ $<
 quiet_cmd_vdsoas = AS32    $@
-      cmd_vdsoas = $(COMPATCC) -Wp,-MD,$(depfile) $(VDSO_AFLAGS) -c -o $@ $<
+      cmd_vdsoas = $(CC_COMPAT) -Wp,-MD,$(depfile) $(VDSO_AFLAGS) -c -o $@ $<
 quiet_cmd_vdsomunge = MUNGE   $@
       cmd_vdsomunge = $(obj)/$(munge) $< $@

arch/arm64/kvm/hyp/switch.c+67−2

@@ -124,6 +124,9 @@ static void __hyp_text __activate_traps(struct kvm_vcpu *vcpu) · 123 unmodified lines
124	{	124	{
125	u64 hcr = vcpu->arch.hcr_el2;	125	u64 hcr = vcpu->arch.hcr_el2;
126		126
		127	if (cpus_have_const_cap(ARM64_WORKAROUND_CAVIUM_TX2_219_TVM))
		128	hcr \|= HCR_TVM;
		129
127	write_sysreg(hcr, hcr_el2);	130	write_sysreg(hcr, hcr_el2);
128		131
129	if (cpus_have_const_cap(ARM64_HAS_RAS_EXTN) && (hcr & HCR_VSE))	132	if (cpus_have_const_cap(ARM64_HAS_RAS_EXTN) && (hcr & HCR_VSE))
@@ -174,8 +177,10 @@ static void __hyp_text __deactivate_traps(struct kvm_vcpu *vcpu) · 44 unmodified lines
174	* the crucial bit is "On taking a vSError interrupt,	177	* the crucial bit is "On taking a vSError interrupt,
175	* HCR_EL2.VSE is cleared to 0."	178	* HCR_EL2.VSE is cleared to 0."
176	*/	179	*/
177	if (vcpu->arch.hcr_el2 & HCR_VSE)	180	if (vcpu->arch.hcr_el2 & HCR_VSE) {
178	vcpu->arch.hcr_el2 = read_sysreg(hcr_el2);	181	vcpu->arch.hcr_el2 &= ~HCR_VSE;
		182	vcpu->arch.hcr_el2 \|= read_sysreg(hcr_el2) & HCR_VSE;
		183	}
179		184
180	if (has_vhe())	185	if (has_vhe())
181	deactivate_traps_vhe();	186	deactivate_traps_vhe();
@@ -380,6 +385,61 @@ static bool __hyp_text __hyp_handle_fpsimd(struct kvm_vcpu *vcpu) · 198 unmodified lines
380	return true;	385	return true;
381	}	386	}
382		387
		388	static bool __hyp_text handle_tx2_tvm(struct kvm_vcpu *vcpu)
		389	{
		390	u32 sysreg = esr_sys64_to_sysreg(kvm_vcpu_get_hsr(vcpu));
		391	int rt = kvm_vcpu_sys_get_rt(vcpu);
		392	u64 val = vcpu_get_reg(vcpu, rt);
		393
		394	/*
		395	* The normal sysreg handling code expects to see the traps,
		396	* let's not do anything here.
		397	*/
		398	if (vcpu->arch.hcr_el2 & HCR_TVM)
		399	return false;
		400
		401	switch (sysreg) {
		402	case SYS_SCTLR_EL1:
		403	write_sysreg_el1(val, SYS_SCTLR);
		404	break;
		405	case SYS_TTBR0_EL1:
		406	write_sysreg_el1(val, SYS_TTBR0);
		407	break;
		408	case SYS_TTBR1_EL1:
		409	write_sysreg_el1(val, SYS_TTBR1);
		410	break;
		411	case SYS_TCR_EL1:
		412	write_sysreg_el1(val, SYS_TCR);
		413	break;
		414	case SYS_ESR_EL1:
		415	write_sysreg_el1(val, SYS_ESR);
		416	break;
		417	case SYS_FAR_EL1:
		418	write_sysreg_el1(val, SYS_FAR);
		419	break;
		420	case SYS_AFSR0_EL1:
		421	write_sysreg_el1(val, SYS_AFSR0);
		422	break;
		423	case SYS_AFSR1_EL1:
		424	write_sysreg_el1(val, SYS_AFSR1);
		425	break;
		426	case SYS_MAIR_EL1:
		427	write_sysreg_el1(val, SYS_MAIR);
		428	break;
		429	case SYS_AMAIR_EL1:
		430	write_sysreg_el1(val, SYS_AMAIR);
		431	break;
		432	case SYS_CONTEXTIDR_EL1:
		433	write_sysreg_el1(val, SYS_CONTEXTIDR);
		434	break;
		435	default:
		436	return false;
		437	}
		438
		439	__kvm_skip_instr(vcpu);
		440	return true;
		441	}
		442
383	/*	443	/*
384	* Return true when we were able to fixup the guest exit and should return to	444	* Return true when we were able to fixup the guest exit and should return to
385	* the guest, false when we should restore the host state and return to the	445	* the guest, false when we should restore the host state and return to the
@@ -399,6 +459,11 @@ static bool __hyp_text fixup_guest_exit(struct kvm_vcpu vcpu, u64 exit_code) · 13 unmodified lines
399	if (*exit_code != ARM_EXCEPTION_TRAP)	459	if (*exit_code != ARM_EXCEPTION_TRAP)
400	goto exit;	460	goto exit;
401		461
		462	if (cpus_have_const_cap(ARM64_WORKAROUND_CAVIUM_TX2_219_TVM) &&
		463	kvm_vcpu_trap_get_class(vcpu) == ESR_ELx_EC_SYS64 &&
		464	handle_tx2_tvm(vcpu))
		465	return true;
		466
402	/*	467	/*
403	* We trap the first access to the FP/SIMD to save the host context	468	* We trap the first access to the FP/SIMD to save the host context
404	* and restore the guest context lazily.	469	* and restore the guest context lazily.

arch/arm64/mm/fault.c+16−3

 	return arch_kasan_reset_tag(addr) >= PAGE_OFFSET;
 }
+static inline unsigned long mm_to_pgd_phys(struct mm_struct *mm)
+{
+	/* Either init_pg_dir or swapper_pg_dir */
+	if (mm == &init_mm)
+		return __pa_symbol(mm->pgd);
+	return (unsigned long)virt_to_phys(mm->pgd);
+}
 /*
  * Dump out the page tables associated with 'addr' in the currently active mm.
  */
 	pr_alert("%s pgtable: %luk pages, %llu-bit VAs, pgdp=%016lx\n",
 		 mm == &init_mm ? "swapper" : "user", PAGE_SIZE / SZ_1K,
-		 vabits_actual, (unsigned long)virt_to_phys(mm->pgd));
+		 vabits_actual, mm_to_pgd_phys(mm));
 	pgdp = pgd_offset(mm, addr);
 	pgd = READ_ONCE(*pgdp);
 	pr_alert("[%016lx] pgd=%016llx", addr, pgd_val(pgd));
 	par = read_sysreg(par_el1);
 	local_irq_restore(flags);
+	/*
+	 * If we now have a valid translation, treat the translation fault as
+	 * spurious.
+	 */
 	if (!(par & SYS_PAR_EL1_F))
-		return false;
+		return true;
 	/*
 	 * If we got a different type of fault from the AT instruction,
 	 * treat the translation fault as spurious.
 	 */
-	dfsc = FIELD_PREP(SYS_PAR_EL1_FST, par);
+	dfsc = FIELD_GET(SYS_PAR_EL1_FST, par);
 	return (dfsc & ESR_ELx_FSC_TYPE) != ESR_ELx_FSC_FAULT;
 }

arch/mips/configs/mtx1_defconfig+0−1

@@ -571,7 +571,6 @@ CONFIG_USB_SERIAL_OMNINET=m · 570 unmodified lines
571	CONFIG_USB_EMI62=m	571	CONFIG_USB_EMI62=m
572	CONFIG_USB_EMI26=m	572	CONFIG_USB_EMI26=m
573	CONFIG_USB_ADUTUX=m	573	CONFIG_USB_ADUTUX=m
574	CONFIG_USB_RIO500=m
575	CONFIG_USB_LEGOTOWER=m	574	CONFIG_USB_LEGOTOWER=m
576	CONFIG_USB_LCD=m	575	CONFIG_USB_LCD=m
577	CONFIG_USB_CYPRESS_CY7C63=m	576	CONFIG_USB_CYPRESS_CY7C63=m

arch/mips/configs/rm200_defconfig+0−1

@@ -314,7 +314,6 @@ CONFIG_USB_SERIAL_SAFE_PADDED=y · 313 unmodified lines
314	CONFIG_USB_SERIAL_CYBERJACK=m	314	CONFIG_USB_SERIAL_CYBERJACK=m
315	CONFIG_USB_SERIAL_XIRCOM=m	315	CONFIG_USB_SERIAL_XIRCOM=m
316	CONFIG_USB_SERIAL_OMNINET=m	316	CONFIG_USB_SERIAL_OMNINET=m
317	CONFIG_USB_RIO500=m
318	CONFIG_USB_LEGOTOWER=m	317	CONFIG_USB_LEGOTOWER=m
319	CONFIG_USB_LCD=m	318	CONFIG_USB_LCD=m
320	CONFIG_USB_CYTHERM=m	319	CONFIG_USB_CYTHERM=m

arch/mips/fw/sni/sniprom.c+1−1

@@ -43,7 +43,7 @@ · 42 unmodified lines
43		43
44	/* O32 stack has to be 8-byte aligned. */	44	/* O32 stack has to be 8-byte aligned. */
45	static u64 o32_stk[4096];	45	static u64 o32_stk[4096];
46	#define O32_STK &o32_stk[sizeof(o32_stk)]	46	#define O32_STK (&o32_stk[ARRAY_SIZE(o32_stk)])
47		47
48	#define __PROM_O32(fun, arg) fun arg __asm__(#fun); \	48	#define __PROM_O32(fun, arg) fun arg __asm__(#fun); \
49	__asm__(#fun " = call_o32")	49	__asm__(#fun " = call_o32")

arch/mips/include/asm/cmpxchg.h+5−4

 extern unsigned long __xchg_small(volatile void *ptr, unsigned long val,
 				  unsigned int size);
-static inline unsigned long __xchg(volatile void *ptr, unsigned long x,
+static __always_inline
-				   int size)
+unsigned long __xchg(volatile void *ptr, unsigned long x, int size)
 {
 	switch (size) {
 	case 1:
 extern unsigned long __cmpxchg_small(volatile void *ptr, unsigned long old,
 				     unsigned long new, unsigned int size);
-static inline unsigned long __cmpxchg(volatile void *ptr, unsigned long old,
+static __always_inline
-				      unsigned long new, unsigned int size)
+unsigned long __cmpxchg(volatile void *ptr, unsigned long old,
+			unsigned long new, unsigned int size)
 {
 	switch (size) {
 	case 1:

arch/mips/include/uapi/asm/hwcap.h+11−0

@@ -6,5 +6,16 @@ · 5 unmodified lines
6	#define HWCAP_MIPS_R6 (1 << 0)	6	#define HWCAP_MIPS_R6 (1 << 0)
7	#define HWCAP_MIPS_MSA (1 << 1)	7	#define HWCAP_MIPS_MSA (1 << 1)
8	#define HWCAP_MIPS_CRC32 (1 << 2)	8	#define HWCAP_MIPS_CRC32 (1 << 2)
		9	#define HWCAP_MIPS_MIPS16 (1 << 3)
		10	#define HWCAP_MIPS_MDMX (1 << 4)
		11	#define HWCAP_MIPS_MIPS3D (1 << 5)
		12	#define HWCAP_MIPS_SMARTMIPS (1 << 6)
		13	#define HWCAP_MIPS_DSP (1 << 7)
		14	#define HWCAP_MIPS_DSP2 (1 << 8)
		15	#define HWCAP_MIPS_DSP3 (1 << 9)
		16	#define HWCAP_MIPS_MIPS16E2 (1 << 10)
		17	#define HWCAP_LOONGSON_MMI (1 << 11)
		18	#define HWCAP_LOONGSON_EXT (1 << 12)
		19	#define HWCAP_LOONGSON_EXT2 (1 << 13)
9		20
10	#endif /* _UAPI_ASM_HWCAP_H */	21	#endif /* _UAPI_ASM_HWCAP_H */

arch/mips/kernel/cpu-probe.c+33−0

@@ -2180,6 +2180,39 @@ void cpu_probe(void) · 2179 unmodified lines
2180	elf_hwcap \|= HWCAP_MIPS_MSA;	2180	elf_hwcap \|= HWCAP_MIPS_MSA;
2181	}	2181	}
2182		2182
		2183	if (cpu_has_mips16)
		2184	elf_hwcap \|= HWCAP_MIPS_MIPS16;
		2185
		2186	if (cpu_has_mdmx)
		2187	elf_hwcap \|= HWCAP_MIPS_MDMX;
		2188
		2189	if (cpu_has_mips3d)
		2190	elf_hwcap \|= HWCAP_MIPS_MIPS3D;
		2191
		2192	if (cpu_has_smartmips)
		2193	elf_hwcap \|= HWCAP_MIPS_SMARTMIPS;
		2194
		2195	if (cpu_has_dsp)
		2196	elf_hwcap \|= HWCAP_MIPS_DSP;
		2197
		2198	if (cpu_has_dsp2)
		2199	elf_hwcap \|= HWCAP_MIPS_DSP2;
		2200
		2201	if (cpu_has_dsp3)
		2202	elf_hwcap \|= HWCAP_MIPS_DSP3;
		2203
		2204	if (cpu_has_mips16e2)
		2205	elf_hwcap \|= HWCAP_MIPS_MIPS16E2;
		2206
		2207	if (cpu_has_loongson_mmi)
		2208	elf_hwcap \|= HWCAP_LOONGSON_MMI;
		2209
		2210	if (cpu_has_loongson_ext)
		2211	elf_hwcap \|= HWCAP_LOONGSON_EXT;
		2212
		2213	if (cpu_has_loongson_ext2)
		2214	elf_hwcap \|= HWCAP_LOONGSON_EXT2;
		2215
2183	if (cpu_has_vz)	2216	if (cpu_has_vz)
2184	cpu_probe_vz(c);	2217	cpu_probe_vz(c);
2185		2218

arch/mips/loongson64/Platform+4−0

       $(call cc-option,-march=mips64r2,-mips64r2 -U_MIPS_ISA -D_MIPS_ISA=_MIPS_ISA_MIPS64)
 endif
+# Some -march= flags enable MMI instructions, and GCC complains about that
+# support being enabled alongside -msoft-float. Thus explicitly disable MMI.
+cflags-y += $(call cc-option,-mno-loongson-mmi)
 #
 # Loongson Machines' Support
 #

arch/mips/vdso/Makefile+1−0

@@ -15,6 +15,7 @@ ccflags-vdso := \ · 14 unmodified lines
15	$(filter -mmicromips,$(KBUILD_CFLAGS)) \	15	$(filter -mmicromips,$(KBUILD_CFLAGS)) \
16	$(filter -march=%,$(KBUILD_CFLAGS)) \	16	$(filter -march=%,$(KBUILD_CFLAGS)) \
17	$(filter -m%-float,$(KBUILD_CFLAGS)) \	17	$(filter -m%-float,$(KBUILD_CFLAGS)) \
		18	$(filter -mno-loongson-%,$(KBUILD_CFLAGS)) \
18	-D__VDSO__	19	-D__VDSO__
19		20
20	ifdef CONFIG_CC_IS_CLANG	21	ifdef CONFIG_CC_IS_CLANG

arch/parisc/include/asm/cache.h+1−1

@@ -22,7 +22,7 @@ · 21 unmodified lines
22		22
23	#define ARCH_DMA_MINALIGN L1_CACHE_BYTES	23	#define ARCH_DMA_MINALIGN L1_CACHE_BYTES
24		24
25	#define __read_mostly __attribute__((__section__(".data..read_mostly")))	25	#define __read_mostly __section(.data..read_mostly)
26		26
27	void parisc_cache_init(void); /* initializes cache-flushing */	27	void parisc_cache_init(void); /* initializes cache-flushing */
28	void disable_sr_hashing_asm(int); /* low level support for above */	28	void disable_sr_hashing_asm(int); /* low level support for above */

arch/parisc/include/asm/ldcw.h+1−1

@@ -52,7 +52,7 @@ · 51 unmodified lines
52	})	52	})
53		53
54	#ifdef CONFIG_SMP	54	#ifdef CONFIG_SMP
55	# define __lock_aligned __attribute__((__section__(".data..lock_aligned")))	55	# define __lock_aligned __section(.data..lock_aligned)
56	#endif	56	#endif
57		57
58	#endif /* __PARISC_LDCW_H */	58	#endif /* __PARISC_LDCW_H */

arch/parisc/mm/ioremap.c+7−5

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	* arch/parisc/mm/ioremap.c	3	* arch/parisc/mm/ioremap.c
4	*	4	*
5	* (C) Copyright 1995 1996 Linus Torvalds	5	* (C) Copyright 1995 1996 Linus Torvalds
6	* (C) Copyright 2001-2006 Helge Deller <deller@gmx.de>	6	* (C) Copyright 2001-2019 Helge Deller <deller@gmx.de>
7	* (C) Copyright 2005 Kyle McMartin <kyle@parisc-linux.org>	7	* (C) Copyright 2005 Kyle McMartin <kyle@parisc-linux.org>
8	*/	8	*/
9		9
@@ -84,7 +84,7 @@ void __iomem * __ioremap(unsigned long phys_addr, unsigned long size, unsigned l · 74 unmodified lines
84	addr = (void __iomem *) area->addr;	84	addr = (void __iomem *) area->addr;
85	if (ioremap_page_range((unsigned long)addr, (unsigned long)addr + size,	85	if (ioremap_page_range((unsigned long)addr, (unsigned long)addr + size,
86	phys_addr, pgprot)) {	86	phys_addr, pgprot)) {
87	vfree(addr);	87	vunmap(addr);
88	return NULL;	88	return NULL;
89	}	89	}
90		90
@@ -92,9 +92,11 @@ void __iomem * __ioremap(unsigned long phys_addr, unsigned long size, unsigned l · 1 unmodified line
92	}	92	}
93	EXPORT_SYMBOL(__ioremap);	93	EXPORT_SYMBOL(__ioremap);
94		94
95	void iounmap(const volatile void __iomem *addr)	95	void iounmap(const volatile void __iomem *io_addr)
96	{	96	{
97	if (addr > high_memory)	97	unsigned long addr = (unsigned long)io_addr & PAGE_MASK;
98	return vfree((void *) (PAGE_MASK & (unsigned long __force) addr));	98
		99	if (is_vmalloc_addr((void *)addr))
		100	vunmap((void *)addr);
99	}	101	}
100	EXPORT_SYMBOL(iounmap);	102	EXPORT_SYMBOL(iounmap);

arch/powerpc/include/asm/book3s/64/tlbflush-radix.h+4−0

 {
 	WARN_ON(1);
 }
+static inline void radix__flush_all_lpid_guest(unsigned int lpid)
+{
+	WARN_ON(1);
+}
 #endif
 extern void radix__flush_hugetlb_tlb_range(struct vm_area_struct *vma,

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

@@ -1921,6 +1921,7 @@ END_FTR_SECTION_IFSET(CPU_FTR_ARCH_207S) · 1920 unmodified lines
1921	mtspr SPRN_PCR, r6	1921	mtspr SPRN_PCR, r6
1922	18:	1922	18:
1923	/* Signal secondary CPUs to continue */	1923	/* Signal secondary CPUs to continue */
		1924	li r0, 0
1924	stb r0,VCORE_IN_GUEST(r5)	1925	stb r0,VCORE_IN_GUEST(r5)
1925	19: lis r8,0x7fff /* MAX_INT@h */	1926	19: lis r8,0x7fff /* MAX_INT@h */
1926	mtspr SPRN_HDEC,r8	1927	mtspr SPRN_HDEC,r8

arch/powerpc/platforms/cell/spufs/inode.c+1−0

@@ -761,6 +761,7 @@ static int spufs_init_fs_context(struct fs_context *fc) · 760 unmodified lines
761	ctx->gid = current_gid();	761	ctx->gid = current_gid();
762	ctx->mode = 0755;	762	ctx->mode = 0755;
763		763
		764	fc->fs_private = ctx;
764	fc->s_fs_info = sbi;	765	fc->s_fs_info = sbi;
765	fc->ops = &spufs_context_ops;	766	fc->ops = &spufs_context_ops;
766	return 0;	767	return 0;

arch/powerpc/platforms/pseries/lpar.c+3−0

@@ -1419,6 +1419,9 @@ void __init pseries_lpar_read_hblkrm_characteristics(void) · 1418 unmodified lines
1419	unsigned char local_buffer[SPLPAR_TLB_BIC_MAXLENGTH];	1419	unsigned char local_buffer[SPLPAR_TLB_BIC_MAXLENGTH];
1420	int call_status, len, idx, bpsize;	1420	int call_status, len, idx, bpsize;
1421		1421
		1422	if (!firmware_has_feature(FW_FEATURE_BLOCK_REMOVE))
		1423	return;
		1424
1422	spin_lock(&rtas_data_buf_lock);	1425	spin_lock(&rtas_data_buf_lock);
1423	memset(rtas_data_buf, 0, RTAS_DATA_BUF_SIZE);	1426	memset(rtas_data_buf, 0, RTAS_DATA_BUF_SIZE);
1424	call_status = rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,	1427	call_status = rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,

arch/riscv/boot/dts/sifive/hifive-unleashed-a00.dts+1−0

@@ -13,6 +13,7 @@ · 12 unmodified lines
13	compatible = "sifive,hifive-unleashed-a00", "sifive,fu540-c000";	13	compatible = "sifive,hifive-unleashed-a00", "sifive,fu540-c000";
14		14
15	chosen {	15	chosen {
		16	stdout-path = "serial0";
16	};	17	};
17		18
18	cpus {	19	cpus {

arch/riscv/include/asm/pgtable.h+8−8

 #define VMALLOC_END      (PAGE_OFFSET - 1)
 #define VMALLOC_START    (PAGE_OFFSET - VMALLOC_SIZE)
-#define FIXADDR_TOP      VMALLOC_START
-#ifdef CONFIG_64BIT
-#define FIXADDR_SIZE     PMD_SIZE
-#else
-#define FIXADDR_SIZE     PGDIR_SIZE
-#endif
-#define FIXADDR_START    (FIXADDR_TOP - FIXADDR_SIZE)
 /*
  * Roughly size the vmemmap space to be large enough to fit enough
  * struct pages to map half the virtual address space. Then
 #define vmemmap		((struct page *)VMEMMAP_START)
+#define FIXADDR_TOP      (VMEMMAP_START)
+#ifdef CONFIG_64BIT
+#define FIXADDR_SIZE     PMD_SIZE
+#else
+#define FIXADDR_SIZE     PGDIR_SIZE
+#endif
+#define FIXADDR_START    (FIXADDR_TOP - FIXADDR_SIZE)
 /*
  * ZERO_PAGE is a global shared page that is always zero,
  * used for zero-mapped memory areas, etc.

arch/riscv/include/asm/tlbflush.h+0−4

 #include <linux/mm_types.h>
 #include <asm/smp.h>
-/*
- * Flush entire local TLB.  'sfence.vma' implicitly fences with the instruction
- * cache as well, so a 'fence.i' is not necessary.
- */
 static inline void local_flush_tlb_all(void)
 {
 	__asm__ __volatile__ ("sfence.vma" : : : "memory");

arch/riscv/kernel/entry.S+1−2

 resume_kernel:
 	REG_L s0, TASK_TI_PREEMPT_COUNT(tp)
 	bnez s0, restore_all
-need_resched:
 	REG_L s0, TASK_TI_FLAGS(tp)
 	andi s0, s0, _TIF_NEED_RESCHED
 	beqz s0, restore_all
 	call preempt_schedule_irq
-	j need_resched
+	j restore_all
 #endif
 work_pending:

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

 asmlinkage void do_trap_break(struct pt_regs *regs)
 {
+	if (user_mode(regs)) {
+		force_sig_fault(SIGTRAP, TRAP_BRKPT,
+				(void __user *)(regs->sepc));
+		return;
+	}
 #ifdef CONFIG_GENERIC_BUG
-	if (!user_mode(regs)) {
+	{
 		enum bug_trap_type type;
 		type = report_bug(regs->sepc, regs);
-		switch (type) {
+		if (type == BUG_TRAP_TYPE_WARN) {
-		case BUG_TRAP_TYPE_NONE:
-			break;
-		case BUG_TRAP_TYPE_WARN:
 			regs->sepc += get_break_insn_length(regs->sepc);
-			break;
+			return;
-		case BUG_TRAP_TYPE_BUG:
-			die(regs, "Kernel BUG");
 		}
 	}
 #endif /* CONFIG_GENERIC_BUG */
-	force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)(regs->sepc));
+	die(regs, "Kernel BUG");
 }
 #ifdef CONFIG_GENERIC_BUG

arch/s390/include/asm/uaccess.h+2−2

@@ -83,7 +83,7 @@ raw_copy_to_user(void __user to, const void from, unsigned long n); · 82 unmodified lines
83	__rc; \	83	__rc; \
84	})	84	})
85		85
86	static inline int __put_user_fn(void x, void __user ptr, unsigned long size)	86	static __always_inline int __put_user_fn(void x, void __user ptr, unsigned long size)
87	{	87	{
88	unsigned long spec = 0x010000UL;	88	unsigned long spec = 0x010000UL;
89	int rc;	89	int rc;
@@ -113,7 +113,7 @@ static inline int __put_user_fn(void x, void __user ptr, unsigned long size) · 23 unmodified lines
113	return rc;	113	return rc;
114	}	114	}
115		115
116	static inline int __get_user_fn(void x, const void __user ptr, unsigned long size)	116	static __always_inline int __get_user_fn(void x, const void __user ptr, unsigned long size)
117	{	117	{
118	unsigned long spec = 0x01UL;	118	unsigned long spec = 0x01UL;
119	int rc;	119	int rc;

arch/sparc/Kconfig+0−1

@@ -29,7 +29,6 @@ config SPARC · 28 unmodified lines
29	select RTC_DRV_M48T59	29	select RTC_DRV_M48T59
30	select RTC_SYSTOHC	30	select RTC_SYSTOHC
31	select HAVE_ARCH_JUMP_LABEL if SPARC64	31	select HAVE_ARCH_JUMP_LABEL if SPARC64
32	select HAVE_FAST_GUP if SPARC64
33	select GENERIC_IRQ_SHOW	32	select GENERIC_IRQ_SHOW
34	select ARCH_WANT_IPC_PARSE_VERSION	33	select ARCH_WANT_IPC_PARSE_VERSION
35	select GENERIC_PCI_IOMAP	34	select GENERIC_PCI_IOMAP

arch/x86/boot/compressed/acpi.c+24−24

  */
 struct mem_vector immovable_mem[MAX_NUMNODES*2];
-/*
- * Max length of 64-bit hex address string is 19, prefix "0x" + 16 hex
- * digits, and '\0' for termination.
- */
-#define MAX_ADDR_LEN 19
-static acpi_physical_address get_cmdline_acpi_rsdp(void)
-{
-	acpi_physical_address addr = 0;
-#ifdef CONFIG_KEXEC
-	char val[MAX_ADDR_LEN] = { };
-	int ret;
-	ret = cmdline_find_option("acpi_rsdp", val, MAX_ADDR_LEN);
-	if (ret < 0)
-		return 0;
-	if (kstrtoull(val, 16, &addr))
-		return 0;
-#endif
-	return addr;
-}
 /*
  * Search EFI system tables for RSDP.  If both ACPI_20_TABLE_GUID and
  * ACPI_TABLE_GUID are found, take the former, which has more features.
 }
 #if defined(CONFIG_RANDOMIZE_BASE) && defined(CONFIG_MEMORY_HOTREMOVE)
+/*
+ * Max length of 64-bit hex address string is 19, prefix "0x" + 16 hex
+ * digits, and '\0' for termination.
+ */
+#define MAX_ADDR_LEN 19
+static acpi_physical_address get_cmdline_acpi_rsdp(void)
+{
+	acpi_physical_address addr = 0;
+#ifdef CONFIG_KEXEC
+	char val[MAX_ADDR_LEN] = { };
+	int ret;
+	ret = cmdline_find_option("acpi_rsdp", val, MAX_ADDR_LEN);
+	if (ret < 0)
+		return 0;
+	if (kstrtoull(val, 16, &addr))
+		return 0;
+#endif
+	return addr;
+}
 /* Compute SRAT address from RSDP. */
 static unsigned long get_acpi_srat_table(void)
 {

arch/x86/boot/compressed/misc.c+19−6

 {
 	const unsigned long kernel_total_size = VO__end - VO__text;
 	unsigned long virt_addr = LOAD_PHYSICAL_ADDR;
+	unsigned long needed_size;
 	/* Retain x86 boot parameters pointer passed from startup_32/64. */
 	boot_params = rmode;
 	free_mem_ptr     = heap;	/* Heap */
 	free_mem_end_ptr = heap + BOOT_HEAP_SIZE;
+	/*
+	 * The memory hole needed for the kernel is the larger of either
+	 * the entire decompressed kernel plus relocation table, or the
+	 * entire decompressed kernel plus .bss and .brk sections.
+	 *
+	 * On X86_64, the memory is mapped with PMD pages. Round the
+	 * size up so that the full extent of PMD pages mapped is
+	 * included in the check against the valid memory table
+	 * entries. This ensures the full mapped area is usable RAM
+	 * and doesn't include any reserved areas.
+	 */
+	needed_size = max(output_len, kernel_total_size);
+#ifdef CONFIG_X86_64
+	needed_size = ALIGN(needed_size, MIN_KERNEL_ALIGN);
+#endif
 	/* Report initial kernel position details. */
 	debug_putaddr(input_data);
 	debug_putaddr(input_len);
 	debug_putaddr(output);
 	debug_putaddr(output_len);
 	debug_putaddr(kernel_total_size);
+	debug_putaddr(needed_size);
 #ifdef CONFIG_X86_64
 	/* Report address of 32-bit trampoline */
 	debug_putaddr(trampoline_32bit);
 #endif
-	/*
-	 * The memory hole needed for the kernel is the larger of either
-	 * the entire decompressed kernel plus relocation table, or the
-	 * entire decompressed kernel plus .bss and .brk sections.
-	 */
 	choose_random_location((unsigned long)input_data, input_len,
 				(unsigned long *)&output,
-				max(output_len, kernel_total_size),
+				needed_size,
 				&virt_addr);
 	/* Validate memory location choices. */

arch/x86/events/amd/core.c+17−13

 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/jiffies.h>
 #include <asm/apicdef.h>
 #include <asm/nmi.h>
 #include "../perf_event.h"
-static DEFINE_PER_CPU(unsigned int, perf_nmi_counter);
+static DEFINE_PER_CPU(unsigned long, perf_nmi_tstamp);
+static unsigned long perf_nmi_window;
 static __initconst const u64 amd_hw_cache_event_ids
 				[PERF_COUNT_HW_CACHE_MAX]
  * handler when multiple PMCs are active or PMC overflow while handling some
  * other source of an NMI.
  *
- * Attempt to mitigate this by using the number of active PMCs to determine
+ * Attempt to mitigate this by creating an NMI window in which un-handled NMIs
- * whether to return NMI_HANDLED if the perf NMI handler did not handle/reset
+ * received during this window will be claimed. This prevents extending the
- * any PMCs. The per-CPU perf_nmi_counter variable is set to a minimum of the
+ * window past when it is possible that latent NMIs should be received. The
- * number of active PMCs or 2. The value of 2 is used in case an NMI does not
+ * per-CPU perf_nmi_tstamp will be set to the window end time whenever perf has
- * arrive at the LAPIC in time to be collapsed into an already pending NMI.
+ * handled a counter. When an un-handled NMI is received, it will be claimed
+ * only if arriving within that window.
  */
 static int amd_pmu_handle_irq(struct pt_regs *regs)
 {
 	handled = x86_pmu_handle_irq(regs);
 	/*
-	 * If a counter was handled, record the number of possible remaining
+	 * If a counter was handled, record a timestamp such that un-handled
-	 * NMIs that can occur.
+	 * NMIs will be claimed if arriving within that window.
 	 */
 	if (handled) {
-		this_cpu_write(perf_nmi_counter,
+		this_cpu_write(perf_nmi_tstamp,
-			       min_t(unsigned int, 2, active));
+			       jiffies + perf_nmi_window);
 		return handled;
 	}
-	if (!this_cpu_read(perf_nmi_counter))
+	if (time_after(jiffies, this_cpu_read(perf_nmi_tstamp)))
 		return NMI_DONE;
-	this_cpu_dec(perf_nmi_counter);
 	return NMI_HANDLED;
 }
 	if (!boot_cpu_has(X86_FEATURE_PERFCTR_CORE))
 		return 0;
+	/* Avoid calulating the value each time in the NMI handler */
+	perf_nmi_window = msecs_to_jiffies(100);
 	switch (boot_cpu_data.x86) {
 	case 0x15:
 		pr_cont("Fam15h ");

arch/x86/events/intel/core.c+4−0

 	case INTEL_FAM6_SKYLAKE:
 	case INTEL_FAM6_KABYLAKE_L:
 	case INTEL_FAM6_KABYLAKE:
+	case INTEL_FAM6_COMETLAKE_L:
+	case INTEL_FAM6_COMETLAKE:
 		x86_add_quirk(intel_pebs_isolation_quirk);
 		x86_pmu.late_ack = true;
 		memcpy(hw_cache_event_ids, skl_hw_cache_event_ids, sizeof(hw_cache_event_ids));
 		/* fall through */
 	case INTEL_FAM6_ICELAKE_L:
 	case INTEL_FAM6_ICELAKE:
+	case INTEL_FAM6_TIGERLAKE_L:
+	case INTEL_FAM6_TIGERLAKE:
 		x86_pmu.late_ack = true;
 		memcpy(hw_cache_event_ids, skl_hw_cache_event_ids, sizeof(hw_cache_event_ids));
 		memcpy(hw_cache_extra_regs, skl_hw_cache_extra_regs, sizeof(hw_cache_extra_regs));

arch/x86/events/intel/cstate.c+32−12

  *	MSR_CORE_C3_RESIDENCY: CORE C3 Residency Counter
  *			       perf code: 0x01
  *			       Available model: NHM,WSM,SNB,IVB,HSW,BDW,SKL,GLM,
-						CNL
+ *						CNL,KBL,CML
  *			       Scope: Core
  *	MSR_CORE_C6_RESIDENCY: CORE C6 Residency Counter
  *			       perf code: 0x02
  *			       Available model: SLM,AMT,NHM,WSM,SNB,IVB,HSW,BDW,
- *						SKL,KNL,GLM,CNL
+ *						SKL,KNL,GLM,CNL,KBL,CML,ICL,TGL
  *			       Scope: Core
  *	MSR_CORE_C7_RESIDENCY: CORE C7 Residency Counter
  *			       perf code: 0x03
- *			       Available model: SNB,IVB,HSW,BDW,SKL,CNL
+ *			       Available model: SNB,IVB,HSW,BDW,SKL,CNL,KBL,CML,
+ *						ICL,TGL
  *			       Scope: Core
  *	MSR_PKG_C2_RESIDENCY:  Package C2 Residency Counter.
  *			       perf code: 0x00
- *			       Available model: SNB,IVB,HSW,BDW,SKL,KNL,GLM,CNL
+ *			       Available model: SNB,IVB,HSW,BDW,SKL,KNL,GLM,CNL,
+ *						KBL,CML,ICL,TGL
  *			       Scope: Package (physical package)
  *	MSR_PKG_C3_RESIDENCY:  Package C3 Residency Counter.
  *			       perf code: 0x01
  *			       Available model: NHM,WSM,SNB,IVB,HSW,BDW,SKL,KNL,
- *						GLM,CNL
+ *						GLM,CNL,KBL,CML,ICL,TGL
  *			       Scope: Package (physical package)
  *	MSR_PKG_C6_RESIDENCY:  Package C6 Residency Counter.
  *			       perf code: 0x02
  *			       Available model: SLM,AMT,NHM,WSM,SNB,IVB,HSW,BDW
- *						SKL,KNL,GLM,CNL
+ *						SKL,KNL,GLM,CNL,KBL,CML,ICL,TGL
  *			       Scope: Package (physical package)
  *	MSR_PKG_C7_RESIDENCY:  Package C7 Residency Counter.
  *			       perf code: 0x03
- *			       Available model: NHM,WSM,SNB,IVB,HSW,BDW,SKL,CNL
+ *			       Available model: NHM,WSM,SNB,IVB,HSW,BDW,SKL,CNL,
+ *						KBL,CML,ICL,TGL
  *			       Scope: Package (physical package)
  *	MSR_PKG_C8_RESIDENCY:  Package C8 Residency Counter.
  *			       perf code: 0x04
- *			       Available model: HSW ULT,KBL,CNL
+ *			       Available model: HSW ULT,KBL,CNL,CML,ICL,TGL
  *			       Scope: Package (physical package)
  *	MSR_PKG_C9_RESIDENCY:  Package C9 Residency Counter.
  *			       perf code: 0x05
- *			       Available model: HSW ULT,KBL,CNL
+ *			       Available model: HSW ULT,KBL,CNL,CML,ICL,TGL
  *			       Scope: Package (physical package)
  *	MSR_PKG_C10_RESIDENCY: Package C10 Residency Counter.
  *			       perf code: 0x06
- *			       Available model: HSW ULT,KBL,GLM,CNL
+ *			       Available model: HSW ULT,KBL,GLM,CNL,CML,ICL,TGL
  *			       Scope: Package (physical package)
  *
  */
 				  BIT(PERF_CSTATE_PKG_C10_RES),
 };
+static const struct cstate_model icl_cstates __initconst = {
+	.core_events		= BIT(PERF_CSTATE_CORE_C6_RES) |
+				  BIT(PERF_CSTATE_CORE_C7_RES),
+	.pkg_events		= BIT(PERF_CSTATE_PKG_C2_RES) |
+				  BIT(PERF_CSTATE_PKG_C3_RES) |
+				  BIT(PERF_CSTATE_PKG_C6_RES) |
+				  BIT(PERF_CSTATE_PKG_C7_RES) |
+				  BIT(PERF_CSTATE_PKG_C8_RES) |
+				  BIT(PERF_CSTATE_PKG_C9_RES) |
+				  BIT(PERF_CSTATE_PKG_C10_RES),
+};
 static const struct cstate_model slm_cstates __initconst = {
 	.core_events		= BIT(PERF_CSTATE_CORE_C1_RES) |
 				  BIT(PERF_CSTATE_CORE_C6_RES),
 	X86_CSTATES_MODEL(INTEL_FAM6_KABYLAKE_L, hswult_cstates),
 	X86_CSTATES_MODEL(INTEL_FAM6_KABYLAKE,   hswult_cstates),
+	X86_CSTATES_MODEL(INTEL_FAM6_COMETLAKE_L, hswult_cstates),
+	X86_CSTATES_MODEL(INTEL_FAM6_COMETLAKE, hswult_cstates),
 	X86_CSTATES_MODEL(INTEL_FAM6_CANNONLAKE_L, cnl_cstates),
 	X86_CSTATES_MODEL(INTEL_FAM6_ATOM_GOLDMONT_PLUS, glm_cstates),
-	X86_CSTATES_MODEL(INTEL_FAM6_ICELAKE_L, snb_cstates),
+	X86_CSTATES_MODEL(INTEL_FAM6_ICELAKE_L, icl_cstates),
-	X86_CSTATES_MODEL(INTEL_FAM6_ICELAKE,   snb_cstates),
+	X86_CSTATES_MODEL(INTEL_FAM6_ICELAKE,   icl_cstates),
+	X86_CSTATES_MODEL(INTEL_FAM6_TIGERLAKE_L, icl_cstates),
+	X86_CSTATES_MODEL(INTEL_FAM6_TIGERLAKE, icl_cstates),
 	{ },
 };
 MODULE_DEVICE_TABLE(x86cpu, intel_cstates_match);

arch/x86/events/msr.c+7−0

 	case INTEL_FAM6_SKYLAKE_X:
 	case INTEL_FAM6_KABYLAKE_L:
 	case INTEL_FAM6_KABYLAKE:
+	case INTEL_FAM6_COMETLAKE_L:
+	case INTEL_FAM6_COMETLAKE:
 	case INTEL_FAM6_ICELAKE_L:
+	case INTEL_FAM6_ICELAKE:
+	case INTEL_FAM6_ICELAKE_X:
+	case INTEL_FAM6_ICELAKE_D:
+	case INTEL_FAM6_TIGERLAKE_L:
+	case INTEL_FAM6_TIGERLAKE:
 		if (idx == PERF_MSR_SMI || idx == PERF_MSR_PPERF)
 			return true;
 		break;

arch/x86/hyperv/hv_apic.c+15−5

 	}
 	if (ms_hyperv.hints & HV_X64_APIC_ACCESS_RECOMMENDED) {
-		pr_info("Hyper-V: Using MSR based APIC access\n");
+		pr_info("Hyper-V: Using enlightened APIC (%s mode)",
+			x2apic_enabled() ? "x2apic" : "xapic");
+		/*
+		 * With x2apic, architectural x2apic MSRs are equivalent to the
+		 * respective synthetic MSRs, so there's no need to override
+		 * the apic accessors.  The only exception is
+		 * hv_apic_eoi_write, because it benefits from lazy EOI when
+		 * available, but it works for both xapic and x2apic modes.
+		 */
 		apic_set_eoi_write(hv_apic_eoi_write);
-		apic->read      = hv_apic_read;
+		if (!x2apic_enabled()) {
-		apic->write     = hv_apic_write;
+			apic->read      = hv_apic_read;
-		apic->icr_write = hv_apic_icr_write;
+			apic->write     = hv_apic_write;
-		apic->icr_read  = hv_apic_icr_read;
+			apic->icr_write = hv_apic_icr_write;
+			apic->icr_read  = hv_apic_icr_read;
+		}
 	}
 }

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

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2		2
3	#ifndef _ASM_X86_CPU_ENTRY_AREA_H	3	#ifndef _ASM_X86_CPU_ENTRY_AREA_H
4	#define _ASM_X86_CPU_ENTRY_AREA_H	4	#define _ASM_X86_CPU_ENTRY_AREA_H

arch/x86/include/asm/intel-family.h+3−0

@@ -83,6 +83,9 @@ · 82 unmodified lines
83	#define INTEL_FAM6_TIGERLAKE_L 0x8C	83	#define INTEL_FAM6_TIGERLAKE_L 0x8C
84	#define INTEL_FAM6_TIGERLAKE 0x8D	84	#define INTEL_FAM6_TIGERLAKE 0x8D
85		85
		86	#define INTEL_FAM6_COMETLAKE 0xA5
		87	#define INTEL_FAM6_COMETLAKE_L 0xA6
		88
86	/* "Small Core" Processors (Atom) */	89	/* "Small Core" Processors (Atom) */
87		90
88	#define INTEL_FAM6_ATOM_BONNELL 0x1C /* Diamondville, Pineview */	91	#define INTEL_FAM6_ATOM_BONNELL 0x1C /* Diamondville, Pineview */

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

@@ -21,7 +21,7 @@ · 20 unmodified lines
21	#define MWAIT_ECX_INTERRUPT_BREAK 0x1	21	#define MWAIT_ECX_INTERRUPT_BREAK 0x1
22	#define MWAITX_ECX_TIMER_ENABLE BIT(1)	22	#define MWAITX_ECX_TIMER_ENABLE BIT(1)
23	#define MWAITX_MAX_LOOPS ((u32)-1)	23	#define MWAITX_MAX_LOOPS ((u32)-1)
24	#define MWAITX_DISABLE_CSTATES 0xf	24	#define MWAITX_DISABLE_CSTATES 0xf0
25		25
26	static inline void __monitor(const void *eax, unsigned long ecx,	26	static inline void __monitor(const void *eax, unsigned long ecx,
27	unsigned long edx)	27	unsigned long edx)

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

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _ASM_X86_PTI_H	2	#ifndef _ASM_X86_PTI_H
3	#define _ASM_X86_PTI_H	3	#define _ASM_X86_PTI_H
4	#ifndef __ASSEMBLY__	4	#ifndef __ASSEMBLY__

arch/x86/include/asm/uaccess.h+23−0

@@ -734,5 +734,28 @@ do { \ · 733 unmodified lines
734	if (unlikely(__gu_err)) goto err_label; \	734	if (unlikely(__gu_err)) goto err_label; \
735	} while (0)	735	} while (0)
736		736
		737	/*
		738	* We want the unsafe accessors to always be inlined and use
		739	* the error labels - thus the macro games.
		740	*/
		741	#define unsafe_copy_loop(dst, src, len, type, label) \
		742	while (len >= sizeof(type)) { \
		743	unsafe_put_user((type )src,(type __user *)dst,label); \
		744	dst += sizeof(type); \
		745	src += sizeof(type); \
		746	len -= sizeof(type); \
		747	}
		748
		749	#define unsafe_copy_to_user(_dst,_src,_len,label) \
		750	do { \
		751	char __user *__ucu_dst = (_dst); \
		752	const char *__ucu_src = (_src); \
		753	size_t __ucu_len = (_len); \
		754	unsafe_copy_loop(__ucu_dst, __ucu_src, __ucu_len, u64, label); \
		755	unsafe_copy_loop(__ucu_dst, __ucu_src, __ucu_len, u32, label); \
		756	unsafe_copy_loop(__ucu_dst, __ucu_src, __ucu_len, u16, label); \
		757	unsafe_copy_loop(__ucu_dst, __ucu_src, __ucu_len, u8, label); \
		758	} while (0)
		759
737	#endif /* _ASM_X86_UACCESS_H */	760	#endif /* _ASM_X86_UACCESS_H */
738		761

arch/x86/kernel/apic/x2apic_cluster.c+2−1

@@ -156,7 +156,8 @@ static int x2apic_dead_cpu(unsigned int dead_cpu) · 155 unmodified lines
156	{	156	{
157	struct cluster_mask *cmsk = per_cpu(cluster_masks, dead_cpu);	157	struct cluster_mask *cmsk = per_cpu(cluster_masks, dead_cpu);
158		158
159	cpumask_clear_cpu(dead_cpu, &cmsk->mask);	159	if (cmsk)
		160	cpumask_clear_cpu(dead_cpu, &cmsk->mask);
160	free_cpumask_var(per_cpu(ipi_mask, dead_cpu));	161	free_cpumask_var(per_cpu(ipi_mask, dead_cpu));
161	return 0;	162	return 0;
162	}	163	}

arch/x86/kernel/cpu/mshyperv.c+4−0

 	int hv_host_info_ecx;
 	int hv_host_info_edx;
+#ifdef CONFIG_PARAVIRT
+	pv_info.name = "Hyper-V";
+#endif
 	/*
 	 * Extract the features and hints
 	 */

arch/x86/kernel/cpu/vmware.c+1−1

@@ -49,7 +49,7 @@ · 48 unmodified lines
49	#define VMWARE_CMD_VCPU_RESERVED 31	49	#define VMWARE_CMD_VCPU_RESERVED 31
50		50
51	#define VMWARE_PORT(cmd, eax, ebx, ecx, edx) \	51	#define VMWARE_PORT(cmd, eax, ebx, ecx, edx) \
52	__asm__("inl (%%dx)" : \	52	__asm__("inl (%%dx), %%eax" : \
53	"=a"(eax), "=c"(ecx), "=d"(edx), "=b"(ebx) : \	53	"=a"(eax), "=c"(ecx), "=d"(edx), "=b"(ebx) : \
54	"a"(VMWARE_HYPERVISOR_MAGIC), \	54	"a"(VMWARE_HYPERVISOR_MAGIC), \
55	"c"(VMWARE_CMD_##cmd), \	55	"c"(VMWARE_CMD_##cmd), \

arch/x86/kernel/head64.c+20−2

@@ -222,13 +222,31 @@ unsigned long __head __startup_64(unsigned long physaddr, · 221 unmodified lines
222	* we might write invalid pmds, when the kernel is relocated	222	* we might write invalid pmds, when the kernel is relocated
223	* cleanup_highmap() fixes this up along with the mappings	223	* cleanup_highmap() fixes this up along with the mappings
224	* beyond _end.	224	* beyond _end.
		225	*
		226	* Only the region occupied by the kernel image has so far
		227	* been checked against the table of usable memory regions
		228	* provided by the firmware, so invalidate pages outside that
		229	* region. A page table entry that maps to a reserved area of
		230	* memory would allow processor speculation into that area,
		231	* and on some hardware (particularly the UV platform) even
		232	* speculative access to some reserved areas is caught as an
		233	* error, causing the BIOS to halt the system.
225	*/	234	*/
226		235
227	pmd = fixup_pointer(level2_kernel_pgt, physaddr);	236	pmd = fixup_pointer(level2_kernel_pgt, physaddr);
228	for (i = 0; i < PTRS_PER_PMD; i++) {	237
		238	/* invalidate pages before the kernel image */
		239	for (i = 0; i < pmd_index((unsigned long)_text); i++)
		240	pmd[i] &= ~_PAGE_PRESENT;
		241
		242	/* fixup pages that are part of the kernel image */
		243	for (; i <= pmd_index((unsigned long)_end); i++)
229	if (pmd[i] & _PAGE_PRESENT)	244	if (pmd[i] & _PAGE_PRESENT)
230	pmd[i] += load_delta;	245	pmd[i] += load_delta;
231	}	246
		247	/* invalidate pages after the kernel image */
		248	for (; i < PTRS_PER_PMD; i++)
		249	pmd[i] &= ~_PAGE_PRESENT;
232		250
233	/*	251	/*
234	* Fixup phys_base - remove the memory encryption mask to obtain	252	* Fixup phys_base - remove the memory encryption mask to obtain

arch/x86/kernel/process.h+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	//	2	//
3	// Code shared between 32 and 64 bit	3	// Code shared between 32 and 64 bit
4		4

arch/x86/lib/delay.c+2−2

@@ -113,8 +113,8 @@ static void delay_mwaitx(unsigned long __loops) · 112 unmodified lines
113	__monitorx(raw_cpu_ptr(&cpu_tss_rw), 0, 0);	113	__monitorx(raw_cpu_ptr(&cpu_tss_rw), 0, 0);
114		114
115	/*	115	/*
116	* AMD, like Intel, supports the EAX hint and EAX=0xf	116	* AMD, like Intel's MWAIT version, supports the EAX hint and
117	* means, do not enter any deep C-state and we use it	117	* EAX=0xf0 means, do not enter any deep C-state and we use it
118	* here in delay() to minimize wakeup latency.	118	* here in delay() to minimize wakeup latency.
119	*/	119	*/
120	__mwaitx(MWAITX_DISABLE_CSTATES, delay, MWAITX_ECX_TIMER_ENABLE);	120	__mwaitx(MWAITX_DISABLE_CSTATES, delay, MWAITX_ECX_TIMER_ENABLE);

arch/x86/platform/efi/efi.c+0−3

@@ -917,9 +917,6 @@ static void __init kexec_enter_virtual_mode(void) · 916 unmodified lines
917		917
918	if (efi_enabled(EFI_OLD_MEMMAP) && (__supported_pte_mask & _PAGE_NX))	918	if (efi_enabled(EFI_OLD_MEMMAP) && (__supported_pte_mask & _PAGE_NX))
919	runtime_code_page_mkexec();	919	runtime_code_page_mkexec();
920
921	/* clean DUMMY object */
922	efi_delete_dummy_variable();
923	#endif	920	#endif
924	}	921	}
925		922

arch/x86/xen/enlighten.c+25−3

@@ -269,19 +269,41 @@ void xen_reboot(int reason) · 268 unmodified lines
269	BUG();	269	BUG();
270	}	270	}
271		271
		272	static int reboot_reason = SHUTDOWN_reboot;
		273	static bool xen_legacy_crash;
272	void xen_emergency_restart(void)	274	void xen_emergency_restart(void)
273	{	275	{
274	xen_reboot(SHUTDOWN_reboot);	276	xen_reboot(reboot_reason);
275	}	277	}
276		278
277	static int	279	static int
278	xen_panic_event(struct notifier_block this, unsigned long event, void ptr)	280	xen_panic_event(struct notifier_block this, unsigned long event, void ptr)
279	{	281	{
280	if (!kexec_crash_loaded())	282	if (!kexec_crash_loaded()) {
281	xen_reboot(SHUTDOWN_crash);	283	if (xen_legacy_crash)
		284	xen_reboot(SHUTDOWN_crash);
		285
		286	reboot_reason = SHUTDOWN_crash;
		287
		288	/*
		289	* If panic_timeout==0 then we are supposed to wait forever.
		290	* However, to preserve original dom0 behavior we have to drop
		291	* into hypervisor. (domU behavior is controlled by its
		292	* config file)
		293	*/
		294	if (panic_timeout == 0)
		295	panic_timeout = -1;
		296	}
282	return NOTIFY_DONE;	297	return NOTIFY_DONE;
283	}	298	}
284		299
		300	static int __init parse_xen_legacy_crash(char *arg)
		301	{
		302	xen_legacy_crash = true;
		303	return 0;
		304	}
		305	early_param("xen_legacy_crash", parse_xen_legacy_crash);
		306
285	static struct notifier_block xen_panic_block = {	307	static struct notifier_block xen_panic_block = {
286	.notifier_call = xen_panic_event,	308	.notifier_call = xen_panic_event,
287	.priority = INT_MIN	309	.priority = INT_MIN

arch/xtensa/boot/dts/virt.dts+1−1

@@ -56,7 +56,7 @@ · 55 unmodified lines
56	reg = <0xf0100000 0x03f00000>;	56	reg = <0xf0100000 0x03f00000>;
57		57
58	// BUS_ADDRESS(3) CPU_PHYSICAL(1) SIZE(2)	58	// BUS_ADDRESS(3) CPU_PHYSICAL(1) SIZE(2)
59	ranges = <0x01000000 0x0 0xf0000000 0xf0000000 0x0 0x00010000>,	59	ranges = <0x01000000 0x0 0x00000000 0xf0000000 0x0 0x00010000>,
60	<0x02000000 0x0 0xf4000000 0xf4000000 0x0 0x08000000>;	60	<0x02000000 0x0 0xf4000000 0xf4000000 0x0 0x08000000>;
61		61
62	// PCI_DEVICE(3) INT#(1) CONTROLLER(PHANDLE) CONTROLLER_DATA(2)	62	// PCI_DEVICE(3) INT#(1) CONTROLLER(PHANDLE) CONTROLLER_DATA(2)

arch/xtensa/include/asm/bitops.h+1−1

@@ -148,7 +148,7 @@ static inline void change_bit(unsigned int bit, volatile unsigned long *p) · 147 unmodified lines
148	" getex %0\n"	148	" getex %0\n"
149	" beqz %0, 1b\n"	149	" beqz %0, 1b\n"
150	: "=&a" (tmp)	150	: "=&a" (tmp)
151	: "a" (~mask), "a" (p)	151	: "a" (mask), "a" (p)
152	: "memory");	152	: "memory");
153	}	153	}
154		154

arch/xtensa/include/asm/uaccess.h+53−41

@@ -100,7 +100,7 @@ do { \ · 99 unmodified lines
100	case 4: __put_user_asm(x, ptr, retval, 4, "s32i", __cb); break; \	100	case 4: __put_user_asm(x, ptr, retval, 4, "s32i", __cb); break; \
101	case 8: { \	101	case 8: { \
102	__typeof__(*ptr) __v64 = x; \	102	__typeof__(*ptr) __v64 = x; \
103	retval = __copy_to_user(ptr, &__v64, 8); \	103	retval = __copy_to_user(ptr, &__v64, 8) ? -EFAULT : 0; \
104	break; \	104	break; \
105	} \	105	} \
106	default: __put_user_bad(); \	106	default: __put_user_bad(); \
@@ -132,14 +132,14 @@ do { \ · 25 unmodified lines
132	#define __check_align_1 ""	132	#define __check_align_1 ""
133		133
134	#define __check_align_2 \	134	#define __check_align_2 \
135	" _bbci.l %3, 0, 1f \n" \	135	" _bbci.l %[addr], 0, 1f \n" \
136	" movi %0, %4 \n" \	136	" movi %[err], %[efault] \n" \
137	" _j 2f \n"	137	" _j 2f \n"
138		138
139	#define __check_align_4 \	139	#define __check_align_4 \
140	" _bbsi.l %3, 0, 0f \n" \	140	" _bbsi.l %[addr], 0, 0f \n" \
141	" _bbci.l %3, 1, 1f \n" \	141	" _bbci.l %[addr], 1, 1f \n" \
142	"0: movi %0, %4 \n" \	142	"0: movi %[err], %[efault] \n" \
143	" _j 2f \n"	143	" _j 2f \n"
144		144
145		145
@@ -151,40 +151,40 @@ do { \ · 5 unmodified lines
151	* WARNING: If you modify this macro at all, verify that the	151	* WARNING: If you modify this macro at all, verify that the
152	* __check_align_* macros still work.	152	* __check_align_* macros still work.
153	*/	153	*/
154	#define __put_user_asm(x, addr, err, align, insn, cb) \	154	#define __put_user_asm(x_, addr_, err_, align, insn, cb)\
155	__asm__ __volatile__( \	155	__asm__ __volatile__( \
156	__check_align_##align \	156	__check_align_##align \
157	"1: "insn" %2, %3, 0 \n" \	157	"1: "insn" %[x], %[addr], 0 \n" \
158	"2: \n" \	158	"2: \n" \
159	" .section .fixup,\"ax\" \n" \	159	" .section .fixup,\"ax\" \n" \
160	" .align 4 \n" \	160	" .align 4 \n" \
161	" .literal_position \n" \	161	" .literal_position \n" \
162	"5: \n" \	162	"5: \n" \
163	" movi %1, 2b \n" \	163	" movi %[tmp], 2b \n" \
164	" movi %0, %4 \n" \	164	" movi %[err], %[efault] \n" \
165	" jx %1 \n" \	165	" jx %[tmp] \n" \
166	" .previous \n" \	166	" .previous \n" \
167	" .section __ex_table,\"a\" \n" \	167	" .section __ex_table,\"a\" \n" \
168	" .long 1b, 5b \n" \	168	" .long 1b, 5b \n" \
169	" .previous" \	169	" .previous" \
170	:"=r" (err), "=r" (cb) \	170	:[err] "+r"(err_), [tmp] "=r"(cb) \
171	:"r" ((int)(x)), "r" (addr), "i" (-EFAULT), "0" (err))	171	:[x] "r"(x_), [addr] "r"(addr_), [efault] "i"(-EFAULT))
172		172
173	#define __get_user_nocheck(x, ptr, size) \	173	#define __get_user_nocheck(x, ptr, size) \
174	({ \	174	({ \
175	long __gu_err, __gu_val; \	175	long __gu_err; \
176	__get_user_size(__gu_val, (ptr), (size), __gu_err); \	176	__get_user_size((x), (ptr), (size), __gu_err); \
177	(x) = (__force __typeof__(*(ptr)))__gu_val; \
178	__gu_err; \	177	__gu_err; \
179	})	178	})
180		179
181	#define __get_user_check(x, ptr, size) \	180	#define __get_user_check(x, ptr, size) \
182	({ \	181	({ \
183	long __gu_err = -EFAULT, __gu_val = 0; \	182	long __gu_err = -EFAULT; \
184	const __typeof__((ptr)) __gu_addr = (ptr); \	183	const __typeof__((ptr)) __gu_addr = (ptr); \
185	if (access_ok(__gu_addr, size)) \	184	if (access_ok(__gu_addr, size)) \
186	__get_user_size(__gu_val, __gu_addr, (size), __gu_err); \	185	__get_user_size((x), __gu_addr, (size), __gu_err); \
187	(x) = (__force __typeof__(*(ptr)))__gu_val; \	186	else \
		187	(x) = 0; \
188	__gu_err; \	188	__gu_err; \
189	})	189	})
190		190
@@ -198,8 +198,17 @@ do { \ · 7 unmodified lines
198	case 1: __get_user_asm(x, ptr, retval, 1, "l8ui", __cb); break;\	198	case 1: __get_user_asm(x, ptr, retval, 1, "l8ui", __cb); break;\
199	case 2: __get_user_asm(x, ptr, retval, 2, "l16ui", __cb); break;\	199	case 2: __get_user_asm(x, ptr, retval, 2, "l16ui", __cb); break;\
200	case 4: __get_user_asm(x, ptr, retval, 4, "l32i", __cb); break;\	200	case 4: __get_user_asm(x, ptr, retval, 4, "l32i", __cb); break;\
201	case 8: retval = __copy_from_user(&x, ptr, 8); break; \	201	case 8: { \
202	default: (x) = __get_user_bad(); \	202	u64 __x; \
		203	if (unlikely(__copy_from_user(&__x, ptr, 8))) { \
		204	retval = -EFAULT; \
		205	(x) = 0; \
		206	} else { \
		207	(x) = *(__force __typeof__((ptr)))&__x; \
		208	} \
		209	break; \
		210	} \
		211	default: (x) = 0; __get_user_bad(); \
203	} \	212	} \
204	} while (0)	213	} while (0)
205		214
@@ -208,25 +217,28 @@ do { \ · 2 unmodified lines
208	* WARNING: If you modify this macro at all, verify that the	217	* WARNING: If you modify this macro at all, verify that the
209	* __check_align_* macros still work.	218	* __check_align_* macros still work.
210	*/	219	*/
211	#define __get_user_asm(x, addr, err, align, insn, cb) \	220	#define __get_user_asm(x_, addr_, err_, align, insn, cb) \
212	__asm__ __volatile__( \	221	do { \
213	__check_align_##align \	222	u32 __x = 0; \
214	"1: "insn" %2, %3, 0 \n" \	223	__asm__ __volatile__( \
215	"2: \n" \	224	__check_align_##align \
216	" .section .fixup,\"ax\" \n" \	225	"1: "insn" %[x], %[addr], 0 \n" \
217	" .align 4 \n" \	226	"2: \n" \
218	" .literal_position \n" \	227	" .section .fixup,\"ax\" \n" \
219	"5: \n" \	228	" .align 4 \n" \
220	" movi %1, 2b \n" \	229	" .literal_position \n" \
221	" movi %2, 0 \n" \	230	"5: \n" \
222	" movi %0, %4 \n" \	231	" movi %[tmp], 2b \n" \
223	" jx %1 \n" \	232	" movi %[err], %[efault] \n" \
224	" .previous \n" \	233	" jx %[tmp] \n" \
225	" .section __ex_table,\"a\" \n" \	234	" .previous \n" \
226	" .long 1b, 5b \n" \	235	" .section __ex_table,\"a\" \n" \
227	" .previous" \	236	" .long 1b, 5b \n" \
228	:"=r" (err), "=r" (cb), "=r" (x) \	237	" .previous" \
229	:"r" (addr), "i" (-EFAULT), "0" (err))	238	:[err] "+r"(err_), [tmp] "=r"(cb), [x] "+r"(__x) \
		239	:[addr] "r"(addr_), [efault] "i"(-EFAULT)); \
		240	(x_) = (__force __typeof__(*(addr_)))__x; \
		241	} while (0)
230		242
231		243
232	/*	244	/*

arch/xtensa/kernel/xtensa_ksyms.c+0−7

@@ -119,13 +119,6 @@ EXPORT_SYMBOL(__invalidate_icache_range); · 118 unmodified lines
119	// FIXME EXPORT_SYMBOL(screen_info);	119	// FIXME EXPORT_SYMBOL(screen_info);
120	#endif	120	#endif
121		121
122	EXPORT_SYMBOL(outsb);
123	EXPORT_SYMBOL(outsw);
124	EXPORT_SYMBOL(outsl);
125	EXPORT_SYMBOL(insb);
126	EXPORT_SYMBOL(insw);
127	EXPORT_SYMBOL(insl);
128
129	extern long common_exception_return;	122	extern long common_exception_return;
130	EXPORT_SYMBOL(common_exception_return);	123	EXPORT_SYMBOL(common_exception_return);
131		124

block/blk-cgroup.c+51−18

@@ -1362,7 +1362,7 @@ int blkcg_activate_policy(struct request_queue *q, · 1361 unmodified lines
1362	const struct blkcg_policy *pol)	1362	const struct blkcg_policy *pol)
1363	{	1363	{
1364	struct blkg_policy_data *pd_prealloc = NULL;	1364	struct blkg_policy_data *pd_prealloc = NULL;
1365	struct blkcg_gq *blkg;	1365	struct blkcg_gq blkg, pinned_blkg = NULL;
1366	int ret;	1366	int ret;
1367		1367
1368	if (blkcg_policy_enabled(q, pol))	1368	if (blkcg_policy_enabled(q, pol))
@@ -1370,49 +1370,82 @@ int blkcg_activate_policy(struct request_queue *q, · 1 unmodified line
1370		1370
1371	if (queue_is_mq(q))	1371	if (queue_is_mq(q))
1372	blk_mq_freeze_queue(q);	1372	blk_mq_freeze_queue(q);
1373	pd_prealloc:	1373	retry:
1374	if (!pd_prealloc) {
1375	pd_prealloc = pol->pd_alloc_fn(GFP_KERNEL, q, &blkcg_root);
1376	if (!pd_prealloc) {
1377	ret = -ENOMEM;
1378	goto out_bypass_end;
1379	}
1380	}
1381
1382	spin_lock_irq(&q->queue_lock);	1374	spin_lock_irq(&q->queue_lock);
1383		1375
1384	/* blkg_list is pushed at the head, reverse walk to init parents first */	1376	/* blkg_list is pushed at the head, reverse walk to allocate parents first */
1385	list_for_each_entry_reverse(blkg, &q->blkg_list, q_node) {	1377	list_for_each_entry_reverse(blkg, &q->blkg_list, q_node) {
1386	struct blkg_policy_data *pd;	1378	struct blkg_policy_data *pd;
1387		1379
1388	if (blkg->pd[pol->plid])	1380	if (blkg->pd[pol->plid])
1389	continue;	1381	continue;
1390		1382
1391	pd = pol->pd_alloc_fn(GFP_NOWAIT \| __GFP_NOWARN, q, &blkcg_root);	1383	/* If prealloc matches, use it; otherwise try GFP_NOWAIT */
1392	if (!pd)	1384	if (blkg == pinned_blkg) {
1393	swap(pd, pd_prealloc);	1385	pd = pd_prealloc;
		1386	pd_prealloc = NULL;
		1387	} else {
		1388	pd = pol->pd_alloc_fn(GFP_NOWAIT \| __GFP_NOWARN, q,
		1389	blkg->blkcg);
		1390	}
		1391
1394	if (!pd) {	1392	if (!pd) {
		1393	/*
		1394	* GFP_NOWAIT failed. Free the existing one and
		1395	* prealloc for @blkg w/ GFP_KERNEL.
		1396	*/
		1397	if (pinned_blkg)
		1398	blkg_put(pinned_blkg);
		1399	blkg_get(blkg);
		1400	pinned_blkg = blkg;
		1401
1395	spin_unlock_irq(&q->queue_lock);	1402	spin_unlock_irq(&q->queue_lock);
1396	goto pd_prealloc;	1403
		1404	if (pd_prealloc)
		1405	pol->pd_free_fn(pd_prealloc);
		1406	pd_prealloc = pol->pd_alloc_fn(GFP_KERNEL, q,
		1407	blkg->blkcg);
		1408	if (pd_prealloc)
		1409	goto retry;
		1410	else
		1411	goto enomem;
1397	}	1412	}
1398		1413
1399	blkg->pd[pol->plid] = pd;	1414	blkg->pd[pol->plid] = pd;
1400	pd->blkg = blkg;	1415	pd->blkg = blkg;
1401	pd->plid = pol->plid;	1416	pd->plid = pol->plid;
1402	if (pol->pd_init_fn)
1403	pol->pd_init_fn(pd);
1404	}	1417	}
1405		1418
		1419	/* all allocated, init in the same order */
		1420	if (pol->pd_init_fn)
		1421	list_for_each_entry_reverse(blkg, &q->blkg_list, q_node)
		1422	pol->pd_init_fn(blkg->pd[pol->plid]);
		1423
1406	__set_bit(pol->plid, q->blkcg_pols);	1424	__set_bit(pol->plid, q->blkcg_pols);
1407	ret = 0;	1425	ret = 0;
1408		1426
1409	spin_unlock_irq(&q->queue_lock);	1427	spin_unlock_irq(&q->queue_lock);
1410	out_bypass_end:	1428	out:
1411	if (queue_is_mq(q))	1429	if (queue_is_mq(q))
1412	blk_mq_unfreeze_queue(q);	1430	blk_mq_unfreeze_queue(q);
		1431	if (pinned_blkg)
		1432	blkg_put(pinned_blkg);
1413	if (pd_prealloc)	1433	if (pd_prealloc)
1414	pol->pd_free_fn(pd_prealloc);	1434	pol->pd_free_fn(pd_prealloc);
1415	return ret;	1435	return ret;
		1436
		1437	enomem:
		1438	/* alloc failed, nothing's initialized yet, free everything */
		1439	spin_lock_irq(&q->queue_lock);
		1440	list_for_each_entry(blkg, &q->blkg_list, q_node) {
		1441	if (blkg->pd[pol->plid]) {
		1442	pol->pd_free_fn(blkg->pd[pol->plid]);
		1443	blkg->pd[pol->plid] = NULL;
		1444	}
		1445	}
		1446	spin_unlock_irq(&q->queue_lock);
		1447	ret = -ENOMEM;
		1448	goto out;
1416	}	1449	}
1417	EXPORT_SYMBOL_GPL(blkcg_activate_policy);	1450	EXPORT_SYMBOL_GPL(blkcg_activate_policy);
1418		1451

block/blk-rq-qos.c+9−5

 	return ret;
 }
-void rq_depth_scale_up(struct rq_depth *rqd)
+/* Returns true on success and false if scaling up wasn't possible */
+bool rq_depth_scale_up(struct rq_depth *rqd)
 {
 	/*
 	 * Hit max in previous round, stop here
 	 */
 	if (rqd->scaled_max)
-		return;
+		return false;
 	rqd->scale_step--;
 	rqd->scaled_max = rq_depth_calc_max_depth(rqd);
+	return true;
 }
 /*
  * Scale rwb down. If 'hard_throttle' is set, do it quicker, since we
- * had a latency violation.
+ * had a latency violation. Returns true on success and returns false if
+ * scaling down wasn't possible.
  */
-void rq_depth_scale_down(struct rq_depth *rqd, bool hard_throttle)
+bool rq_depth_scale_down(struct rq_depth *rqd, bool hard_throttle)
 {
 	/*
 	 * Stop scaling down when we've hit the limit. This also prevents
 	 * keep up.
 	 */
 	if (rqd->max_depth == 1)
-		return;
+		return false;
 	if (rqd->scale_step < 0 && hard_throttle)
 		rqd->scale_step = 0;
 	rqd->scaled_max = false;
 	rq_depth_calc_max_depth(rqd);
+	return true;
 }
 struct rq_qos_wait_data {

block/blk-rq-qos.h+7−10

@@ -108,16 +108,13 @@ static inline void rq_qos_add(struct request_queue q, struct rq_qos rqos) · 107 unmodified lines
108		108
109	static inline void rq_qos_del(struct request_queue q, struct rq_qos rqos)	109	static inline void rq_qos_del(struct request_queue q, struct rq_qos rqos)
110	{	110	{
111	struct rq_qos cur, prev = NULL;	111	struct rq_qos **cur;
112	for (cur = q->rq_qos; cur; cur = cur->next) {	112
113	if (cur == rqos) {	113	for (cur = &q->rq_qos; cur; cur = &(cur)->next) {
114	if (prev)	114	if (*cur == rqos) {
115	prev->next = rqos->next;	115	*cur = rqos->next;
116	else
117	q->rq_qos = cur;
118	break;	116	break;
119	}	117	}
120	prev = cur;
121	}	118	}
122		119
123	blk_mq_debugfs_unregister_rqos(rqos);	120	blk_mq_debugfs_unregister_rqos(rqos);
@@ -130,8 +127,8 @@ void rq_qos_wait(struct rq_wait rqw, void private_data, · 6 unmodified lines
130	acquire_inflight_cb_t *acquire_inflight_cb,	127	acquire_inflight_cb_t *acquire_inflight_cb,
131	cleanup_cb_t *cleanup_cb);	128	cleanup_cb_t *cleanup_cb);
132	bool rq_wait_inc_below(struct rq_wait *rq_wait, unsigned int limit);	129	bool rq_wait_inc_below(struct rq_wait *rq_wait, unsigned int limit);
133	void rq_depth_scale_up(struct rq_depth *rqd);	130	bool rq_depth_scale_up(struct rq_depth *rqd);
134	void rq_depth_scale_down(struct rq_depth *rqd, bool hard_throttle);	131	bool rq_depth_scale_down(struct rq_depth *rqd, bool hard_throttle);
135	bool rq_depth_calc_max_depth(struct rq_depth *rqd);	132	bool rq_depth_calc_max_depth(struct rq_depth *rqd);
136		133
137	void __rq_qos_cleanup(struct rq_qos rqos, struct bio bio);	134	void __rq_qos_cleanup(struct rq_qos rqos, struct bio bio);

block/blk-wbt.c+4−2

 static void scale_up(struct rq_wb *rwb)
 {
-	rq_depth_scale_up(&rwb->rq_depth);
+	if (!rq_depth_scale_up(&rwb->rq_depth))
+		return;
 	calc_wb_limits(rwb);
 	rwb->unknown_cnt = 0;
 	rwb_wake_all(rwb);
 static void scale_down(struct rq_wb *rwb, bool hard_throttle)
 {
-	rq_depth_scale_down(&rwb->rq_depth, hard_throttle);
+	if (!rq_depth_scale_down(&rwb->rq_depth, hard_throttle))
+		return;
 	calc_wb_limits(rwb);
 	rwb->unknown_cnt = 0;
 	rwb_trace_step(rwb, "scale down");

block/elevator.c+2−1

@@ -616,7 +616,8 @@ out: · 615 unmodified lines
616		616
617	static inline bool elv_support_iosched(struct request_queue *q)	617	static inline bool elv_support_iosched(struct request_queue *q)
618	{	618	{
619	if (q->tag_set && (q->tag_set->flags & BLK_MQ_F_NO_SCHED))	619	if (!q->mq_ops \|\|
		620	(q->tag_set && (q->tag_set->flags & BLK_MQ_F_NO_SCHED)))
620	return false;	621	return false;
621	return true;	622	return true;
622	}	623	}

drivers/acpi/cppc_acpi.c+1−1

 			pcc_data[pcc_ss_id]->refcount--;
 			if (!pcc_data[pcc_ss_id]->refcount) {
 				pcc_mbox_free_channel(pcc_data[pcc_ss_id]->pcc_channel);
-				pcc_data[pcc_ss_id]->pcc_channel_acquired = 0;
 				kfree(pcc_data[pcc_ss_id]);
+				pcc_data[pcc_ss_id] = NULL;
 			}
 		}
 	}

drivers/acpi/hmat/hmat.c+1−1

@@ -403,7 +403,7 @@ static int __init hmat_parse_proximity_domain(union acpi_subtable_headers *heade · 402 unmodified lines
403	pr_info("HMAT: Memory Flags:%04x Processor Domain:%d Memory Domain:%d\n",	403	pr_info("HMAT: Memory Flags:%04x Processor Domain:%d Memory Domain:%d\n",
404	p->flags, p->processor_PD, p->memory_PD);	404	p->flags, p->processor_PD, p->memory_PD);
405		405
406	if (p->flags & ACPI_HMAT_MEMORY_PD_VALID) {	406	if (p->flags & ACPI_HMAT_MEMORY_PD_VALID && hmat_revision == 1) {
407	target = find_mem_target(p->memory_PD);	407	target = find_mem_target(p->memory_PD);
408	if (!target) {	408	if (!target) {
409	pr_debug("HMAT: Memory Domain missing from SRAT\n");	409	pr_debug("HMAT: Memory Domain missing from SRAT\n");

drivers/acpi/processor_perflib.c+6−4

 	struct acpi_processor *pr = per_cpu(processors, cpu);
 	int ret;
+	if (!pr)
+		return;
 	ret = dev_pm_qos_add_request(get_cpu_device(cpu),
 				     &pr->perflib_req, DEV_PM_QOS_MAX_FREQUENCY,
 				     INT_MAX);
-	if (ret < 0) {
+	if (ret < 0)
 		pr_err("Failed to add freq constraint for CPU%d (%d)\n", cpu,
 		       ret);
-		return;
-	}
 }
 void acpi_processor_ppc_exit(int cpu)
 {
 	struct acpi_processor *pr = per_cpu(processors, cpu);
-	dev_pm_qos_remove_request(&pr->perflib_req);
+	if (pr)
+		dev_pm_qos_remove_request(&pr->perflib_req);
 }
 static int acpi_processor_get_performance_control(struct acpi_processor *pr)

drivers/acpi/processor_thermal.c+6−4

 	struct acpi_processor *pr = per_cpu(processors, cpu);
 	int ret;
+	if (!pr)
+		return;
 	ret = dev_pm_qos_add_request(get_cpu_device(cpu),
 				     &pr->thermal_req, DEV_PM_QOS_MAX_FREQUENCY,
 				     INT_MAX);
-	if (ret < 0) {
+	if (ret < 0)
 		pr_err("Failed to add freq constraint for CPU%d (%d)\n", cpu,
 		       ret);
-		return;
-	}
 }
 void acpi_thermal_cpufreq_exit(int cpu)
 {
 	struct acpi_processor *pr = per_cpu(processors, cpu);
-	dev_pm_qos_remove_request(&pr->thermal_req);
+	if (pr)
+		dev_pm_qos_remove_request(&pr->thermal_req);
 }
 #else				/* ! CONFIG_CPU_FREQ */
 static int cpufreq_get_max_state(unsigned int cpu)

drivers/acpi/sleep.c+0−13

@@ -361,19 +361,6 @@ static const struct dmi_system_id acpisleep_dmi_table[] __initconst = { · 360 unmodified lines
361	DMI_MATCH(DMI_PRODUCT_NAME, "80E3"),	361	DMI_MATCH(DMI_PRODUCT_NAME, "80E3"),
362	},	362	},
363	},	363	},
364	/*
365	* https://bugzilla.kernel.org/show_bug.cgi?id=196907
366	* Some Dell XPS13 9360 cannot do suspend-to-idle using the Low Power
367	* S0 Idle firmware interface.
368	*/
369	{
370	.callback = init_default_s3,
371	.ident = "Dell XPS13 9360",
372	.matches = {
373	DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
374	DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9360"),
375	},
376	},
377	/*	364	/*
378	* ThinkPad X1 Tablet(2016) cannot do suspend-to-idle using	365	* ThinkPad X1 Tablet(2016) cannot do suspend-to-idle using
379	* the Low Power S0 Idle firmware interface (see	366	* the Low Power S0 Idle firmware interface (see

drivers/android/binder.c+3−1

 #include <linux/sched/signal.h>
 #include <linux/sched/mm.h>
 #include <linux/seq_file.h>
+#include <linux/string.h>
 #include <linux/uaccess.h>
 #include <linux/pid_namespace.h>
 #include <linux/security.h>
 #include <linux/task_work.h>
 #include <uapi/linux/android/binder.h>
+#include <uapi/linux/android/binderfs.h>
 #include <asm/cacheflush.h>
 	e->target_handle = tr->target.handle;
 	e->data_size = tr->data_size;
 	e->offsets_size = tr->offsets_size;
-	e->context_name = proc->context->name;
+	strscpy(e->context_name, proc->context->name, BINDERFS_MAX_NAME);
 	if (reply) {
 		binder_inner_proc_lock(proc);

drivers/android/binder_alloc.c+1−1

@@ -156,7 +156,7 @@ static struct binder_buffer *binder_alloc_prepare_to_free_locked( · 155 unmodified lines
156	}	156	}
157		157
158	/**	158	/**
159	* binder_alloc_buffer_lookup() - get buffer given user ptr	159	* binder_alloc_prepare_to_free() - get buffer given user ptr
160	* @alloc: binder_alloc for this proc	160	* @alloc: binder_alloc for this proc
161	* @user_ptr: User pointer to buffer data	161	* @user_ptr: User pointer to buffer data
162	*	162	*

drivers/android/binder_internal.h+1−1

@@ -130,7 +130,7 @@ struct binder_transaction_log_entry { · 129 unmodified lines
130	int return_error_line;	130	int return_error_line;
131	uint32_t return_error;	131	uint32_t return_error;
132	uint32_t return_error_param;	132	uint32_t return_error_param;
133	const char *context_name;	133	char context_name[BINDERFS_MAX_NAME + 1];
134	};	134	};
135		135
136	struct binder_transaction_log {	136	struct binder_transaction_log {

drivers/ata/ahci.c+3−1

@@ -1600,7 +1600,9 @@ static void ahci_intel_pcs_quirk(struct pci_dev pdev, struct ahci_host_priv hp · 1599 unmodified lines
1600	*/	1600	*/
1601	if (!id \|\| id->vendor != PCI_VENDOR_ID_INTEL)	1601	if (!id \|\| id->vendor != PCI_VENDOR_ID_INTEL)
1602	return;	1602	return;
1603	if (((enum board_ids) id->driver_data) < board_ahci_pcs7)	1603
		1604	/* Skip applying the quirk on Denverton and beyond */
		1605	if (((enum board_ids) id->driver_data) >= board_ahci_pcs7)
1604	return;	1606	return;
1605		1607
1606	/*	1608	/*

drivers/ata/libata-scsi.c+0−21

@@ -4791,27 +4791,6 @@ void ata_scsi_hotplug(struct work_struct *work) · 4790 unmodified lines
4791	return;	4791	return;
4792	}	4792	}
4793		4793
4794	/*
4795	* XXX - UGLY HACK
4796	*
4797	* The block layer suspend/resume path is fundamentally broken due
4798	* to freezable kthreads and workqueue and may deadlock if a block
4799	* device gets removed while resume is in progress. I don't know
4800	* what the solution is short of removing freezable kthreads and
4801	* workqueues altogether.
4802	*
4803	* The following is an ugly hack to avoid kicking off device
4804	* removal while freezer is active. This is a joke but does avoid
4805	* this particular deadlock scenario.
4806	*
4807	* https://bugzilla.kernel.org/show_bug.cgi?id=62801
4808	* http://marc.info/?l=linux-kernel&m=138695698516487
4809	*/
4810	#ifdef CONFIG_FREEZER
4811	while (pm_freezing)
4812	msleep(10);
4813	#endif
4814
4815	DPRINTK("ENTER\n");	4794	DPRINTK("ENTER\n");
4816	mutex_lock(&ap->scsi_scan_mutex);	4795	mutex_lock(&ap->scsi_scan_mutex);
4817		4796

drivers/base/core.c+3−0

  */
 #include <linux/acpi.h>
+#include <linux/cpufreq.h>
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/fwnode.h>
 	wait_for_device_probe();
 	device_block_probing();
+	cpufreq_suspend();
 	spin_lock(&devices_kset->list_lock);
 	/*
 	 * Walk the devices list backward, shutting down each in turn.

drivers/base/memory.c+3−0

 	pfn >>= PAGE_SHIFT;
 	if (!pfn_valid(pfn))
 		return -ENXIO;
+	/* Only online pages can be soft-offlined (esp., not ZONE_DEVICE). */
+	if (!pfn_to_online_page(pfn))
+		return -EIO;
 	ret = soft_offline_page(pfn_to_page(pfn), 0);
 	return ret == 0 ? count : ret;
 }

drivers/base/platform.c+39−7

@@ -241,12 +241,8 @@ struct resource platform_get_resource_byname(struct platform_device dev, · 240 unmodified lines
241	}	241	}
242	EXPORT_SYMBOL_GPL(platform_get_resource_byname);	242	EXPORT_SYMBOL_GPL(platform_get_resource_byname);
243		243
244	/**	244	static int __platform_get_irq_byname(struct platform_device *dev,
245	* platform_get_irq_byname - get an IRQ for a device by name	245	const char *name)
246	* @dev: platform device
247	* @name: IRQ name
248	*/
249	int platform_get_irq_byname(struct platform_device dev, const char name)
250	{	246	{
251	struct resource *r;	247	struct resource *r;
252		248
@@ -262,11 +258,47 @@ int platform_get_irq_byname(struct platform_device dev, const char name) · 9 unmodified lines
262	if (r)	258	if (r)
263	return r->start;	259	return r->start;
264		260
265	dev_err(&dev->dev, "IRQ %s not found\n", name);
266	return -ENXIO;	261	return -ENXIO;
267	}	262	}
		263
		264	/**
		265	* platform_get_irq_byname - get an IRQ for a device by name
		266	* @dev: platform device
		267	* @name: IRQ name
		268	*
		269	* Get an IRQ like platform_get_irq(), but then by name rather then by index.
		270	*
		271	* Return: IRQ number on success, negative error number on failure.
		272	*/
		273	int platform_get_irq_byname(struct platform_device dev, const char name)
		274	{
		275	int ret;
		276
		277	ret = __platform_get_irq_byname(dev, name);
		278	if (ret < 0 && ret != -EPROBE_DEFER)
		279	dev_err(&dev->dev, "IRQ %s not found\n", name);
		280
		281	return ret;
		282	}
268	EXPORT_SYMBOL_GPL(platform_get_irq_byname);	283	EXPORT_SYMBOL_GPL(platform_get_irq_byname);
269		284
		285	/**
		286	* platform_get_irq_byname_optional - get an optional IRQ for a device by name
		287	* @dev: platform device
		288	* @name: IRQ name
		289	*
		290	* Get an optional IRQ by name like platform_get_irq_byname(). Except that it
		291	* does not print an error message if an IRQ can not be obtained.
		292	*
		293	* Return: IRQ number on success, negative error number on failure.
		294	*/
		295	int platform_get_irq_byname_optional(struct platform_device *dev,
		296	const char *name)
		297	{
		298	return __platform_get_irq_byname(dev, name);
		299	}
		300	EXPORT_SYMBOL_GPL(platform_get_irq_byname_optional);
		301
270	/**	302	/**
271	* platform_add_devices - add a numbers of platform devices	303	* platform_add_devices - add a numbers of platform devices
272	* @devs: array of platform devices to add	304	* @devs: array of platform devices to add

drivers/block/nbd.c+1−1

 	if (refcount_dec_and_mutex_lock(&nbd->refs,
 					&nbd_index_mutex)) {
 		idr_remove(&nbd_index_idr, nbd->index);
-		mutex_unlock(&nbd_index_mutex);
 		nbd_dev_remove(nbd);
+		mutex_unlock(&nbd_index_mutex);
 	}
 }

drivers/block/null_blk_zoned.c+1−2

 		zone->wp = zone->start;
 		break;
 	default:
-		cmd->error = BLK_STS_NOTSUPP;
+		return BLK_STS_NOTSUPP;
-		break;
 	}
 	return BLK_STS_OK;
 }

drivers/block/rbd.c+6−3

 	queue_delayed_work(rbd_dev->task_wq, &rbd_dev->lock_dwork, 0);
 	ret = wait_for_completion_killable_timeout(&rbd_dev->acquire_wait,
 			    ceph_timeout_jiffies(rbd_dev->opts->lock_timeout));
-	if (ret > 0)
+	if (ret > 0) {
 		ret = rbd_dev->acquire_err;
-	else if (!ret)
+	} else {
-		ret = -ETIMEDOUT;
+		cancel_delayed_work_sync(&rbd_dev->lock_dwork);
+		if (!ret)
+			ret = -ETIMEDOUT;
+	}
 	if (ret) {
 		rbd_warn(rbd_dev, "failed to acquire exclusive lock: %ld", ret);

drivers/block/zram/zram_drv.c+3−2

 static ssize_t backing_dev_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
+	struct file *file;
 	struct zram *zram = dev_to_zram(dev);
-	struct file *file = zram->backing_dev;
 	char *p;
 	ssize_t ret;
 	down_read(&zram->init_lock);
-	if (!zram->backing_dev) {
+	file = zram->backing_dev;
+	if (!file) {
 		memcpy(buf, "none\n", 5);
 		up_read(&zram->init_lock);
 		return 5;

drivers/cpufreq/cpufreq.c+0−10

 }
 EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
-/*
- * Stop cpufreq at shutdown to make sure it isn't holding any locks
- * or mutexes when secondary CPUs are halted.
- */
-static struct syscore_ops cpufreq_syscore_ops = {
-	.shutdown = cpufreq_suspend,
-};
 struct kobject *cpufreq_global_kobject;
 EXPORT_SYMBOL(cpufreq_global_kobject);
 	cpufreq_global_kobject = kobject_create_and_add("cpufreq", &cpu_subsys.dev_root->kobj);
 	BUG_ON(!cpufreq_global_kobject);
-	register_syscore_ops(&cpufreq_syscore_ops);
 	return 0;
 }
 module_param(off, int, 0444);

drivers/firmware/dmi_scan.c+1−1

@@ -408,7 +408,7 @@ static void __init save_mem_devices(const struct dmi_header dm, void v) · 407 unmodified lines
408	bytes = ~0ull;	408	bytes = ~0ull;
409	else if (size & 0x8000)	409	else if (size & 0x8000)
410	bytes = (u64)(size & 0x7fff) << 10;	410	bytes = (u64)(size & 0x7fff) << 10;
411	else if (size != 0x7fff)	411	else if (size != 0x7fff \|\| dm->length < 0x20)
412	bytes = (u64)size << 20;	412	bytes = (u64)size << 20;
413	else	413	else
414	bytes = (u64)get_unaligned((u32 *)&d[0x1C]) << 20;	414	bytes = (u64)get_unaligned((u32 *)&d[0x1C]) << 20;

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

@@ -381,7 +381,7 @@ static void cper_print_pcie(const char pfx, const struct cper_sec_pcie pcie, · 380 unmodified lines
381	printk("%s""vendor_id: 0x%04x, device_id: 0x%04x\n", pfx,	381	printk("%s""vendor_id: 0x%04x, device_id: 0x%04x\n", pfx,
382	pcie->device_id.vendor_id, pcie->device_id.device_id);	382	pcie->device_id.vendor_id, pcie->device_id.device_id);
383	p = pcie->device_id.class_code;	383	p = pcie->device_id.class_code;
384	printk("%s""class_code: %02x%02x%02x\n", pfx, p[0], p[1], p[2]);	384	printk("%s""class_code: %02x%02x%02x\n", pfx, p[2], p[1], p[0]);
385	}	385	}
386	if (pcie->validation_bits & CPER_PCIE_VALID_SERIAL_NUMBER)	386	if (pcie->validation_bits & CPER_PCIE_VALID_SERIAL_NUMBER)
387	printk("%s""serial number: 0x%04x, 0x%04x\n", pfx,	387	printk("%s""serial number: 0x%04x, 0x%04x\n", pfx,

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

@@ -267,6 +267,9 @@ static __init int efivar_ssdt_load(void) · 266 unmodified lines
267	void *data;	267	void *data;
268	int ret;	268	int ret;
269		269
		270	if (!efivar_ssdt[0])
		271	return 0;
		272
270	ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries);	273	ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries);
271		274
272	list_for_each_entry_safe(entry, aux, &entries, list) {	275	list_for_each_entry_safe(entry, aux, &entries, list) {

drivers/firmware/efi/rci2-table.c+1−1

@@ -76,7 +76,7 @@ static u16 checksum(void) · 75 unmodified lines
76	return chksum;	76	return chksum;
77	}	77	}
78		78
79	int __init efi_rci2_sysfs_init(void)	79	static int __init efi_rci2_sysfs_init(void)
80	{	80	{
81	struct kobject *tables_kobj;	81	struct kobject *tables_kobj;
82	int ret = -ENOMEM;	82	int ret = -ENOMEM;

drivers/firmware/efi/tpm.c+19−7

 {
 	struct linux_efi_tpm_eventlog *log_tbl;
 	struct efi_tcg2_final_events_table *final_tbl;
-	unsigned int tbl_size;
+	int tbl_size;
 	int ret = 0;
 	if (efi.tpm_log == EFI_INVALID_TABLE_ADDR) {
 		goto out;
 	}
-	tbl_size = tpm2_calc_event_log_size((void *)efi.tpm_final_log
+	tbl_size = 0;
-					    + sizeof(final_tbl->version)
+	if (final_tbl->nr_events != 0) {
-					    + sizeof(final_tbl->nr_events),
+		void *events = (void *)efi.tpm_final_log
-					    final_tbl->nr_events,
+				+ sizeof(final_tbl->version)
-					    log_tbl->log);
+				+ sizeof(final_tbl->nr_events);
+		tbl_size = tpm2_calc_event_log_size(events,
+						    final_tbl->nr_events,
+						    log_tbl->log);
+	}
+	if (tbl_size < 0) {
+		pr_err(FW_BUG "Failed to parse event in TPM Final Events Log\n");
+		goto out_calc;
+	}
 	memblock_reserve((unsigned long)final_tbl,
 			 tbl_size + sizeof(*final_tbl));
-	early_memunmap(final_tbl, sizeof(*final_tbl));
 	efi_tpm_final_log_size = tbl_size;
+out_calc:
+	early_memunmap(final_tbl, sizeof(*final_tbl));
 out:
 	early_memunmap(log_tbl, sizeof(*log_tbl));
 	return ret;

drivers/firmware/google/vpd_decode.c+1−1

@@ -52,7 +52,7 @@ static int vpd_decode_entry(const u32 max_len, const u8 *input_buf, · 51 unmodified lines
52	if (max_len - consumed < *entry_len)	52	if (max_len - consumed < *entry_len)
53	return VPD_FAIL;	53	return VPD_FAIL;
54		54
55	consumed += decoded_len;	55	consumed += *entry_len;
56	*_consumed = consumed;	56	*_consumed = consumed;
57	return VPD_OK;	57	return VPD_OK;
58	}	58	}

drivers/gpio/gpio-eic-sprd.c+4−3

@@ -530,11 +530,12 @@ static void sprd_eic_handle_one_type(struct gpio_chip *chip) · 529 unmodified lines
530	}	530	}
531		531
532	for_each_set_bit(n, &reg, SPRD_EIC_PER_BANK_NR) {	532	for_each_set_bit(n, &reg, SPRD_EIC_PER_BANK_NR) {
533	girq = irq_find_mapping(chip->irq.domain,	533	u32 offset = bank * SPRD_EIC_PER_BANK_NR + n;
534	bank * SPRD_EIC_PER_BANK_NR + n);	534
		535	girq = irq_find_mapping(chip->irq.domain, offset);
535		536
536	generic_handle_irq(girq);	537	generic_handle_irq(girq);
537	sprd_eic_toggle_trigger(chip, girq, n);	538	sprd_eic_toggle_trigger(chip, girq, offset);
538	}	539	}
539	}	540	}
540	}	541	}

drivers/gpio/gpio-intel-mid.c+6−3

 	chip->irq_eoi(data);
 }
-static void intel_mid_irq_init_hw(struct intel_mid_gpio *priv)
+static int intel_mid_irq_init_hw(struct gpio_chip *chip)
 {
+	struct intel_mid_gpio *priv = gpiochip_get_data(chip);
 	void __iomem *reg;
 	unsigned base;
 		reg = gpio_reg(&priv->chip, base, GEDR);
 		writel(~0, reg);
 	}
+	return 0;
 }
 static int __maybe_unused intel_gpio_runtime_idle(struct device *dev)
 	girq = &priv->chip.irq;
 	girq->chip = &intel_mid_irqchip;
+	girq->init_hw = intel_mid_irq_init_hw;
 	girq->parent_handler = intel_mid_irq_handler;
 	girq->num_parents = 1;
 	girq->parents = devm_kcalloc(&pdev->dev, girq->num_parents,
 	girq->default_type = IRQ_TYPE_NONE;
 	girq->handler = handle_simple_irq;
-	intel_mid_irq_init_hw(priv);
 	pci_set_drvdata(pdev, priv);
 	retval = devm_gpiochip_add_data(&pdev->dev, &priv->chip, priv);
 	if (retval) {
 		dev_err(&pdev->dev, "gpiochip_add error %d\n", retval);

drivers/gpio/gpio-lynxpoint.c+6−4

 	.flags = IRQCHIP_SKIP_SET_WAKE,
 };
-static void lp_gpio_irq_init_hw(struct lp_gpio *lg)
+static int lp_gpio_irq_init_hw(struct gpio_chip *chip)
 {
+	struct lp_gpio *lg = gpiochip_get_data(chip);
 	unsigned long reg;
 	unsigned base;
 		reg = lp_gpio_reg(&lg->chip, base, LP_INT_STAT);
 		outl(0xffffffff, reg);
 	}
+	return 0;
 }
 static int lp_gpio_probe(struct platform_device *pdev)
 		girq = &gc->irq;
 		girq->chip = &lp_irqchip;
+		girq->init_hw = lp_gpio_irq_init_hw;
 		girq->parent_handler = lp_gpio_irq_handler;
 		girq->num_parents = 1;
 		girq->parents = devm_kcalloc(&pdev->dev, girq->num_parents,
 			return -ENOMEM;
 		girq->parents[0] = (unsigned)irq_rc->start;
 		girq->default_type = IRQ_TYPE_NONE;
-		girq->handler = handle_simple_irq;
+		girq->handler = handle_bad_irq;
-		lp_gpio_irq_init_hw(lg);
 	}
 	ret = devm_gpiochip_add_data(dev, gc, lg);

drivers/gpio/gpio-max77620.c+3−3

@@ -192,13 +192,13 @@ static int max77620_gpio_set_debounce(struct max77620_gpio *mgpio, · 191 unmodified lines
192	case 0:	192	case 0:
193	val = MAX77620_CNFG_GPIO_DBNC_None;	193	val = MAX77620_CNFG_GPIO_DBNC_None;
194	break;	194	break;
195	case 1 ... 8:	195	case 1000 ... 8000:
196	val = MAX77620_CNFG_GPIO_DBNC_8ms;	196	val = MAX77620_CNFG_GPIO_DBNC_8ms;
197	break;	197	break;
198	case 9 ... 16:	198	case 9000 ... 16000:
199	val = MAX77620_CNFG_GPIO_DBNC_16ms;	199	val = MAX77620_CNFG_GPIO_DBNC_16ms;
200	break;	200	break;
201	case 17 ... 32:	201	case 17000 ... 32000:
202	val = MAX77620_CNFG_GPIO_DBNC_32ms;	202	val = MAX77620_CNFG_GPIO_DBNC_32ms;
203	break;	203	break;
204	default:	204	default:

drivers/gpio/gpio-merrifield.c+6−3

 	chained_irq_exit(irqchip, desc);
 }
-static void mrfld_irq_init_hw(struct mrfld_gpio *priv)
+static int mrfld_irq_init_hw(struct gpio_chip *chip)
 {
+	struct mrfld_gpio *priv = gpiochip_get_data(chip);
 	void __iomem *reg;
 	unsigned int base;
 		reg = gpio_reg(&priv->chip, base, GFER);
 		writel(0, reg);
 	}
+	return 0;
 }
 static const char *mrfld_gpio_get_pinctrl_dev_name(struct mrfld_gpio *priv)
 	girq = &priv->chip.irq;
 	girq->chip = &mrfld_irqchip;
+	girq->init_hw = mrfld_irq_init_hw;
 	girq->parent_handler = mrfld_irq_handler;
 	girq->num_parents = 1;
 	girq->parents = devm_kcalloc(&pdev->dev, girq->num_parents,
 	if (!girq->parents)
 		return -ENOMEM;
 	girq->parents[0] = pdev->irq;
+	girq->first = irq_base;
 	girq->default_type = IRQ_TYPE_NONE;
 	girq->handler = handle_bad_irq;
-	mrfld_irq_init_hw(priv);
 	pci_set_drvdata(pdev, priv);
 	retval = devm_gpiochip_add_data(&pdev->dev, &priv->chip, priv);
 	if (retval) {

drivers/gpio/gpiolib-of.c+1−1

@@ -317,7 +317,7 @@ struct gpio_desc gpiod_get_from_of_node(struct device_node node, · 316 unmodified lines
317	transitory = flags & OF_GPIO_TRANSITORY;	317	transitory = flags & OF_GPIO_TRANSITORY;
318		318
319	ret = gpiod_request(desc, label);	319	ret = gpiod_request(desc, label);
320	if (ret == -EBUSY && (flags & GPIOD_FLAGS_BIT_NONEXCLUSIVE))	320	if (ret == -EBUSY && (dflags & GPIOD_FLAGS_BIT_NONEXCLUSIVE))
321	return desc;	321	return desc;
322	if (ret)	322	if (ret)
323	return ERR_PTR(ret);	323	return ERR_PTR(ret);

drivers/gpio/gpiolib.c+40−9

 				struct lock_class_key *lock_key,
 				struct lock_class_key *request_key);
 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
+static int gpiochip_irqchip_init_hw(struct gpio_chip *gpiochip);
 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip);
 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip);
 	machine_gpiochip_add(chip);
+	ret = gpiochip_irqchip_init_hw(chip);
+	if (ret)
+		goto err_remove_acpi_chip;
 	ret = gpiochip_irqchip_init_valid_mask(chip);
 	if (ret)
 		goto err_remove_acpi_chip;
  * The following is irqchip helper code for gpiochips.
  */
+static int gpiochip_irqchip_init_hw(struct gpio_chip *gc)
+{
+	struct gpio_irq_chip *girq = &gc->irq;
+	if (!girq->init_hw)
+		return 0;
+	return girq->init_hw(gc);
+}
 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gc)
 {
 	struct gpio_irq_chip *girq = &gc->irq;
 {
 	return 0;
 }
 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
+static inline int gpiochip_irqchip_init_hw(struct gpio_chip *gpiochip)
+{
+	return 0;
+}
 static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
 {
 	return 0;
 		if (!ret)
 			goto set_output_value;
 		/* Emulate open drain by not actively driving the line high */
-		if (value)
+		if (value) {
-			return gpiod_direction_input(desc);
+			ret = gpiod_direction_input(desc);
+			goto set_output_flag;
+		}
 	}
 	else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
 		ret = gpio_set_config(gc, gpio_chip_hwgpio(desc),
 		if (!ret)
 			goto set_output_value;
 		/* Emulate open source by not actively driving the line low */
-		if (!value)
+		if (!value) {
-			return gpiod_direction_input(desc);
+			ret = gpiod_direction_input(desc);
+			goto set_output_flag;
+		}
 	} else {
 		gpio_set_config(gc, gpio_chip_hwgpio(desc),
 				PIN_CONFIG_DRIVE_PUSH_PULL);
 set_output_value:
 	return gpiod_direction_output_raw_commit(desc, value);
+set_output_flag:
+	/*
+	 * When emulating open-source or open-drain functionalities by not
+	 * actively driving the line (setting mode to input) we still need to
+	 * set the IS_OUT flag or otherwise we won't be able to set the line
+	 * value anymore.
+	 */
+	if (ret == 0)
+		set_bit(FLAG_IS_OUT, &desc->flags);
+	return ret;
 }
 EXPORT_SYMBOL_GPL(gpiod_direction_output);
 	if (value) {
 		ret = chip->direction_input(chip, offset);
-		if (!ret)
-			clear_bit(FLAG_IS_OUT, &desc->flags);
 	} else {
 		ret = chip->direction_output(chip, offset, 0);
 		if (!ret)
 			set_bit(FLAG_IS_OUT, &desc->flags);
 	} else {
 		ret = chip->direction_input(chip, offset);
-		if (!ret)
-			clear_bit(FLAG_IS_OUT, &desc->flags);
 	}
 	trace_gpio_direction(desc_to_gpio(desc), !value, ret);
 	if (ret < 0)

drivers/gpu/drm/amd/amdgpu/amdgpu_bo_list.c+7−7

 	r = amdgpu_bo_create_list_entry_array(&args->in, &info);
 	if (r)
-		goto error_free;
+		return r;
 	switch (args->in.operation) {
 	case AMDGPU_BO_LIST_OP_CREATE:
 		r = idr_alloc(&fpriv->bo_list_handles, list, 1, 0, GFP_KERNEL);
 		mutex_unlock(&fpriv->bo_list_lock);
 		if (r < 0) {
-			amdgpu_bo_list_put(list);
+			goto error_put_list;
-			return r;
 		}
 		handle = r;
 		mutex_unlock(&fpriv->bo_list_lock);
 		if (IS_ERR(old)) {
-			amdgpu_bo_list_put(list);
 			r = PTR_ERR(old);
-			goto error_free;
+			goto error_put_list;
 		}
 		amdgpu_bo_list_put(old);
 	return 0;
+error_put_list:
+	amdgpu_bo_list_put(list);
 error_free:
-	if (info)
+	kvfree(info);
-		kvfree(info);
 	return r;
 }

drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c+35−0

@@ -1048,6 +1048,41 @@ static int amdgpu_pci_probe(struct pci_dev *pdev, · 1047 unmodified lines
1048	return -ENODEV;	1048	return -ENODEV;
1049	}	1049	}
1050		1050
		1051	#ifdef CONFIG_DRM_AMDGPU_SI
		1052	if (!amdgpu_si_support) {
		1053	switch (flags & AMD_ASIC_MASK) {
		1054	case CHIP_TAHITI:
		1055	case CHIP_PITCAIRN:
		1056	case CHIP_VERDE:
		1057	case CHIP_OLAND:
		1058	case CHIP_HAINAN:
		1059	dev_info(&pdev->dev,
		1060	"SI support provided by radeon.\n");
		1061	dev_info(&pdev->dev,
		1062	"Use radeon.si_support=0 amdgpu.si_support=1 to override.\n"
		1063	);
		1064	return -ENODEV;
		1065	}
		1066	}
		1067	#endif
		1068	#ifdef CONFIG_DRM_AMDGPU_CIK
		1069	if (!amdgpu_cik_support) {
		1070	switch (flags & AMD_ASIC_MASK) {
		1071	case CHIP_KAVERI:
		1072	case CHIP_BONAIRE:
		1073	case CHIP_HAWAII:
		1074	case CHIP_KABINI:
		1075	case CHIP_MULLINS:
		1076	dev_info(&pdev->dev,
		1077	"CIK support provided by radeon.\n");
		1078	dev_info(&pdev->dev,
		1079	"Use radeon.cik_support=0 amdgpu.cik_support=1 to override.\n"
		1080	);
		1081	return -ENODEV;
		1082	}
		1083	}
		1084	#endif
		1085
1051	/* Get rid of things like offb */	1086	/* Get rid of things like offb */
1052	ret = drm_fb_helper_remove_conflicting_pci_framebuffers(pdev, "amdgpudrmfb");	1087	ret = drm_fb_helper_remove_conflicting_pci_framebuffers(pdev, "amdgpudrmfb");
1053	if (ret)	1088	if (ret)

drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c+0−35

@@ -144,41 +144,6 @@ int amdgpu_driver_load_kms(struct drm_device *dev, unsigned long flags) · 143 unmodified lines
144	struct amdgpu_device *adev;	144	struct amdgpu_device *adev;
145	int r, acpi_status;	145	int r, acpi_status;
146		146
147	#ifdef CONFIG_DRM_AMDGPU_SI
148	if (!amdgpu_si_support) {
149	switch (flags & AMD_ASIC_MASK) {
150	case CHIP_TAHITI:
151	case CHIP_PITCAIRN:
152	case CHIP_VERDE:
153	case CHIP_OLAND:
154	case CHIP_HAINAN:
155	dev_info(dev->dev,
156	"SI support provided by radeon.\n");
157	dev_info(dev->dev,
158	"Use radeon.si_support=0 amdgpu.si_support=1 to override.\n"
159	);
160	return -ENODEV;
161	}
162	}
163	#endif
164	#ifdef CONFIG_DRM_AMDGPU_CIK
165	if (!amdgpu_cik_support) {
166	switch (flags & AMD_ASIC_MASK) {
167	case CHIP_KAVERI:
168	case CHIP_BONAIRE:
169	case CHIP_HAWAII:
170	case CHIP_KABINI:
171	case CHIP_MULLINS:
172	dev_info(dev->dev,
173	"CIK support provided by radeon.\n");
174	dev_info(dev->dev,
175	"Use radeon.cik_support=0 amdgpu.cik_support=1 to override.\n"
176	);
177	return -ENODEV;
178	}
179	}
180	#endif
181
182	adev = kzalloc(sizeof(struct amdgpu_device), GFP_KERNEL);	147	adev = kzalloc(sizeof(struct amdgpu_device), GFP_KERNEL);
183	if (adev == NULL) {	148	if (adev == NULL) {
184	return -ENOMEM;	149	return -ENOMEM;

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

@@ -1129,7 +1129,7 @@ static void sdma_v5_0_ring_emit_pipeline_sync(struct amdgpu_ring *ring) · 1128 unmodified lines
1129	amdgpu_ring_write(ring, addr & 0xfffffffc);	1129	amdgpu_ring_write(ring, addr & 0xfffffffc);
1130	amdgpu_ring_write(ring, upper_32_bits(addr) & 0xffffffff);	1130	amdgpu_ring_write(ring, upper_32_bits(addr) & 0xffffffff);
1131	amdgpu_ring_write(ring, seq); /* reference */	1131	amdgpu_ring_write(ring, seq); /* reference */
1132	amdgpu_ring_write(ring, 0xfffffff); /* mask */	1132	amdgpu_ring_write(ring, 0xffffffff); /* mask */
1133	amdgpu_ring_write(ring, SDMA_PKT_POLL_REGMEM_DW5_RETRY_COUNT(0xfff) \|	1133	amdgpu_ring_write(ring, SDMA_PKT_POLL_REGMEM_DW5_RETRY_COUNT(0xfff) \|
1134	SDMA_PKT_POLL_REGMEM_DW5_INTERVAL(4)); /* retry count, poll interval */	1134	SDMA_PKT_POLL_REGMEM_DW5_INTERVAL(4)); /* retry count, poll interval */
1135	}	1135	}

drivers/gpu/drm/amd/powerplay/smumgr/polaris10_smumgr.c+1−1

@@ -655,7 +655,7 @@ static int polaris10_populate_smc_mvdd_table(struct pp_hwmgr *hwmgr, · 654 unmodified lines
655	count = SMU_MAX_SMIO_LEVELS;	655	count = SMU_MAX_SMIO_LEVELS;
656	for (level = 0; level < count; level++) {	656	for (level = 0; level < count; level++) {
657	table->SmioTable2.Pattern[level].Voltage =	657	table->SmioTable2.Pattern[level].Voltage =
658	PP_HOST_TO_SMC_US(data->mvdd_voltage_table.entries[count].value * VOLTAGE_SCALE);	658	PP_HOST_TO_SMC_US(data->mvdd_voltage_table.entries[level].value * VOLTAGE_SCALE);
659	/* Index into DpmTable.Smio. Drive bits from Smio entry to get this voltage level.*/	659	/* Index into DpmTable.Smio. Drive bits from Smio entry to get this voltage level.*/
660	table->SmioTable2.Pattern[level].Smio =	660	table->SmioTable2.Pattern[level].Smio =
661	(uint8_t) level;	661	(uint8_t) level;

drivers/gpu/drm/amd/powerplay/smumgr/vegam_smumgr.c+1−1

@@ -456,7 +456,7 @@ static int vegam_populate_smc_mvdd_table(struct pp_hwmgr *hwmgr, · 455 unmodified lines
456	count = SMU_MAX_SMIO_LEVELS;	456	count = SMU_MAX_SMIO_LEVELS;
457	for (level = 0; level < count; level++) {	457	for (level = 0; level < count; level++) {
458	table->SmioTable2.Pattern[level].Voltage = PP_HOST_TO_SMC_US(	458	table->SmioTable2.Pattern[level].Voltage = PP_HOST_TO_SMC_US(
459	data->mvdd_voltage_table.entries[count].value * VOLTAGE_SCALE);	459	data->mvdd_voltage_table.entries[level].value * VOLTAGE_SCALE);
460	/* Index into DpmTable.Smio. Drive bits from Smio entry to get this voltage level.*/	460	/* Index into DpmTable.Smio. Drive bits from Smio entry to get this voltage level.*/
461	table->SmioTable2.Pattern[level].Smio =	461	table->SmioTable2.Pattern[level].Smio =
462	(uint8_t) level;	462	(uint8_t) level;

drivers/gpu/drm/bridge/tc358767.c+6−1

@@ -729,6 +729,8 @@ static int tc_set_video_mode(struct tc_data *tc, · 728 unmodified lines
729	int lower_margin = mode->vsync_start - mode->vdisplay;	729	int lower_margin = mode->vsync_start - mode->vdisplay;
730	int vsync_len = mode->vsync_end - mode->vsync_start;	730	int vsync_len = mode->vsync_end - mode->vsync_start;
731	u32 dp0_syncval;	731	u32 dp0_syncval;
		732	u32 bits_per_pixel = 24;
		733	u32 in_bw, out_bw;
732		734
733	/*	735	/*
734	* Recommended maximum number of symbols transferred in a transfer unit:	736	* Recommended maximum number of symbols transferred in a transfer unit:
@@ -736,7 +738,10 @@ static int tc_set_video_mode(struct tc_data *tc, · 1 unmodified line
736	* (output active video bandwidth in bytes))	738	* (output active video bandwidth in bytes))
737	* Must be less than tu_size.	739	* Must be less than tu_size.
738	*/	740	*/
739	max_tu_symbol = TU_SIZE_RECOMMENDED - 1;	741
		742	in_bw = mode->clock * bits_per_pixel / 8;
		743	out_bw = tc->link.base.num_lanes * tc->link.base.rate;
		744	max_tu_symbol = DIV_ROUND_UP(in_bw * TU_SIZE_RECOMMENDED, out_bw);
740		745
741	dev_dbg(tc->dev, "set mode %dx%d\n",	746	dev_dbg(tc->dev, "set mode %dx%d\n",
742	mode->hdisplay, mode->vdisplay);	747	mode->hdisplay, mode->vdisplay);

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

@@ -159,6 +159,9 @@ static const struct edid_quirk { · 158 unmodified lines
159	/* Medion MD 30217 PG */	159	/* Medion MD 30217 PG */
160	{ "MED", 0x7b8, EDID_QUIRK_PREFER_LARGE_75 },	160	{ "MED", 0x7b8, EDID_QUIRK_PREFER_LARGE_75 },
161		161
		162	/* Lenovo G50 */
		163	{ "SDC", 18514, EDID_QUIRK_FORCE_6BPC },
		164
162	/* Panel in Samsung NP700G7A-S01PL notebook reports 6bpc */	165	/* Panel in Samsung NP700G7A-S01PL notebook reports 6bpc */
163	{ "SEC", 0xd033, EDID_QUIRK_FORCE_8BPC },	166	{ "SEC", 0xd033, EDID_QUIRK_FORCE_8BPC },
164		167

drivers/gpu/drm/msm/dsi/dsi_host.c+4−2

 #include "dsi_cfg.h"
 #include "msm_kms.h"
+#define DSI_RESET_TOGGLE_DELAY_MS 20
 static int dsi_get_version(const void __iomem *base, u32 *major, u32 *minor)
 {
 	u32 ver;
 	wmb(); /* clocks need to be enabled before reset */
 	dsi_write(msm_host, REG_DSI_RESET, 1);
-	wmb(); /* make sure reset happen */
+	msleep(DSI_RESET_TOGGLE_DELAY_MS); /* make sure reset happen */
 	dsi_write(msm_host, REG_DSI_RESET, 0);
 }
 	/* dsi controller can only be reset while clocks are running */
 	dsi_write(msm_host, REG_DSI_RESET, 1);
-	wmb();	/* make sure reset happen */
+	msleep(DSI_RESET_TOGGLE_DELAY_MS); /* make sure reset happen */
 	dsi_write(msm_host, REG_DSI_RESET, 0);
 	wmb();	/* controller out of reset */
 	dsi_write(msm_host, REG_DSI_CTRL, data0);

drivers/gpu/drm/panel/panel-lg-lb035q02.c+8−1

 MODULE_DEVICE_TABLE(of, lb035q02_of_match);
+static const struct spi_device_id lb035q02_ids[] = {
+	{ "lb035q02", 0 },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(spi, lb035q02_ids);
 static struct spi_driver lb035q02_driver = {
 	.probe		= lb035q02_probe,
 	.remove		= lb035q02_remove,
+	.id_table	= lb035q02_ids,
 	.driver		= {
 		.name	= "panel-lg-lb035q02",
 		.of_match_table = lb035q02_of_match,
 module_spi_driver(lb035q02_driver);
-MODULE_ALIAS("spi:lgphilips,lb035q02");
 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
 MODULE_DESCRIPTION("LG.Philips LB035Q02 LCD Panel driver");
 MODULE_LICENSE("GPL");

drivers/gpu/drm/panel/panel-nec-nl8048hl11.c+8−1

 MODULE_DEVICE_TABLE(of, nl8048_of_match);
+static const struct spi_device_id nl8048_ids[] = {
+	{ "nl8048hl11", 0 },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(spi, nl8048_ids);
 static struct spi_driver nl8048_driver = {
 	.probe		= nl8048_probe,
 	.remove		= nl8048_remove,
+	.id_table	= nl8048_ids,
 	.driver		= {
 		.name	= "panel-nec-nl8048hl11",
 		.pm	= &nl8048_pm_ops,
 module_spi_driver(nl8048_driver);
-MODULE_ALIAS("spi:nec,nl8048hl11");
 MODULE_AUTHOR("Erik Gilling <konkers@android.com>");
 MODULE_DESCRIPTION("NEC-NL8048HL11 Driver");
 MODULE_LICENSE("GPL");

drivers/gpu/drm/panel/panel-sony-acx565akm.c+8−1

 MODULE_DEVICE_TABLE(of, acx565akm_of_match);
+static const struct spi_device_id acx565akm_ids[] = {
+	{ "acx565akm", 0 },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(spi, acx565akm_ids);
 static struct spi_driver acx565akm_driver = {
 	.probe		= acx565akm_probe,
 	.remove		= acx565akm_remove,
+	.id_table	= acx565akm_ids,
 	.driver		= {
 		.name	= "panel-sony-acx565akm",
 		.of_match_table = acx565akm_of_match,
 module_spi_driver(acx565akm_driver);
-MODULE_ALIAS("spi:sony,acx565akm");
 MODULE_AUTHOR("Nokia Corporation");
 MODULE_DESCRIPTION("Sony ACX565AKM LCD Panel Driver");
 MODULE_LICENSE("GPL");

drivers/gpu/drm/panel/panel-tpo-td028ttec1.c+1−2

@@ -374,8 +374,7 @@ static const struct of_device_id td028ttec1_of_match[] = { · 373 unmodified lines
374	MODULE_DEVICE_TABLE(of, td028ttec1_of_match);	374	MODULE_DEVICE_TABLE(of, td028ttec1_of_match);
375		375
376	static const struct spi_device_id td028ttec1_ids[] = {	376	static const struct spi_device_id td028ttec1_ids[] = {
377	{ "tpo,td028ttec1", 0},	377	{ "td028ttec1", 0 },
378	{ "toppoly,td028ttec1", 0 },
379	{ /* sentinel */ }	378	{ /* sentinel */ }
380	};	379	};
381		380

drivers/gpu/drm/panel/panel-tpo-td043mtea1.c+8−1

 MODULE_DEVICE_TABLE(of, td043mtea1_of_match);
+static const struct spi_device_id td043mtea1_ids[] = {
+	{ "td043mtea1", 0 },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(spi, td043mtea1_ids);
 static struct spi_driver td043mtea1_driver = {
 	.probe		= td043mtea1_probe,
 	.remove		= td043mtea1_remove,
+	.id_table	= td043mtea1_ids,
 	.driver		= {
 		.name	= "panel-tpo-td043mtea1",
 		.pm	= &td043mtea1_pm_ops,
 module_spi_driver(td043mtea1_driver);
-MODULE_ALIAS("spi:tpo,td043mtea1");
 MODULE_AUTHOR("Gražvydas Ignotas <notasas@gmail.com>");
 MODULE_DESCRIPTION("TPO TD043MTEA1 Panel Driver");
 MODULE_LICENSE("GPL");

drivers/gpu/drm/panfrost/panfrost_gpu.c+3−0

 	pfdev->features.mem_features = gpu_read(pfdev, GPU_MEM_FEATURES);
 	pfdev->features.mmu_features = gpu_read(pfdev, GPU_MMU_FEATURES);
 	pfdev->features.thread_features = gpu_read(pfdev, GPU_THREAD_FEATURES);
+	pfdev->features.max_threads = gpu_read(pfdev, GPU_THREAD_MAX_THREADS);
+	pfdev->features.thread_max_workgroup_sz = gpu_read(pfdev, GPU_THREAD_MAX_WORKGROUP_SIZE);
+	pfdev->features.thread_max_barrier_sz = gpu_read(pfdev, GPU_THREAD_MAX_BARRIER_SIZE);
 	pfdev->features.coherency_features = gpu_read(pfdev, GPU_COHERENCY_FEATURES);
 	for (i = 0; i < 4; i++)
 		pfdev->features.texture_features[i] = gpu_read(pfdev, GPU_TEXTURE_FEATURES(i));

drivers/gpu/drm/panfrost/panfrost_job.c+11−5

 		job_read(pfdev, JS_TAIL_LO(js)),
 		sched_job);
-	mutex_lock(&pfdev->reset_lock);
+	if (!mutex_trylock(&pfdev->reset_lock))
+		return;
-	for (i = 0; i < NUM_JOB_SLOTS; i++)
+	for (i = 0; i < NUM_JOB_SLOTS; i++) {
-		drm_sched_stop(&pfdev->js->queue[i].sched, sched_job);
+		struct drm_gpu_scheduler *sched = &pfdev->js->queue[i].sched;
+		drm_sched_stop(sched, sched_job);
+		if (js != i)
+			/* Ensure any timeouts on other slots have finished */
+			cancel_delayed_work_sync(&sched->work_tdr);
+	}
-	if (sched_job)
+	drm_sched_increase_karma(sched_job);
-		drm_sched_increase_karma(sched_job);
 	spin_lock_irqsave(&pfdev->js->job_lock, flags);
 	for (i = 0; i < NUM_JOB_SLOTS; i++) {

drivers/gpu/drm/radeon/radeon_drv.c+0−8

 static void
 radeon_pci_shutdown(struct pci_dev *pdev)
 {
-	struct drm_device *ddev = pci_get_drvdata(pdev);
 	/* if we are running in a VM, make sure the device
 	 * torn down properly on reboot/shutdown
 	 */
 	if (radeon_device_is_virtual())
 		radeon_pci_remove(pdev);
-	/* Some adapters need to be suspended before a
-	* shutdown occurs in order to prevent an error
-	* during kexec.
-	*/
-	radeon_suspend_kms(ddev, true, true, false);
 }
 static int radeon_pmops_suspend(struct device *dev)

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

 	list_add_tail(&bo->lru, &man->lru[bo->priority]);
 	kref_get(&bo->list_kref);
-	if (bo->ttm && !(bo->ttm->page_flags &
+	if (!(man->flags & TTM_MEMTYPE_FLAG_FIXED) && bo->ttm &&
-			 (TTM_PAGE_FLAG_SG | TTM_PAGE_FLAG_SWAPPED))) {
+	    !(bo->ttm->page_flags & (TTM_PAGE_FLAG_SG |
+				     TTM_PAGE_FLAG_SWAPPED))) {
 		list_add_tail(&bo->swap, &bdev->glob->swap_lru[bo->priority]);
 		kref_get(&bo->list_kref);
 	}
 	if (!bo) {
 		if (busy_bo)
-			ttm_bo_get(busy_bo);
+			kref_get(&busy_bo->list_kref);
 		spin_unlock(&glob->lru_lock);
 		ret = ttm_mem_evict_wait_busy(busy_bo, ctx, ticket);
 		if (busy_bo)
-			ttm_bo_put(busy_bo);
+			kref_put(&busy_bo->list_kref, ttm_bo_release_list);
 		return ret;
 	}

drivers/gpu/drm/ttm/ttm_bo_vm.c+7−9

@@ -278,15 +278,13 @@ static vm_fault_t ttm_bo_vm_fault(struct vm_fault *vmf) · 277 unmodified lines
278	else	278	else
279	ret = vmf_insert_pfn(&cvma, address, pfn);	279	ret = vmf_insert_pfn(&cvma, address, pfn);
280		280
281	/*	281	/* Never error on prefaulted PTEs */
282	* Somebody beat us to this PTE or prefaulting to	282	if (unlikely((ret & VM_FAULT_ERROR))) {
283	* an already populated PTE, or prefaulting error.	283	if (i == 0)
284	*/	284	goto out_io_unlock;
285		285	else
286	if (unlikely((ret == VM_FAULT_NOPAGE && i > 0)))	286	break;
287	break;	287	}
288	else if (unlikely(ret & VM_FAULT_ERROR))
289	goto out_io_unlock;
290		288
291	address += PAGE_SIZE;	289	address += PAGE_SIZE;
292	if (unlikely(++page_offset >= page_last))	290	if (unlikely(++page_offset >= page_last))

drivers/gpu/drm/xen/xen_drm_front.c+2−10

 	struct device *dev = &xb_dev->dev;
 	int ret;
-	/*
+	ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(64));
-	 * The device is not spawn from a device tree, so arch_setup_dma_ops
-	 * is not called, thus leaving the device with dummy DMA ops.
-	 * This makes the device return error on PRIME buffer import, which
-	 * is not correct: to fix this call of_dma_configure() with a NULL
-	 * node to set default DMA ops.
-	 */
-	dev->coherent_dma_mask = DMA_BIT_MASK(32);
-	ret = of_dma_configure(dev, NULL, true);
 	if (ret < 0) {
-		DRM_ERROR("Cannot setup DMA ops, ret %d", ret);
+		DRM_ERROR("Cannot setup DMA mask, ret %d", ret);
 		return ret;
 	}

drivers/hid/hid-hyperv.c+10−46

@@ -314,60 +314,24 @@ static void mousevsc_on_receive(struct hv_device *device, · 313 unmodified lines
314		314
315	static void mousevsc_on_channel_callback(void *context)	315	static void mousevsc_on_channel_callback(void *context)
316	{	316	{
317	const int packet_size = 0x100;
318	int ret;
319	struct hv_device *device = context;	317	struct hv_device *device = context;
320	u32 bytes_recvd;
321	u64 req_id;
322	struct vmpacket_descriptor *desc;	318	struct vmpacket_descriptor *desc;
323	unsigned char *buffer;
324	int bufferlen = packet_size;
325
326	buffer = kmalloc(bufferlen, GFP_ATOMIC);
327	if (!buffer)
328	return;
329
330	do {
331	ret = vmbus_recvpacket_raw(device->channel, buffer,
332	bufferlen, &bytes_recvd, &req_id);
333
334	switch (ret) {
335	case 0:
336	if (bytes_recvd <= 0) {
337	kfree(buffer);
338	return;
339	}
340	desc = (struct vmpacket_descriptor *)buffer;
341
342	switch (desc->type) {
343	case VM_PKT_COMP:
344	break;
345
346	case VM_PKT_DATA_INBAND:
347	mousevsc_on_receive(device, desc);
348	break;
349
350	default:
351	pr_err("unhandled packet type %d, tid %llx len %d\n",
352	desc->type, req_id, bytes_recvd);
353	break;
354	}
355		319
		320	foreach_vmbus_pkt(desc, device->channel) {
		321	switch (desc->type) {
		322	case VM_PKT_COMP:
356	break;	323	break;
357		324
358	case -ENOBUFS:	325	case VM_PKT_DATA_INBAND:
359	kfree(buffer);	326	mousevsc_on_receive(device, desc);
360	/* Handle large packet */	327	break;
361	bufferlen = bytes_recvd;
362	buffer = kmalloc(bytes_recvd, GFP_ATOMIC);
363
364	if (!buffer)
365	return;
366		328
		329	default:
		330	pr_err("Unhandled packet type %d, tid %llx len %d\n",
		331	desc->type, desc->trans_id, desc->len8 * 8);
367	break;	332	break;
368	}	333	}
369	} while (1);	334	}
370
371	}	335	}
372		336
373	static int mousevsc_connect_to_vsp(struct hv_device *device)	337	static int mousevsc_connect_to_vsp(struct hv_device *device)

drivers/hv/vmbus_drv.c+6−0

 		drv->shutdown(dev);
 }
+#ifdef CONFIG_PM_SLEEP
 /*
  * vmbus_suspend - Suspend a vmbus device
  */
 	return drv->resume(dev);
 }
+#endif /* CONFIG_PM_SLEEP */
 /*
  * vmbus_device_release - Final callback release of the vmbus child device
 	vmbus_signal_eom(msg, message_type);
 }
+#ifdef CONFIG_PM_SLEEP
 /*
  * Fake RESCIND_CHANNEL messages to clean up hv_sock channels by force for
  * hibernation, because hv_sock connections can not persist across hibernation.
 		      vmbus_connection.work_queue,
 		      &ctx->work);
 }
+#endif /* CONFIG_PM_SLEEP */
 /*
  * Direct callback for channels using other deferred processing
 	return ret_val;
 }
+#ifdef CONFIG_PM_SLEEP
 static int vmbus_bus_suspend(struct device *dev)
 {
 	struct vmbus_channel *channel, *sc;
 	return 0;
 }
+#endif /* CONFIG_PM_SLEEP */
 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
 	{"VMBUS", 0},

drivers/hwmon/nct7904.c+27−6

 	u8 enable_dts;
 	u8 has_dts;
 	u8 temp_mode; /* 0: TR mode, 1: TD mode */
+	u8 fan_alarm[2];
+	u8 vsen_alarm[3];
 };
 /* Access functions */
 				       SMI_STS5_REG + (channel >> 3));
 		if (ret < 0)
 			return ret;
-		*val = (ret >> (channel & 0x07)) & 1;
+		if (!data->fan_alarm[channel >> 3])
+			data->fan_alarm[channel >> 3] = ret & 0xff;
+		else
+			/* If there is new alarm showing up */
+			data->fan_alarm[channel >> 3] |= (ret & 0xff);
+		*val = (data->fan_alarm[channel >> 3] >> (channel & 0x07)) & 1;
+		/* Needs to clean the alarm if alarm existing */
+		if (*val)
+			data->fan_alarm[channel >> 3] ^= 1 << (channel & 0x07);
 		return 0;
 	default:
 		return -EOPNOTSUPP;
 				       SMI_STS1_REG + (index >> 3));
 		if (ret < 0)
 			return ret;
-		*val = (ret >> (index & 0x07)) & 1;
+		if (!data->vsen_alarm[index >> 3])
+			data->vsen_alarm[index >> 3] = ret & 0xff;
+		else
+			/* If there is new alarm showing up */
+			data->vsen_alarm[index >> 3] |= (ret & 0xff);
+		*val = (data->vsen_alarm[index >> 3] >> (index & 0x07)) & 1;
+		/* Needs to clean the alarm if alarm existing */
+		if (*val)
+			data->vsen_alarm[index >> 3] ^= 1 << (index & 0x07);
 		return 0;
 	default:
 		return -EOPNOTSUPP;
 	data->temp_mode = 0;
 	for (i = 0; i < 4; i++) {
-		val = (ret & (0x03 << i)) >> (i * 2);
+		val = (ret >> (i * 2)) & 0x03;
 		bit = (1 << i);
-		if (val == 0)
+		if (val == 0) {
 			data->tcpu_mask &= ~bit;
-		else if (val == 0x1 || val == 0x2)
+		} else {
-			data->temp_mode |= bit;
+			if (val == 0x1 || val == 0x2)
+				data->temp_mode |= bit;
+			data->vsen_mask &= ~(0x06 << (i * 2));
+		}
 	}
 	/* PECI */

drivers/iio/accel/adxl372.c+17−5

 	if (ret < 0)
 		return ret;
-	fifo_samples = st->watermark & 0xFF;
+	/*
+	 * watermark stores the number of sets; we need to write the FIFO
+	 * registers with the number of samples
+	 */
+	fifo_samples = (st->watermark * st->fifo_set_size);
 	fifo_ctl = ADXL372_FIFO_CTL_FORMAT_MODE(st->fifo_format) |
 		   ADXL372_FIFO_CTL_MODE_MODE(st->fifo_mode) |
-		   ADXL372_FIFO_CTL_SAMPLES_MODE(st->watermark);
+		   ADXL372_FIFO_CTL_SAMPLES_MODE(fifo_samples);
-	ret = regmap_write(st->regmap, ADXL372_FIFO_SAMPLES, fifo_samples);
+	ret = regmap_write(st->regmap,
+			   ADXL372_FIFO_SAMPLES, fifo_samples & 0xFF);
 	if (ret < 0)
 		return ret;
 			goto err;
 		/* Each sample is 2 bytes */
-		for (i = 0; i < fifo_entries * sizeof(u16);
+		for (i = 0; i < fifo_entries; i += st->fifo_set_size)
-		     i += st->fifo_set_size * sizeof(u16))
 			iio_push_to_buffers(indio_dev, &st->fifo_buf[i]);
 	}
 err:
 		return -ENODEV;
 	}
+	/*
+	 * Perform a software reset to make sure the device is in a consistent
+	 * state after start up.
+	 */
+	ret = regmap_write(st->regmap, ADXL372_RESET, ADXL372_RESET_CODE);
+	if (ret < 0)
+		return ret;
 	ret = adxl372_set_op_mode(st, ADXL372_STANDBY);
 	if (ret < 0)
 		return ret;

drivers/iio/accel/bmc150-accel-core.c+1−1

@@ -117,7 +117,7 @@ · 116 unmodified lines
117	#define BMC150_ACCEL_SLEEP_1_SEC 0x0F	117	#define BMC150_ACCEL_SLEEP_1_SEC 0x0F
118		118
119	#define BMC150_ACCEL_REG_TEMP 0x08	119	#define BMC150_ACCEL_REG_TEMP 0x08
120	#define BMC150_ACCEL_TEMP_CENTER_VAL 24	120	#define BMC150_ACCEL_TEMP_CENTER_VAL 23
121		121
122	#define BMC150_ACCEL_AXIS_TO_REG(axis) (BMC150_ACCEL_REG_XOUT_L + (axis * 2))	122	#define BMC150_ACCEL_AXIS_TO_REG(axis) (BMC150_ACCEL_REG_XOUT_L + (axis * 2))
123	#define BMC150_AUTO_SUSPEND_DELAY_MS 2000	123	#define BMC150_AUTO_SUSPEND_DELAY_MS 2000

drivers/iio/adc/ad799x.c+2−2

@@ -810,10 +810,10 @@ static int ad799x_probe(struct i2c_client *client, · 809 unmodified lines
810		810
811	ret = ad799x_write_config(st, st->chip_config->default_config);	811	ret = ad799x_write_config(st, st->chip_config->default_config);
812	if (ret < 0)	812	if (ret < 0)
813	goto error_disable_reg;	813	goto error_disable_vref;
814	ret = ad799x_read_config(st);	814	ret = ad799x_read_config(st);
815	if (ret < 0)	815	if (ret < 0)
816	goto error_disable_reg;	816	goto error_disable_vref;
817	st->config = ret;	817	st->config = ret;
818		818
819	ret = iio_triggered_buffer_setup(indio_dev, NULL,	819	ret = iio_triggered_buffer_setup(indio_dev, NULL,

drivers/iio/adc/axp288_adc.c+32−0

@@ -7,6 +7,7 @@ · 6 unmodified lines
7	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	7	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8	*/	8	*/
9		9
		10	#include <linux/dmi.h>
10	#include <linux/module.h>	11	#include <linux/module.h>
11	#include <linux/kernel.h>	12	#include <linux/kernel.h>
12	#include <linux/device.h>	13	#include <linux/device.h>
@@ -25,6 +26,11 @@ · 12 unmodified lines
25	#define AXP288_ADC_EN_MASK 0xF0	26	#define AXP288_ADC_EN_MASK 0xF0
26	#define AXP288_ADC_TS_ENABLE 0x01	27	#define AXP288_ADC_TS_ENABLE 0x01
27		28
		29	#define AXP288_ADC_TS_BIAS_MASK GENMASK(5, 4)
		30	#define AXP288_ADC_TS_BIAS_20UA (0 << 4)
		31	#define AXP288_ADC_TS_BIAS_40UA (1 << 4)
		32	#define AXP288_ADC_TS_BIAS_60UA (2 << 4)
		33	#define AXP288_ADC_TS_BIAS_80UA (3 << 4)
28	#define AXP288_ADC_TS_CURRENT_ON_OFF_MASK GENMASK(1, 0)	34	#define AXP288_ADC_TS_CURRENT_ON_OFF_MASK GENMASK(1, 0)
29	#define AXP288_ADC_TS_CURRENT_OFF (0 << 0)	35	#define AXP288_ADC_TS_CURRENT_OFF (0 << 0)
30	#define AXP288_ADC_TS_CURRENT_ON_WHEN_CHARGING (1 << 0)	36	#define AXP288_ADC_TS_CURRENT_ON_WHEN_CHARGING (1 << 0)
@@ -177,10 +183,36 @@ static int axp288_adc_read_raw(struct iio_dev *indio_dev, · 146 unmodified lines
177	return ret;	183	return ret;
178	}	184	}
179		185
		186	/*
		187	* We rely on the machine's firmware to correctly setup the TS pin bias current
		188	* at boot. This lists systems with broken fw where we need to set it ourselves.
		189	*/
		190	static const struct dmi_system_id axp288_adc_ts_bias_override[] = {
		191	{
		192	/* Lenovo Ideapad 100S (11 inch) */
		193	.matches = {
		194	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
		195	DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad 100S-11IBY"),
		196	},
		197	.driver_data = (void *)(uintptr_t)AXP288_ADC_TS_BIAS_80UA,
		198	},
		199	{}
		200	};
		201
180	static int axp288_adc_initialize(struct axp288_adc_info *info)	202	static int axp288_adc_initialize(struct axp288_adc_info *info)
181	{	203	{
		204	const struct dmi_system_id *bias_override;
182	int ret, adc_enable_val;	205	int ret, adc_enable_val;
183		206
		207	bias_override = dmi_first_match(axp288_adc_ts_bias_override);
		208	if (bias_override) {
		209	ret = regmap_update_bits(info->regmap, AXP288_ADC_TS_PIN_CTRL,
		210	AXP288_ADC_TS_BIAS_MASK,
		211	(uintptr_t)bias_override->driver_data);
		212	if (ret)
		213	return ret;
		214	}
		215
184	/*	216	/*
185	* Determine if the TS pin is enabled and set the TS current-source	217	* Determine if the TS pin is enabled and set the TS current-source
186	* accordingly.	218	* accordingly.

drivers/iio/adc/hx711.c+5−5

 static int hx711_cycle(struct hx711_data *hx711_data)
 {
-	int val;
+	unsigned long flags;
 	/*
 	 * if preempted for more then 60us while PD_SCK is high:
 	 * hx711 is going in reset
 	 * ==> measuring is false
 	 */
-	preempt_disable();
+	local_irq_save(flags);
 	gpiod_set_value(hx711_data->gpiod_pd_sck, 1);
 	/*
 	 */
 	ndelay(hx711_data->data_ready_delay_ns);
-	val = gpiod_get_value(hx711_data->gpiod_dout);
 	/*
 	 * here we are not waiting for 0.2 us as suggested by the datasheet,
 	 * because the oscilloscope showed in a test scenario
 	 * and 0.56 us for PD_SCK low on TI Sitara with 800 MHz
 	 */
 	gpiod_set_value(hx711_data->gpiod_pd_sck, 0);
-	preempt_enable();
+	local_irq_restore(flags);
 	/*
 	 * make it a square wave for addressing cases with capacitance on
 	 */
 	ndelay(hx711_data->data_ready_delay_ns);
-	return val;
+	/* sample as late as possible */
+	return gpiod_get_value(hx711_data->gpiod_dout);
 }
 static int hx711_read(struct hx711_data *hx711_data)

drivers/iio/adc/meson_saradc.c+5−5

 	if (IS_ERR(base))
 		return PTR_ERR(base);
+	priv->regmap = devm_regmap_init_mmio(&pdev->dev, base,
+					     priv->param->regmap_config);
+	if (IS_ERR(priv->regmap))
+		return PTR_ERR(priv->regmap);
 	irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
 	if (!irq)
 		return -EINVAL;
 	if (ret)
 		return ret;
-	priv->regmap = devm_regmap_init_mmio(&pdev->dev, base,
-					     priv->param->regmap_config);
-	if (IS_ERR(priv->regmap))
-		return PTR_ERR(priv->regmap);
 	priv->clkin = devm_clk_get(&pdev->dev, "clkin");
 	if (IS_ERR(priv->clkin)) {
 		dev_err(&pdev->dev, "failed to get clkin\n");

drivers/iio/adc/stm32-adc-core.c+40−30

 #include "stm32-adc-core.h"
-/* STM32F4 - common registers for all ADC instances: 1, 2 & 3 */
-#define STM32F4_ADC_CSR			(STM32_ADCX_COMN_OFFSET + 0x00)
-#define STM32F4_ADC_CCR			(STM32_ADCX_COMN_OFFSET + 0x04)
-/* STM32F4_ADC_CSR - bit fields */
-#define STM32F4_EOC3			BIT(17)
-#define STM32F4_EOC2			BIT(9)
-#define STM32F4_EOC1			BIT(1)
-/* STM32F4_ADC_CCR - bit fields */
-#define STM32F4_ADC_ADCPRE_SHIFT	16
-#define STM32F4_ADC_ADCPRE_MASK		GENMASK(17, 16)
-/* STM32H7 - common registers for all ADC instances */
-#define STM32H7_ADC_CSR			(STM32_ADCX_COMN_OFFSET + 0x00)
-#define STM32H7_ADC_CCR			(STM32_ADCX_COMN_OFFSET + 0x08)
-/* STM32H7_ADC_CSR - bit fields */
-#define STM32H7_EOC_SLV			BIT(18)
-#define STM32H7_EOC_MST			BIT(2)
-/* STM32H7_ADC_CCR - bit fields */
-#define STM32H7_PRESC_SHIFT		18
-#define STM32H7_PRESC_MASK		GENMASK(21, 18)
-#define STM32H7_CKMODE_SHIFT		16
-#define STM32H7_CKMODE_MASK		GENMASK(17, 16)
 #define STM32_ADC_CORE_SLEEP_DELAY_MS	2000
 /* SYSCFG registers */
  * @eoc1:	adc1 end of conversion flag in @csr
  * @eoc2:	adc2 end of conversion flag in @csr
  * @eoc3:	adc3 end of conversion flag in @csr
+ * @ier:	interrupt enable register offset for each adc
+ * @eocie_msk:	end of conversion interrupt enable mask in @ier
  */
 struct stm32_adc_common_regs {
 	u32 csr;
 	u32 eoc1_msk;
 	u32 eoc2_msk;
 	u32 eoc3_msk;
+	u32 ier;
+	u32 eocie_msk;
 };
 struct stm32_adc_priv;
 	.eoc1_msk = STM32F4_EOC1,
 	.eoc2_msk = STM32F4_EOC2,
 	.eoc3_msk = STM32F4_EOC3,
+	.ier = STM32F4_ADC_CR1,
+	.eocie_msk = STM32F4_EOCIE,
 };
 /* STM32H7 common registers definitions */
 	.ccr = STM32H7_ADC_CCR,
 	.eoc1_msk = STM32H7_EOC_MST,
 	.eoc2_msk = STM32H7_EOC_SLV,
+	.ier = STM32H7_ADC_IER,
+	.eocie_msk = STM32H7_EOCIE,
+};
+static const unsigned int stm32_adc_offset[STM32_ADC_MAX_ADCS] = {
+	0, STM32_ADC_OFFSET, STM32_ADC_OFFSET * 2,
 };
+static unsigned int stm32_adc_eoc_enabled(struct stm32_adc_priv *priv,
+					  unsigned int adc)
+{
+	u32 ier, offset = stm32_adc_offset[adc];
+	ier = readl_relaxed(priv->common.base + offset + priv->cfg->regs->ier);
+	return ier & priv->cfg->regs->eocie_msk;
+}
 /* ADC common interrupt for all instances */
 static void stm32_adc_irq_handler(struct irq_desc *desc)
 {
 	chained_irq_enter(chip, desc);
 	status = readl_relaxed(priv->common.base + priv->cfg->regs->csr);
-	if (status & priv->cfg->regs->eoc1_msk)
+	/*
+	 * End of conversion may be handled by using IRQ or DMA. There may be a
+	 * race here when two conversions complete at the same time on several
+	 * ADCs. EOC may be read 'set' for several ADCs, with:
+	 * - an ADC configured to use DMA (EOC triggers the DMA request, and
+	 *   is then automatically cleared by DR read in hardware)
+	 * - an ADC configured to use IRQs (EOCIE bit is set. The handler must
+	 *   be called in this case)
+	 * So both EOC status bit in CSR and EOCIE control bit must be checked
+	 * before invoking the interrupt handler (e.g. call ISR only for
+	 * IRQ-enabled ADCs).
+	 */
+	if (status & priv->cfg->regs->eoc1_msk &&
+	    stm32_adc_eoc_enabled(priv, 0))
 		generic_handle_irq(irq_find_mapping(priv->domain, 0));
-	if (status & priv->cfg->regs->eoc2_msk)
+	if (status & priv->cfg->regs->eoc2_msk &&
+	    stm32_adc_eoc_enabled(priv, 1))
 		generic_handle_irq(irq_find_mapping(priv->domain, 1));
-	if (status & priv->cfg->regs->eoc3_msk)
+	if (status & priv->cfg->regs->eoc3_msk &&
+	    stm32_adc_eoc_enabled(priv, 2))
 		generic_handle_irq(irq_find_mapping(priv->domain, 2));
 	chained_irq_exit(chip, desc);

drivers/iio/adc/stm32-adc-core.h+137−0

@@ -25,8 +25,145 @@ · 24 unmodified lines
25	* --------------------------------------------------------	25	* --------------------------------------------------------
26	*/	26	*/
27	#define STM32_ADC_MAX_ADCS 3	27	#define STM32_ADC_MAX_ADCS 3
		28	#define STM32_ADC_OFFSET 0x100
28	#define STM32_ADCX_COMN_OFFSET 0x300	29	#define STM32_ADCX_COMN_OFFSET 0x300
29		30
		31	/* STM32F4 - Registers for each ADC instance */
		32	#define STM32F4_ADC_SR 0x00
		33	#define STM32F4_ADC_CR1 0x04
		34	#define STM32F4_ADC_CR2 0x08
		35	#define STM32F4_ADC_SMPR1 0x0C
		36	#define STM32F4_ADC_SMPR2 0x10
		37	#define STM32F4_ADC_HTR 0x24
		38	#define STM32F4_ADC_LTR 0x28
		39	#define STM32F4_ADC_SQR1 0x2C
		40	#define STM32F4_ADC_SQR2 0x30
		41	#define STM32F4_ADC_SQR3 0x34
		42	#define STM32F4_ADC_JSQR 0x38
		43	#define STM32F4_ADC_JDR1 0x3C
		44	#define STM32F4_ADC_JDR2 0x40
		45	#define STM32F4_ADC_JDR3 0x44
		46	#define STM32F4_ADC_JDR4 0x48
		47	#define STM32F4_ADC_DR 0x4C
		48
		49	/* STM32F4 - common registers for all ADC instances: 1, 2 & 3 */
		50	#define STM32F4_ADC_CSR (STM32_ADCX_COMN_OFFSET + 0x00)
		51	#define STM32F4_ADC_CCR (STM32_ADCX_COMN_OFFSET + 0x04)
		52
		53	/* STM32F4_ADC_SR - bit fields */
		54	#define STM32F4_STRT BIT(4)
		55	#define STM32F4_EOC BIT(1)
		56
		57	/* STM32F4_ADC_CR1 - bit fields */
		58	#define STM32F4_RES_SHIFT 24
		59	#define STM32F4_RES_MASK GENMASK(25, 24)
		60	#define STM32F4_SCAN BIT(8)
		61	#define STM32F4_EOCIE BIT(5)
		62
		63	/* STM32F4_ADC_CR2 - bit fields */
		64	#define STM32F4_SWSTART BIT(30)
		65	#define STM32F4_EXTEN_SHIFT 28
		66	#define STM32F4_EXTEN_MASK GENMASK(29, 28)
		67	#define STM32F4_EXTSEL_SHIFT 24
		68	#define STM32F4_EXTSEL_MASK GENMASK(27, 24)
		69	#define STM32F4_EOCS BIT(10)
		70	#define STM32F4_DDS BIT(9)
		71	#define STM32F4_DMA BIT(8)
		72	#define STM32F4_ADON BIT(0)
		73
		74	/* STM32F4_ADC_CSR - bit fields */
		75	#define STM32F4_EOC3 BIT(17)
		76	#define STM32F4_EOC2 BIT(9)
		77	#define STM32F4_EOC1 BIT(1)
		78
		79	/* STM32F4_ADC_CCR - bit fields */
		80	#define STM32F4_ADC_ADCPRE_SHIFT 16
		81	#define STM32F4_ADC_ADCPRE_MASK GENMASK(17, 16)
		82
		83	/* STM32H7 - Registers for each ADC instance */
		84	#define STM32H7_ADC_ISR 0x00
		85	#define STM32H7_ADC_IER 0x04
		86	#define STM32H7_ADC_CR 0x08
		87	#define STM32H7_ADC_CFGR 0x0C
		88	#define STM32H7_ADC_SMPR1 0x14
		89	#define STM32H7_ADC_SMPR2 0x18
		90	#define STM32H7_ADC_PCSEL 0x1C
		91	#define STM32H7_ADC_SQR1 0x30
		92	#define STM32H7_ADC_SQR2 0x34
		93	#define STM32H7_ADC_SQR3 0x38
		94	#define STM32H7_ADC_SQR4 0x3C
		95	#define STM32H7_ADC_DR 0x40
		96	#define STM32H7_ADC_DIFSEL 0xC0
		97	#define STM32H7_ADC_CALFACT 0xC4
		98	#define STM32H7_ADC_CALFACT2 0xC8
		99
		100	/* STM32H7 - common registers for all ADC instances */
		101	#define STM32H7_ADC_CSR (STM32_ADCX_COMN_OFFSET + 0x00)
		102	#define STM32H7_ADC_CCR (STM32_ADCX_COMN_OFFSET + 0x08)
		103
		104	/* STM32H7_ADC_ISR - bit fields */
		105	#define STM32MP1_VREGREADY BIT(12)
		106	#define STM32H7_EOC BIT(2)
		107	#define STM32H7_ADRDY BIT(0)
		108
		109	/* STM32H7_ADC_IER - bit fields */
		110	#define STM32H7_EOCIE STM32H7_EOC
		111
		112	/* STM32H7_ADC_CR - bit fields */
		113	#define STM32H7_ADCAL BIT(31)
		114	#define STM32H7_ADCALDIF BIT(30)
		115	#define STM32H7_DEEPPWD BIT(29)
		116	#define STM32H7_ADVREGEN BIT(28)
		117	#define STM32H7_LINCALRDYW6 BIT(27)
		118	#define STM32H7_LINCALRDYW5 BIT(26)
		119	#define STM32H7_LINCALRDYW4 BIT(25)
		120	#define STM32H7_LINCALRDYW3 BIT(24)
		121	#define STM32H7_LINCALRDYW2 BIT(23)
		122	#define STM32H7_LINCALRDYW1 BIT(22)
		123	#define STM32H7_ADCALLIN BIT(16)
		124	#define STM32H7_BOOST BIT(8)
		125	#define STM32H7_ADSTP BIT(4)
		126	#define STM32H7_ADSTART BIT(2)
		127	#define STM32H7_ADDIS BIT(1)
		128	#define STM32H7_ADEN BIT(0)
		129
		130	/* STM32H7_ADC_CFGR bit fields */
		131	#define STM32H7_EXTEN_SHIFT 10
		132	#define STM32H7_EXTEN_MASK GENMASK(11, 10)
		133	#define STM32H7_EXTSEL_SHIFT 5
		134	#define STM32H7_EXTSEL_MASK GENMASK(9, 5)
		135	#define STM32H7_RES_SHIFT 2
		136	#define STM32H7_RES_MASK GENMASK(4, 2)
		137	#define STM32H7_DMNGT_SHIFT 0
		138	#define STM32H7_DMNGT_MASK GENMASK(1, 0)
		139
		140	enum stm32h7_adc_dmngt {
		141	STM32H7_DMNGT_DR_ONLY, /* Regular data in DR only */
		142	STM32H7_DMNGT_DMA_ONESHOT, /* DMA one shot mode */
		143	STM32H7_DMNGT_DFSDM, /* DFSDM mode */
		144	STM32H7_DMNGT_DMA_CIRC, /* DMA circular mode */
		145	};
		146
		147	/* STM32H7_ADC_CALFACT - bit fields */
		148	#define STM32H7_CALFACT_D_SHIFT 16
		149	#define STM32H7_CALFACT_D_MASK GENMASK(26, 16)
		150	#define STM32H7_CALFACT_S_SHIFT 0
		151	#define STM32H7_CALFACT_S_MASK GENMASK(10, 0)
		152
		153	/* STM32H7_ADC_CALFACT2 - bit fields */
		154	#define STM32H7_LINCALFACT_SHIFT 0
		155	#define STM32H7_LINCALFACT_MASK GENMASK(29, 0)
		156
		157	/* STM32H7_ADC_CSR - bit fields */
		158	#define STM32H7_EOC_SLV BIT(18)
		159	#define STM32H7_EOC_MST BIT(2)
		160
		161	/* STM32H7_ADC_CCR - bit fields */
		162	#define STM32H7_PRESC_SHIFT 18
		163	#define STM32H7_PRESC_MASK GENMASK(21, 18)
		164	#define STM32H7_CKMODE_SHIFT 16
		165	#define STM32H7_CKMODE_MASK GENMASK(17, 16)
		166
30	/**	167	/**
31	* struct stm32_adc_common - stm32 ADC driver common data (for all instances)	168	* struct stm32_adc_common - stm32 ADC driver common data (for all instances)
32	* @base: control registers base cpu addr	169	* @base: control registers base cpu addr

drivers/iio/adc/stm32-adc.c+0−109

@@ -28,115 +28,6 @@ · 27 unmodified lines
28		28
29	#include "stm32-adc-core.h"	29	#include "stm32-adc-core.h"
30		30
31	/* STM32F4 - Registers for each ADC instance */
32	#define STM32F4_ADC_SR 0x00
33	#define STM32F4_ADC_CR1 0x04
34	#define STM32F4_ADC_CR2 0x08
35	#define STM32F4_ADC_SMPR1 0x0C
36	#define STM32F4_ADC_SMPR2 0x10
37	#define STM32F4_ADC_HTR 0x24
38	#define STM32F4_ADC_LTR 0x28
39	#define STM32F4_ADC_SQR1 0x2C
40	#define STM32F4_ADC_SQR2 0x30
41	#define STM32F4_ADC_SQR3 0x34
42	#define STM32F4_ADC_JSQR 0x38
43	#define STM32F4_ADC_JDR1 0x3C
44	#define STM32F4_ADC_JDR2 0x40
45	#define STM32F4_ADC_JDR3 0x44
46	#define STM32F4_ADC_JDR4 0x48
47	#define STM32F4_ADC_DR 0x4C
48
49	/* STM32F4_ADC_SR - bit fields */
50	#define STM32F4_STRT BIT(4)
51	#define STM32F4_EOC BIT(1)
52
53	/* STM32F4_ADC_CR1 - bit fields */
54	#define STM32F4_RES_SHIFT 24
55	#define STM32F4_RES_MASK GENMASK(25, 24)
56	#define STM32F4_SCAN BIT(8)
57	#define STM32F4_EOCIE BIT(5)
58
59	/* STM32F4_ADC_CR2 - bit fields */
60	#define STM32F4_SWSTART BIT(30)
61	#define STM32F4_EXTEN_SHIFT 28
62	#define STM32F4_EXTEN_MASK GENMASK(29, 28)
63	#define STM32F4_EXTSEL_SHIFT 24
64	#define STM32F4_EXTSEL_MASK GENMASK(27, 24)
65	#define STM32F4_EOCS BIT(10)
66	#define STM32F4_DDS BIT(9)
67	#define STM32F4_DMA BIT(8)
68	#define STM32F4_ADON BIT(0)
69
70	/* STM32H7 - Registers for each ADC instance */
71	#define STM32H7_ADC_ISR 0x00
72	#define STM32H7_ADC_IER 0x04
73	#define STM32H7_ADC_CR 0x08
74	#define STM32H7_ADC_CFGR 0x0C
75	#define STM32H7_ADC_SMPR1 0x14
76	#define STM32H7_ADC_SMPR2 0x18
77	#define STM32H7_ADC_PCSEL 0x1C
78	#define STM32H7_ADC_SQR1 0x30
79	#define STM32H7_ADC_SQR2 0x34
80	#define STM32H7_ADC_SQR3 0x38
81	#define STM32H7_ADC_SQR4 0x3C
82	#define STM32H7_ADC_DR 0x40
83	#define STM32H7_ADC_DIFSEL 0xC0
84	#define STM32H7_ADC_CALFACT 0xC4
85	#define STM32H7_ADC_CALFACT2 0xC8
86
87	/* STM32H7_ADC_ISR - bit fields */
88	#define STM32MP1_VREGREADY BIT(12)
89	#define STM32H7_EOC BIT(2)
90	#define STM32H7_ADRDY BIT(0)
91
92	/* STM32H7_ADC_IER - bit fields */
93	#define STM32H7_EOCIE STM32H7_EOC
94
95	/* STM32H7_ADC_CR - bit fields */
96	#define STM32H7_ADCAL BIT(31)
97	#define STM32H7_ADCALDIF BIT(30)
98	#define STM32H7_DEEPPWD BIT(29)
99	#define STM32H7_ADVREGEN BIT(28)
100	#define STM32H7_LINCALRDYW6 BIT(27)
101	#define STM32H7_LINCALRDYW5 BIT(26)
102	#define STM32H7_LINCALRDYW4 BIT(25)
103	#define STM32H7_LINCALRDYW3 BIT(24)
104	#define STM32H7_LINCALRDYW2 BIT(23)
105	#define STM32H7_LINCALRDYW1 BIT(22)
106	#define STM32H7_ADCALLIN BIT(16)
107	#define STM32H7_BOOST BIT(8)
108	#define STM32H7_ADSTP BIT(4)
109	#define STM32H7_ADSTART BIT(2)
110	#define STM32H7_ADDIS BIT(1)
111	#define STM32H7_ADEN BIT(0)
112
113	/* STM32H7_ADC_CFGR bit fields */
114	#define STM32H7_EXTEN_SHIFT 10
115	#define STM32H7_EXTEN_MASK GENMASK(11, 10)
116	#define STM32H7_EXTSEL_SHIFT 5
117	#define STM32H7_EXTSEL_MASK GENMASK(9, 5)
118	#define STM32H7_RES_SHIFT 2
119	#define STM32H7_RES_MASK GENMASK(4, 2)
120	#define STM32H7_DMNGT_SHIFT 0
121	#define STM32H7_DMNGT_MASK GENMASK(1, 0)
122
123	enum stm32h7_adc_dmngt {
124	STM32H7_DMNGT_DR_ONLY, /* Regular data in DR only */
125	STM32H7_DMNGT_DMA_ONESHOT, /* DMA one shot mode */
126	STM32H7_DMNGT_DFSDM, /* DFSDM mode */
127	STM32H7_DMNGT_DMA_CIRC, /* DMA circular mode */
128	};
129
130	/* STM32H7_ADC_CALFACT - bit fields */
131	#define STM32H7_CALFACT_D_SHIFT 16
132	#define STM32H7_CALFACT_D_MASK GENMASK(26, 16)
133	#define STM32H7_CALFACT_S_SHIFT 0
134	#define STM32H7_CALFACT_S_MASK GENMASK(10, 0)
135
136	/* STM32H7_ADC_CALFACT2 - bit fields */
137	#define STM32H7_LINCALFACT_SHIFT 0
138	#define STM32H7_LINCALFACT_MASK GENMASK(29, 0)
139
140	/* Number of linear calibration shadow registers / LINCALRDYW control bits */	31	/* Number of linear calibration shadow registers / LINCALRDYW control bits */
141	#define STM32H7_LINCALFACT_NUM 6	32	#define STM32H7_LINCALFACT_NUM 6
142		33

drivers/iio/imu/adis_buffer.c+8−2

 		return -ENOMEM;
 	adis->buffer = kzalloc(burst_length + sizeof(u16), GFP_KERNEL);
-	if (!adis->buffer)
+	if (!adis->buffer) {
+		kfree(adis->xfer);
+		adis->xfer = NULL;
 		return -ENOMEM;
+	}
 	tx = adis->buffer + burst_length;
 	tx[0] = ADIS_READ_REG(adis->burst->reg_cmd);
 		return -ENOMEM;
 	adis->buffer = kcalloc(indio_dev->scan_bytes, 2, GFP_KERNEL);
-	if (!adis->buffer)
+	if (!adis->buffer) {
+		kfree(adis->xfer);
+		adis->xfer = NULL;
 		return -ENOMEM;
+	}
 	rx = adis->buffer;
 	tx = rx + scan_count;

drivers/iio/imu/st_lsm6dsx/st_lsm6dsx.h+2−0

@@ -99,7 +99,9 @@ struct st_lsm6dsx_fs { · 98 unmodified lines
99	#define ST_LSM6DSX_FS_LIST_SIZE 4	99	#define ST_LSM6DSX_FS_LIST_SIZE 4
100	struct st_lsm6dsx_fs_table_entry {	100	struct st_lsm6dsx_fs_table_entry {
101	struct st_lsm6dsx_reg reg;	101	struct st_lsm6dsx_reg reg;
		102
102	struct st_lsm6dsx_fs fs_avl[ST_LSM6DSX_FS_LIST_SIZE];	103	struct st_lsm6dsx_fs fs_avl[ST_LSM6DSX_FS_LIST_SIZE];
		104	int fs_len;
103	};	105	};
104		106
105	/**	107	/**

drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c+19−9

 				.fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 				.fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 				.fs_avl[3] = { IIO_G_TO_M_S_2(732), 0x1 },
+				.fs_len = 4,
 			},
 			[ST_LSM6DSX_ID_GYRO] = {
 				.reg = {
 				.fs_avl[0] = {  IIO_DEGREE_TO_RAD(245), 0x0 },
 				.fs_avl[1] = {  IIO_DEGREE_TO_RAD(500), 0x1 },
 				.fs_avl[2] = { IIO_DEGREE_TO_RAD(2000), 0x3 },
+				.fs_len = 3,
 			},
 		},
 	},
 				.fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 				.fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 				.fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
+				.fs_len = 4,
 			},
 			[ST_LSM6DSX_ID_GYRO] = {
 				.reg = {
 				.fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 				.fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 				.fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
+				.fs_len = 4,
 			},
 		},
 		.decimator = {
 				.fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 				.fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 				.fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
+				.fs_len = 4,
 			},
 			[ST_LSM6DSX_ID_GYRO] = {
 				.reg = {
 				.fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 				.fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 				.fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
+				.fs_len = 4,
 			},
 		},
 		.decimator = {
 				.fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 				.fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 				.fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
+				.fs_len = 4,
 			},
 			[ST_LSM6DSX_ID_GYRO] = {
 				.reg = {
 				.fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 				.fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 				.fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
+				.fs_len = 4,
 			},
 		},
 		.decimator = {
 				.fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 				.fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 				.fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
+				.fs_len = 4,
 			},
 			[ST_LSM6DSX_ID_GYRO] = {
 				.reg = {
 				.fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 				.fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 				.fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
+				.fs_len = 4,
 			},
 		},
 		.batch = {
 				.fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 				.fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 				.fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
+				.fs_len = 4,
 			},
 			[ST_LSM6DSX_ID_GYRO] = {
 				.reg = {
 				.fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 				.fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 				.fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
+				.fs_len = 4,
 			},
 		},
 		.batch = {
 				.fs_avl[1] = { IIO_G_TO_M_S_2(122), 0x2 },
 				.fs_avl[2] = { IIO_G_TO_M_S_2(244), 0x3 },
 				.fs_avl[3] = { IIO_G_TO_M_S_2(488), 0x1 },
+				.fs_len = 4,
 			},
 			[ST_LSM6DSX_ID_GYRO] = {
 				.reg = {
 				.fs_avl[1] = { IIO_DEGREE_TO_RAD(17500), 0x1 },
 				.fs_avl[2] = { IIO_DEGREE_TO_RAD(35000), 0x2 },
 				.fs_avl[3] = { IIO_DEGREE_TO_RAD(70000), 0x3 },
+				.fs_len = 4,
 			},
 		},
 		.batch = {
 	int i, err;
 	fs_table = &sensor->hw->settings->fs_table[sensor->id];
-	for (i = 0; i < ST_LSM6DSX_FS_LIST_SIZE; i++)
+	for (i = 0; i < fs_table->fs_len; i++) {
 		if (fs_table->fs_avl[i].gain == gain)
 			break;
+	}
-	if (i == ST_LSM6DSX_FS_LIST_SIZE)
+	if (i == fs_table->fs_len)
 		return -EINVAL;
 	data = ST_LSM6DSX_SHIFT_VAL(fs_table->fs_avl[i].val,
 {
 	struct st_lsm6dsx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
 	const struct st_lsm6dsx_fs_table_entry *fs_table;
-	enum st_lsm6dsx_sensor_id id = sensor->id;
 	struct st_lsm6dsx_hw *hw = sensor->hw;
 	int i, len = 0;
-	fs_table = &hw->settings->fs_table[id];
+	fs_table = &hw->settings->fs_table[sensor->id];
-	for (i = 0; i < ST_LSM6DSX_FS_LIST_SIZE; i++) {
+	for (i = 0; i < fs_table->fs_len; i++)
-		if (!fs_table->fs_avl[i].gain)
-			break;
 		len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ",
 				 fs_table->fs_avl[i].gain);
-	}
 	buf[len - 1] = '\n';
 	return len;

drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_shub.c+7−8

@@ -61,6 +61,7 @@ static const struct st_lsm6dsx_ext_dev_settings st_lsm6dsx_ext_dev_table[] = { · 60 unmodified lines
61	.gain = 1500,	61	.gain = 1500,
62	.val = 0x0,	62	.val = 0x0,
63	}, /* 1500 uG/LSB */	63	}, /* 1500 uG/LSB */
		64	.fs_len = 1,
64	},	65	},
65	.temp_comp = {	66	.temp_comp = {
66	.addr = 0x60,	67	.addr = 0x60,
@@ -92,9 +93,11 @@ static const struct st_lsm6dsx_ext_dev_settings st_lsm6dsx_ext_dev_table[] = { · 25 unmodified lines
92	static void st_lsm6dsx_shub_wait_complete(struct st_lsm6dsx_hw *hw)	93	static void st_lsm6dsx_shub_wait_complete(struct st_lsm6dsx_hw *hw)
93	{	94	{
94	struct st_lsm6dsx_sensor *sensor;	95	struct st_lsm6dsx_sensor *sensor;
		96	u16 odr;
95		97
96	sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);	98	sensor = iio_priv(hw->iio_devs[ST_LSM6DSX_ID_ACC]);
97	msleep((2000U / sensor->odr) + 1);	99	odr = (hw->enable_mask & BIT(ST_LSM6DSX_ID_ACC)) ? sensor->odr : 13;
		100	msleep((2000U / odr) + 1);
98	}	101	}
99		102
100	/**	103	/**
@@ -555,13 +558,9 @@ static ssize_t st_lsm6dsx_shub_scale_avail(struct device *dev, · 454 unmodified lines
555	int i, len = 0;	558	int i, len = 0;
556		559
557	settings = sensor->ext_info.settings;	560	settings = sensor->ext_info.settings;
558	for (i = 0; i < ST_LSM6DSX_FS_LIST_SIZE; i++) {	561	for (i = 0; i < settings->fs_table.fs_len; i++)
559	u16 val = settings->fs_table.fs_avl[i].gain;	562	len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ",
560		563	settings->fs_table.fs_avl[i].gain);
561	if (val > 0)
562	len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ",
563	val);
564	}
565	buf[len - 1] = '\n';	564	buf[len - 1] = '\n';
566		565
567	return len;	566	return len;

drivers/iio/light/Kconfig+1−0

@@ -314,6 +314,7 @@ config MAX44009 · 313 unmodified lines
314	config NOA1305	314	config NOA1305
315	tristate "ON Semiconductor NOA1305 ambient light sensor"	315	tristate "ON Semiconductor NOA1305 ambient light sensor"
316	depends on I2C	316	depends on I2C
		317	select REGMAP_I2C
317	help	318	help
318	Say Y here if you want to build support for the ON Semiconductor	319	Say Y here if you want to build support for the ON Semiconductor
319	NOA1305 ambient light sensor.	320	NOA1305 ambient light sensor.

drivers/iio/light/opt3001.c+5−1

 	struct iio_dev *iio = _iio;
 	struct opt3001 *opt = iio_priv(iio);
 	int ret;
+	bool wake_result_ready_queue = false;
 	if (!opt->ok_to_ignore_lock)
 		mutex_lock(&opt->lock);
 		}
 		opt->result = ret;
 		opt->result_ready = true;
-		wake_up(&opt->result_ready_queue);
+		wake_result_ready_queue = true;
 	}
 out:
 	if (!opt->ok_to_ignore_lock)
 		mutex_unlock(&opt->lock);
+	if (wake_result_ready_queue)
+		wake_up(&opt->result_ready_queue);
 	return IRQ_HANDLED;
 }

drivers/iio/light/vcnl4000.c+9−5

 static const struct of_device_id vcnl_4000_of_match[] = {
 	{
 		.compatible = "vishay,vcnl4000",
-		.data = "VCNL4000",
+		.data = (void *)VCNL4000,
 	},
 	{
 		.compatible = "vishay,vcnl4010",
-		.data = "VCNL4010",
+		.data = (void *)VCNL4010,
 	},
 	{
-		.compatible = "vishay,vcnl4010",
+		.compatible = "vishay,vcnl4020",
-		.data = "VCNL4020",
+		.data = (void *)VCNL4010,
+	},
+	{
+		.compatible = "vishay,vcnl4040",
+		.data = (void *)VCNL4040,
 	},
 	{
 		.compatible = "vishay,vcnl4200",
-		.data = "VCNL4200",
+		.data = (void *)VCNL4200,
 	},
 	{},
 };

drivers/infiniband/core/cm.c+3−0

 error1:
 	port_modify.set_port_cap_mask = 0;
 	port_modify.clr_port_cap_mask = IB_PORT_CM_SUP;
+	kfree(port);
 	while (--i) {
 		if (!rdma_cap_ib_cm(ib_device, i))
 			continue;
 		ib_modify_port(ib_device, port->port_num, 0, &port_modify);
 		ib_unregister_mad_agent(port->mad_agent);
 		cm_remove_port_fs(port);
+		kfree(port);
 	}
 free:
 	kfree(cm_dev);
 		spin_unlock_irq(&cm.state_lock);
 		ib_unregister_mad_agent(cur_mad_agent);
 		cm_remove_port_fs(port);
+		kfree(port);
 	}
 	kfree(cm_dev);

drivers/infiniband/core/cma.c+2−1

 		conn_id->cm_id.iw = NULL;
 		cma_exch(conn_id, RDMA_CM_DESTROYING);
 		mutex_unlock(&conn_id->handler_mutex);
+		mutex_unlock(&listen_id->handler_mutex);
 		cma_deref_id(conn_id);
 		rdma_destroy_id(&conn_id->id);
-		goto out;
+		return ret;
 	}
 	mutex_unlock(&conn_id->handler_mutex);

drivers/infiniband/core/device.c+5−4

 	if (!netdev)
 		return -ENODEV;
-	dev_put(netdev);
 	port_attr->max_mtu = IB_MTU_4096;
 	port_attr->active_mtu = ib_mtu_int_to_enum(netdev->mtu);
 		port_attr->state = IB_PORT_DOWN;
 		port_attr->phys_state = IB_PORT_PHYS_STATE_DISABLED;
 	} else {
-		inetdev = in_dev_get(netdev);
+		rcu_read_lock();
+		inetdev = __in_dev_get_rcu(netdev);
 		if (inetdev && inetdev->ifa_list) {
 			port_attr->state = IB_PORT_ACTIVE;
 			port_attr->phys_state = IB_PORT_PHYS_STATE_LINK_UP;
-			in_dev_put(inetdev);
 		} else {
 			port_attr->state = IB_PORT_INIT;
 			port_attr->phys_state =
 				IB_PORT_PHYS_STATE_PORT_CONFIGURATION_TRAINING;
 		}
+		rcu_read_unlock();
 	}
+	dev_put(netdev);
 	err = device->ops.query_port(device, port_num, port_attr);
 	if (err)
 		return err;

drivers/infiniband/core/nldev.c+5−7

 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 	if (!msg) {
 		ret = -ENOMEM;
-		goto err;
+		goto err_get;
 	}
 	nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
 	cntn = nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID]);
 	qpn = nla_get_u32(tb[RDMA_NLDEV_ATTR_RES_LQPN]);
-	ret = rdma_counter_unbind_qpn(device, port, qpn, cntn);
-	if (ret)
-		goto err_unbind;
 	if (fill_nldev_handle(msg, device) ||
 	    nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port) ||
 	    nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_COUNTER_ID, cntn) ||
 		goto err_fill;
 	}
+	ret = rdma_counter_unbind_qpn(device, port, qpn, cntn);
+	if (ret)
+		goto err_fill;
 	nlmsg_end(msg, nlh);
 	ib_device_put(device);
 	return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
 err_fill:
-	rdma_counter_bind_qpn(device, port, qpn, cntn);
-err_unbind:
 	nlmsg_free(msg);
 err:
 	ib_device_put(device);

drivers/infiniband/core/security.c+1−1

@@ -426,7 +426,7 @@ int ib_create_qp_security(struct ib_qp qp, struct ib_device dev) · 425 unmodified lines
426	int ret;	426	int ret;
427		427
428	rdma_for_each_port (dev, i) {	428	rdma_for_each_port (dev, i) {
429	is_ib = rdma_protocol_ib(dev, i++);	429	is_ib = rdma_protocol_ib(dev, i);
430	if (is_ib)	430	if (is_ib)
431	break;	431	break;
432	}	432	}

drivers/infiniband/core/umem_odp.c+4−2

 	 * that the hardware will not attempt to access the MR any more.
 	 */
 	if (!umem_odp->is_implicit_odp) {
+		mutex_lock(&umem_odp->umem_mutex);
 		ib_umem_odp_unmap_dma_pages(umem_odp, ib_umem_start(umem_odp),
 					    ib_umem_end(umem_odp));
+		mutex_unlock(&umem_odp->umem_mutex);
 		kvfree(umem_odp->dma_list);
 		kvfree(umem_odp->page_list);
 	}
 	u64 addr;
 	struct ib_device *dev = umem_odp->umem.ibdev;
+	lockdep_assert_held(&umem_odp->umem_mutex);
 	virt = max_t(u64, virt, ib_umem_start(umem_odp));
 	bound = min_t(u64, bound, ib_umem_end(umem_odp));
 	/* Note that during the run of this function, the
 	 * faults from completion. We might be racing with other
 	 * invalidations, so we must make sure we free each page only
 	 * once. */
-	mutex_lock(&umem_odp->umem_mutex);
 	for (addr = virt; addr < bound; addr += BIT(umem_odp->page_shift)) {
 		idx = (addr - ib_umem_start(umem_odp)) >> umem_odp->page_shift;
 		if (umem_odp->page_list[idx]) {
 			umem_odp->npages--;
 		}
 	}
-	mutex_unlock(&umem_odp->umem_mutex);
 }
 EXPORT_SYMBOL(ib_umem_odp_unmap_dma_pages);

drivers/infiniband/hw/cxgb4/device.c+5−2

 	}
 }
-static int dump_qp(struct c4iw_qp *qp, struct c4iw_debugfs_data *qpd)
+static int dump_qp(unsigned long id, struct c4iw_qp *qp,
+		   struct c4iw_debugfs_data *qpd)
 {
 	int space;
 	int cc;
+	if (id != qp->wq.sq.qid)
+		return 0;
 	space = qpd->bufsize - qpd->pos - 1;
 	if (space == 0)
 	xa_lock_irq(&qpd->devp->qps);
 	xa_for_each(&qpd->devp->qps, index, qp)
-		dump_qp(qp, qpd);
+		dump_qp(index, qp, qpd);
 	xa_unlock_irq(&qpd->devp->qps);
 	qpd->buf[qpd->pos++] = 0;

drivers/infiniband/hw/cxgb4/mem.c+17−11

 			   struct sk_buff *skb, struct c4iw_wr_wait *wr_waitp)
 {
 	int err;
-	struct fw_ri_tpte tpt;
+	struct fw_ri_tpte *tpt;
 	u32 stag_idx;
 	static atomic_t key;
 	if (c4iw_fatal_error(rdev))
 		return -EIO;
+	tpt = kmalloc(sizeof(*tpt), GFP_KERNEL);
+	if (!tpt)
+		return -ENOMEM;
 	stag_state = stag_state > 0;
 	stag_idx = (*stag) >> 8;
 			mutex_lock(&rdev->stats.lock);
 			rdev->stats.stag.fail++;
 			mutex_unlock(&rdev->stats.lock);
+			kfree(tpt);
 			return -ENOMEM;
 		}
 		mutex_lock(&rdev->stats.lock);
 	/* write TPT entry */
 	if (reset_tpt_entry)
-		memset(&tpt, 0, sizeof(tpt));
+		memset(tpt, 0, sizeof(*tpt));
 	else {
-		tpt.valid_to_pdid = cpu_to_be32(FW_RI_TPTE_VALID_F |
+		tpt->valid_to_pdid = cpu_to_be32(FW_RI_TPTE_VALID_F |
 			FW_RI_TPTE_STAGKEY_V((*stag & FW_RI_TPTE_STAGKEY_M)) |
 			FW_RI_TPTE_STAGSTATE_V(stag_state) |
 			FW_RI_TPTE_STAGTYPE_V(type) | FW_RI_TPTE_PDID_V(pdid));
-		tpt.locread_to_qpid = cpu_to_be32(FW_RI_TPTE_PERM_V(perm) |
+		tpt->locread_to_qpid = cpu_to_be32(FW_RI_TPTE_PERM_V(perm) |
 			(bind_enabled ? FW_RI_TPTE_MWBINDEN_F : 0) |
 			FW_RI_TPTE_ADDRTYPE_V((zbva ? FW_RI_ZERO_BASED_TO :
 						      FW_RI_VA_BASED_TO))|
 			FW_RI_TPTE_PS_V(page_size));
-		tpt.nosnoop_pbladdr = !pbl_size ? 0 : cpu_to_be32(
+		tpt->nosnoop_pbladdr = !pbl_size ? 0 : cpu_to_be32(
 			FW_RI_TPTE_PBLADDR_V(PBL_OFF(rdev, pbl_addr)>>3));
-		tpt.len_lo = cpu_to_be32((u32)(len & 0xffffffffUL));
+		tpt->len_lo = cpu_to_be32((u32)(len & 0xffffffffUL));
-		tpt.va_hi = cpu_to_be32((u32)(to >> 32));
+		tpt->va_hi = cpu_to_be32((u32)(to >> 32));
-		tpt.va_lo_fbo = cpu_to_be32((u32)(to & 0xffffffffUL));
+		tpt->va_lo_fbo = cpu_to_be32((u32)(to & 0xffffffffUL));
-		tpt.dca_mwbcnt_pstag = cpu_to_be32(0);
+		tpt->dca_mwbcnt_pstag = cpu_to_be32(0);
-		tpt.len_hi = cpu_to_be32((u32)(len >> 32));
+		tpt->len_hi = cpu_to_be32((u32)(len >> 32));
 	}
 	err = write_adapter_mem(rdev, stag_idx +
 				(rdev->lldi.vr->stag.start >> 5),
-				sizeof(tpt), &tpt, skb, wr_waitp);
+				sizeof(*tpt), tpt, skb, wr_waitp);
 	if (reset_tpt_entry) {
 		c4iw_put_resource(&rdev->resource.tpt_table, stag_idx);
 		rdev->stats.stag.cur -= 32;
 		mutex_unlock(&rdev->stats.lock);
 	}
+	kfree(tpt);
 	return err;
 }

drivers/infiniband/hw/cxgb4/qp.c+1−9

 	if (CHELSIO_CHIP_VERSION(rhp->rdev.lldi.adapter_type) > CHELSIO_T6)
 		srq->flags = T4_SRQ_LIMIT_SUPPORT;
-	ret = xa_insert_irq(&rhp->qps, srq->wq.qid, srq, GFP_KERNEL);
-	if (ret)
-		goto err_free_queue;
 	if (udata) {
 		srq_key_mm = kmalloc(sizeof(*srq_key_mm), GFP_KERNEL);
 		if (!srq_key_mm) {
 			ret = -ENOMEM;
-			goto err_remove_handle;
+			goto err_free_queue;
 		}
 		srq_db_key_mm = kmalloc(sizeof(*srq_db_key_mm), GFP_KERNEL);
 		if (!srq_db_key_mm) {
 	kfree(srq_db_key_mm);
 err_free_srq_key_mm:
 	kfree(srq_key_mm);
-err_remove_handle:
-	xa_erase_irq(&rhp->qps, srq->wq.qid);
 err_free_queue:
 	free_srq_queue(srq, ucontext ? &ucontext->uctx : &rhp->rdev.uctx,
 		       srq->wr_waitp);
 	rhp = srq->rhp;
 	pr_debug("%s id %d\n", __func__, srq->wq.qid);
-	xa_erase_irq(&rhp->qps, srq->wq.qid);
 	ucontext = rdma_udata_to_drv_context(udata, struct c4iw_ucontext,
 					     ibucontext);
 	free_srq_queue(srq, ucontext ? &ucontext->uctx : &rhp->rdev.uctx,

drivers/infiniband/hw/hfi1/sdma.c+4−1

 	}
 	ret = rhashtable_init(tmp_sdma_rht, &sdma_rht_params);
-	if (ret < 0)
+	if (ret < 0) {
+		kfree(tmp_sdma_rht);
 		goto bail;
+	}
 	dd->sdma_rht = tmp_sdma_rht;
 	dd_dev_info(dd, "SDMA num_sdma: %u\n", dd->num_sdma);

drivers/infiniband/hw/i40iw/i40iw_verbs.c+4−0

 		return -ENOMEM;
 	iwibdev = iwdev->iwibdev;
 	rdma_set_device_sysfs_group(&iwibdev->ibdev, &i40iw_attr_group);
+	ret = ib_device_set_netdev(&iwibdev->ibdev, iwdev->netdev, 1);
+	if (ret)
+		goto error;
 	ret = ib_register_device(&iwibdev->ibdev, "i40iw%d");
 	if (ret)
 		goto error;

drivers/infiniband/hw/mlx5/devx.c+16−42

 	return 0;
 }
-static void devx_free_indirect_mkey(struct rcu_head *rcu)
-{
-	kfree(container_of(rcu, struct devx_obj, devx_mr.rcu));
-}
-/* This function to delete from the radix tree needs to be called before
- * destroying the underlying mkey. Otherwise a race might occur in case that
- * other thread will get the same mkey before this one will be deleted,
- * in that case it will fail via inserting to the tree its own data.
- *
- * Note:
- * An error in the destroy is not expected unless there is some other indirect
- * mkey which points to this one. In a kernel cleanup flow it will be just
- * destroyed in the iterative destruction call. In a user flow, in case
- * the application didn't close in the expected order it's its own problem,
- * the mkey won't be part of the tree, in both cases the kernel is safe.
- */
-static void devx_cleanup_mkey(struct devx_obj *obj)
-{
-	xa_erase(&obj->ib_dev->mdev->priv.mkey_table,
-		 mlx5_base_mkey(obj->devx_mr.mmkey.key));
-}
 static void devx_cleanup_subscription(struct mlx5_ib_dev *dev,
 				      struct devx_event_subscription *sub)
 {
 	int ret;
 	dev = mlx5_udata_to_mdev(&attrs->driver_udata);
-	if (obj->flags & DEVX_OBJ_FLAGS_INDIRECT_MKEY)
+	if (obj->flags & DEVX_OBJ_FLAGS_INDIRECT_MKEY) {
-		devx_cleanup_mkey(obj);
+		/*
+		 * The pagefault_single_data_segment() does commands against
+		 * the mmkey, we must wait for that to stop before freeing the
+		 * mkey, as another allocation could get the same mkey #.
+		 */
+		xa_erase(&obj->ib_dev->mdev->priv.mkey_table,
+			 mlx5_base_mkey(obj->devx_mr.mmkey.key));
+		synchronize_srcu(&dev->mr_srcu);
+	}
 	if (obj->flags & DEVX_OBJ_FLAGS_DCT)
 		ret = mlx5_core_destroy_dct(obj->ib_dev->mdev, &obj->core_dct);
 		devx_cleanup_subscription(dev, sub_entry);
 	mutex_unlock(&devx_event_table->event_xa_lock);
-	if (obj->flags & DEVX_OBJ_FLAGS_INDIRECT_MKEY) {
-		call_srcu(&dev->mr_srcu, &obj->devx_mr.rcu,
-			  devx_free_indirect_mkey);
-		return ret;
-	}
 	kfree(obj);
 	return ret;
 }
 				   &obj_id);
 	WARN_ON(obj->dinlen > MLX5_MAX_DESTROY_INBOX_SIZE_DW * sizeof(u32));
-	if (obj->flags & DEVX_OBJ_FLAGS_INDIRECT_MKEY) {
-		err = devx_handle_mkey_indirect(obj, dev, cmd_in, cmd_out);
-		if (err)
-			goto obj_destroy;
-	}
 	err = uverbs_copy_to(attrs, MLX5_IB_ATTR_DEVX_OBJ_CREATE_CMD_OUT, cmd_out, cmd_out_len);
 	if (err)
-		goto err_copy;
+		goto obj_destroy;
 	if (opcode == MLX5_CMD_OP_CREATE_GENERAL_OBJECT)
 		obj_type = MLX5_GET(general_obj_in_cmd_hdr, cmd_in, obj_type);
 	obj->obj_id = get_enc_obj_id(opcode | obj_type << 16, obj_id);
+	if (obj->flags & DEVX_OBJ_FLAGS_INDIRECT_MKEY) {
+		err = devx_handle_mkey_indirect(obj, dev, cmd_in, cmd_out);
+		if (err)
+			goto obj_destroy;
+	}
 	return 0;
-err_copy:
-	if (obj->flags & DEVX_OBJ_FLAGS_INDIRECT_MKEY)
-		devx_cleanup_mkey(obj);
 obj_destroy:
 	if (obj->flags & DEVX_OBJ_FLAGS_DCT)
 		mlx5_core_destroy_dct(obj->ib_dev->mdev, &obj->core_dct);

drivers/infiniband/hw/mlx5/mlx5_ib.h+1−2

 	struct mlx5_ib_dev     *dev;
 	u32 out[MLX5_ST_SZ_DW(create_mkey_out)];
 	struct mlx5_core_sig_ctx    *sig;
-	int			live;
+	unsigned int		live;
 	void			*descs_alloc;
 	int			access_flags; /* Needed for rereg MR */
 struct mlx5_ib_devx_mr {
 	struct mlx5_core_mkey	mmkey;
 	int			ndescs;
-	struct rcu_head		rcu;
 };
 struct mlx5_ib_umr_context {

drivers/infiniband/hw/mlx5/mr.c+27−41

 		length + (start & (MLX5_ADAPTER_PAGE_SIZE - 1));
 }
-static void update_odp_mr(struct mlx5_ib_mr *mr)
-{
-	if (is_odp_mr(mr)) {
-		/*
-		 * This barrier prevents the compiler from moving the
-		 * setting of umem->odp_data->private to point to our
-		 * MR, before reg_umr finished, to ensure that the MR
-		 * initialization have finished before starting to
-		 * handle invalidations.
-		 */
-		smp_wmb();
-		to_ib_umem_odp(mr->umem)->private = mr;
-		/*
-		 * Make sure we will see the new
-		 * umem->odp_data->private value in the invalidation
-		 * routines, before we can get page faults on the
-		 * MR. Page faults can happen once we put the MR in
-		 * the tree, below this line. Without the barrier,
-		 * there can be a fault handling and an invalidation
-		 * before umem->odp_data->private == mr is visible to
-		 * the invalidation handler.
-		 */
-		smp_wmb();
-	}
-}
 static void reg_mr_callback(int status, struct mlx5_async_work *context)
 {
 	struct mlx5_ib_mr *mr =
 	mr->umem = umem;
 	set_mr_fields(dev, mr, npages, length, access_flags);
-	update_odp_mr(mr);
 	if (use_umr) {
 		int update_xlt_flags = MLX5_IB_UPD_XLT_ENABLE;
 		}
 	}
-	if (IS_ENABLED(CONFIG_INFINIBAND_ON_DEMAND_PAGING)) {
+	if (is_odp_mr(mr)) {
-		mr->live = 1;
+		to_ib_umem_odp(mr->umem)->private = mr;
 		atomic_set(&mr->num_pending_prefetch, 0);
 	}
+	if (IS_ENABLED(CONFIG_INFINIBAND_ON_DEMAND_PAGING))
+		smp_store_release(&mr->live, 1);
 	return &mr->ibmr;
 error:
 	if (!mr->umem)
 		return -EINVAL;
+	if (is_odp_mr(mr))
+		return -EOPNOTSUPP;
 	if (flags & IB_MR_REREG_TRANS) {
 		addr = virt_addr;
 		len = length;
 		}
 		mr->allocated_from_cache = 0;
-		if (IS_ENABLED(CONFIG_INFINIBAND_ON_DEMAND_PAGING))
-			mr->live = 1;
 	} else {
 		/*
 		 * Send a UMR WQE
 	set_mr_fields(dev, mr, npages, len, access_flags);
-	update_odp_mr(mr);
 	return 0;
 err:
 		/* Prevent new page faults and
 		 * prefetch requests from succeeding
 		 */
-		mr->live = 0;
+		WRITE_ONCE(mr->live, 0);
+		/* Wait for all running page-fault handlers to finish. */
+		synchronize_srcu(&dev->mr_srcu);
 		/* dequeue pending prefetch requests for the mr */
 		if (atomic_read(&mr->num_pending_prefetch))
 			flush_workqueue(system_unbound_wq);
 		WARN_ON(atomic_read(&mr->num_pending_prefetch));
-		/* Wait for all running page-fault handlers to finish. */
-		synchronize_srcu(&dev->mr_srcu);
 		/* Destroy all page mappings */
 		if (!umem_odp->is_implicit_odp)
 			mlx5_ib_invalidate_range(umem_odp,
 int mlx5_ib_dealloc_mw(struct ib_mw *mw)
 {
+	struct mlx5_ib_dev *dev = to_mdev(mw->device);
 	struct mlx5_ib_mw *mmw = to_mmw(mw);
 	int err;
-	err =  mlx5_core_destroy_mkey((to_mdev(mw->device))->mdev,
+	if (IS_ENABLED(CONFIG_INFINIBAND_ON_DEMAND_PAGING)) {
-				      &mmw->mmkey);
+		xa_erase(&dev->mdev->priv.mkey_table,
-	if (!err)
+			 mlx5_base_mkey(mmw->mmkey.key));
-		kfree(mmw);
+		/*
-	return err;
+		 * pagefault_single_data_segment() may be accessing mmw under
+		 * SRCU if the user bound an ODP MR to this MW.
+		 */
+		synchronize_srcu(&dev->mr_srcu);
+	}
+	err = mlx5_core_destroy_mkey(dev->mdev, &mmw->mmkey);
+	if (err)
+		return err;
+	kfree(mmw);
+	return 0;
 }
 int mlx5_ib_check_mr_status(struct ib_mr *ibmr, u32 check_mask,

drivers/infiniband/hw/mlx5/odp.c+47−11

 		return;
 	}
+	/*
+	 * The locking here is pretty subtle. Ideally the implicit children
+	 * list would be protected by the umem_mutex, however that is not
+	 * possible. Instead this uses a weaker update-then-lock pattern:
+	 *
+	 *  srcu_read_lock()
+	 *    <change children list>
+	 *    mutex_lock(umem_mutex)
+	 *     mlx5_ib_update_xlt()
+	 *    mutex_unlock(umem_mutex)
+	 *    destroy lkey
+	 *
+	 * ie any change the children list must be followed by the locked
+	 * update_xlt before destroying.
+	 *
+	 * The umem_mutex provides the acquire/release semantic needed to make
+	 * the children list visible to a racing thread. While SRCU is not
+	 * technically required, using it gives consistent use of the SRCU
+	 * locking around the children list.
+	 */
+	lockdep_assert_held(&to_ib_umem_odp(mr->umem)->umem_mutex);
+	lockdep_assert_held(&mr->dev->mr_srcu);
 	odp = odp_lookup(offset * MLX5_IMR_MTT_SIZE,
 			 nentries * MLX5_IMR_MTT_SIZE, mr);
 	struct ib_umem_odp *odp = container_of(work, struct ib_umem_odp, work);
 	int idx = ib_umem_start(odp) >> MLX5_IMR_MTT_SHIFT;
 	struct mlx5_ib_mr *mr = odp->private, *imr = mr->parent;
+	struct ib_umem_odp *odp_imr = to_ib_umem_odp(imr->umem);
+	int srcu_key;
 	mr->parent = NULL;
 	synchronize_srcu(&mr->dev->mr_srcu);
-	ib_umem_odp_release(odp);
+	if (smp_load_acquire(&imr->live)) {
-	if (imr->live)
+		srcu_key = srcu_read_lock(&mr->dev->mr_srcu);
+		mutex_lock(&odp_imr->umem_mutex);
 		mlx5_ib_update_xlt(imr, idx, 1, 0,
 				   MLX5_IB_UPD_XLT_INDIRECT |
 				   MLX5_IB_UPD_XLT_ATOMIC);
+		mutex_unlock(&odp_imr->umem_mutex);
+		srcu_read_unlock(&mr->dev->mr_srcu, srcu_key);
+	}
+	ib_umem_odp_release(odp);
 	mlx5_mr_cache_free(mr->dev, mr);
 	if (atomic_dec_and_test(&imr->num_leaf_free))
 				   idx - blk_start_idx + 1, 0,
 				   MLX5_IB_UPD_XLT_ZAP |
 				   MLX5_IB_UPD_XLT_ATOMIC);
-	mutex_unlock(&umem_odp->umem_mutex);
 	/*
 	 * We are now sure that the device will not access the
 	 * memory. We can safely unmap it, and mark it as dirty if
 	if (unlikely(!umem_odp->npages && mr->parent &&
 		     !umem_odp->dying)) {
-		WRITE_ONCE(umem_odp->dying, 1);
+		WRITE_ONCE(mr->live, 0);
+		umem_odp->dying = 1;
 		atomic_inc(&mr->parent->num_leaf_free);
 		schedule_work(&umem_odp->work);
 	}
+	mutex_unlock(&umem_odp->umem_mutex);
 }
 void mlx5_ib_internal_fill_odp_caps(struct mlx5_ib_dev *dev)
 	mr->ibmr.lkey = mr->mmkey.key;
 	mr->ibmr.rkey = mr->mmkey.key;
-	mr->live = 1;
 	mlx5_ib_dbg(dev, "key %x dev %p mr %p\n",
 		    mr->mmkey.key, dev->mdev, mr);
 		mtt->parent = mr;
 		INIT_WORK(&odp->work, mr_leaf_free_action);
+		smp_store_release(&mtt->live, 1);
 		if (!nentries)
 			start_idx = addr >> MLX5_IMR_MTT_SHIFT;
 		nentries++;
 	init_waitqueue_head(&imr->q_leaf_free);
 	atomic_set(&imr->num_leaf_free, 0);
 	atomic_set(&imr->num_pending_prefetch, 0);
+	smp_store_release(&imr->live, 1);
 	return imr;
 }
 		if (mr->parent != imr)
 			continue;
+		mutex_lock(&umem_odp->umem_mutex);
 		ib_umem_odp_unmap_dma_pages(umem_odp, ib_umem_start(umem_odp),
 					    ib_umem_end(umem_odp));
-		if (umem_odp->dying)
+		if (umem_odp->dying) {
+			mutex_unlock(&umem_odp->umem_mutex);
 			continue;
+		}
-		WRITE_ONCE(umem_odp->dying, 1);
+		umem_odp->dying = 1;
 		atomic_inc(&imr->num_leaf_free);
 		schedule_work(&umem_odp->work);
+		mutex_unlock(&umem_odp->umem_mutex);
 	}
 	up_read(&per_mm->umem_rwsem);
 	switch (mmkey->type) {
 	case MLX5_MKEY_MR:
 		mr = container_of(mmkey, struct mlx5_ib_mr, mmkey);
-		if (!mr->live || !mr->ibmr.pd) {
+		if (!smp_load_acquire(&mr->live) || !mr->ibmr.pd) {
 			mlx5_ib_dbg(dev, "got dead MR\n");
 			ret = -EFAULT;
 			goto srcu_unlock;
 		mr = container_of(mmkey, struct mlx5_ib_mr, mmkey);
-		if (mr->ibmr.pd != pd) {
+		if (!smp_load_acquire(&mr->live)) {
 			ret = false;
 			break;
 		}
-		if (!mr->live) {
+		if (mr->ibmr.pd != pd) {
 			ret = false;
 			break;
 		}

drivers/infiniband/hw/vmw_pvrdma/pvrdma_srq.c+0−2

@@ -230,8 +230,6 @@ static void pvrdma_free_srq(struct pvrdma_dev dev, struct pvrdma_srq srq) · 229 unmodified lines
230		230
231	pvrdma_page_dir_cleanup(dev, &srq->pdir);	231	pvrdma_page_dir_cleanup(dev, &srq->pdir);
232		232
233	kfree(srq);
234
235	atomic_dec(&dev->num_srqs);	233	atomic_dec(&dev->num_srqs);
236	}	234	}
237		235

drivers/infiniband/sw/siw/siw_qp.c+11−4

  */
 void siw_qp_llp_write_space(struct sock *sk)
 {
-	struct siw_cep *cep = sk_to_cep(sk);
+	struct siw_cep *cep;
-	cep->sk_write_space(sk);
+	read_lock(&sk->sk_callback_lock);
+	cep  = sk_to_cep(sk);
+	if (cep) {
+		cep->sk_write_space(sk);
-	if (!test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
+		if (!test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
-		(void)siw_sq_start(cep->qp);
+			(void)siw_sq_start(cep->qp);
+	}
+	read_unlock(&sk->sk_callback_lock);
 }
 static int siw_qp_readq_init(struct siw_qp *qp, int irq_size, int orq_size)

drivers/input/misc/da9063_onkey.c+1−4

@@ -232,10 +232,7 @@ static int da9063_onkey_probe(struct platform_device *pdev) · 231 unmodified lines
232	onkey->input->phys = onkey->phys;	232	onkey->input->phys = onkey->phys;
233	onkey->input->dev.parent = &pdev->dev;	233	onkey->input->dev.parent = &pdev->dev;
234		234
235	if (onkey->key_power)	235	input_set_capability(onkey->input, EV_KEY, KEY_POWER);
236	input_set_capability(onkey->input, EV_KEY, KEY_POWER);
237
238	input_set_capability(onkey->input, EV_KEY, KEY_SLEEP);
239		236
240	INIT_DELAYED_WORK(&onkey->work, da9063_poll_on);	237	INIT_DELAYED_WORK(&onkey->work, da9063_poll_on);
241		238

drivers/input/misc/soc_button_array.c+12−5

 			continue;
 		gpio = soc_button_lookup_gpio(&pdev->dev, info->acpi_index);
-		if (gpio < 0 && gpio != -ENOENT) {
+		if (!gpio_is_valid(gpio)) {
-			error = gpio;
+			/*
-			goto err_free_mem;
+			 * Skip GPIO if not present. Note we deliberately
-		} else if (!gpio_is_valid(gpio)) {
+			 * ignore -EPROBE_DEFER errors here. On some devices
-			/* Skip GPIO if not present */
+			 * Intel is using so called virtual GPIOs which are not
+			 * GPIOs at all but some way for AML code to check some
+			 * random status bits without need a custom opregion.
+			 * In some cases the resources table we parse points to
+			 * such a virtual GPIO, since these are not real GPIOs
+			 * we do not have a driver for these so they will never
+			 * show up, therefore we ignore -EPROBE_DEFER.
+			 */
 			continue;
 		}

drivers/input/mouse/elantech.c+29−26

 				  leave_breadcrumbs);
 }
-static bool elantech_use_host_notify(struct psmouse *psmouse,
-				     struct elantech_device_info *info)
-{
-	if (ETP_NEW_IC_SMBUS_HOST_NOTIFY(info->fw_version))
-		return true;
-	switch (info->bus) {
-	case ETP_BUS_PS2_ONLY:
-		/* expected case */
-		break;
-	case ETP_BUS_SMB_HST_NTFY_ONLY:
-	case ETP_BUS_PS2_SMB_HST_NTFY:
-		/* SMbus implementation is stable since 2018 */
-		if (dmi_get_bios_year() >= 2018)
-			return true;
-		/* fall through */
-	default:
-		psmouse_dbg(psmouse,
-			    "Ignoring SMBus bus provider %d\n", info->bus);
-		break;
-	}
-	return false;
-}
 /**
  * elantech_setup_smbus - called once the PS/2 devices are enumerated
  * and decides to instantiate a SMBus InterTouch device.
 		 * i2c_blacklist_pnp_ids.
 		 * Old ICs are up to the user to decide.
 		 */
-		if (!elantech_use_host_notify(psmouse, info) ||
+		if (!ETP_NEW_IC_SMBUS_HOST_NOTIFY(info->fw_version) ||
 		    psmouse_matches_pnp_id(psmouse, i2c_blacklist_pnp_ids))
 			return -ENXIO;
 	}
 	return 0;
 }
+static bool elantech_use_host_notify(struct psmouse *psmouse,
+				     struct elantech_device_info *info)
+{
+	if (ETP_NEW_IC_SMBUS_HOST_NOTIFY(info->fw_version))
+		return true;
+	switch (info->bus) {
+	case ETP_BUS_PS2_ONLY:
+		/* expected case */
+		break;
+	case ETP_BUS_SMB_ALERT_ONLY:
+		/* fall-through  */
+	case ETP_BUS_PS2_SMB_ALERT:
+		psmouse_dbg(psmouse, "Ignoring SMBus provider through alert protocol.\n");
+		break;
+	case ETP_BUS_SMB_HST_NTFY_ONLY:
+		/* fall-through  */
+	case ETP_BUS_PS2_SMB_HST_NTFY:
+		return true;
+	default:
+		psmouse_dbg(psmouse,
+			    "Ignoring SMBus bus provider %d.\n",
+			    info->bus);
+	}
+	return false;
+}
 int elantech_init_smbus(struct psmouse *psmouse)
 {
 	struct elantech_device_info info;

drivers/input/rmi4/rmi_driver.c+5−1

 	}
 	mutex_lock(&data->irq_mutex);
-	bitmap_and(data->irq_status, data->irq_status, data->current_irq_mask,
+	bitmap_and(data->irq_status, data->irq_status, data->fn_irq_bits,
 	       data->irq_count);
 	/*
 	 * At this point, irq_status has all bits that are set in the
 	bitmap_copy(data->current_irq_mask, data->new_irq_mask,
 		    data->num_of_irq_regs);
+	bitmap_or(data->fn_irq_bits, data->fn_irq_bits, mask, data->irq_count);
 error_unlock:
 	mutex_unlock(&data->irq_mutex);
 	return error;
 	struct device *dev = &rmi_dev->dev;
 	mutex_lock(&data->irq_mutex);
+	bitmap_andnot(data->fn_irq_bits,
+		      data->fn_irq_bits, mask, data->irq_count);
 	bitmap_andnot(data->new_irq_mask,
 		  data->current_irq_mask, mask, data->irq_count);

drivers/input/touchscreen/goodix.c+50−8

 	const char *cfg_name;
 	struct completion firmware_loading_complete;
 	unsigned long irq_flags;
+	unsigned int contact_size;
 };
 #define GOODIX_GPIO_INT_NAME		"irq"
 #define GOODIX_MAX_WIDTH		4096
 #define GOODIX_INT_TRIGGER		1
 #define GOODIX_CONTACT_SIZE		8
+#define GOODIX_MAX_CONTACT_SIZE		9
 #define GOODIX_MAX_CONTACTS		10
 #define GOODIX_CONFIG_MAX_LENGTH	240
 	{}
 };
+static const struct dmi_system_id nine_bytes_report[] = {
+#if defined(CONFIG_DMI) && defined(CONFIG_X86)
+	{
+		.ident = "Lenovo YogaBook",
+		/* YB1-X91L/F and YB1-X90L/F */
+		.matches = {
+			DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X9")
+		}
+	},
+#endif
+	{}
+};
 /**
  * goodix_i2c_read - read data from a register of the i2c slave device.
  *
 	max_timeout = jiffies + msecs_to_jiffies(GOODIX_BUFFER_STATUS_TIMEOUT);
 	do {
 		error = goodix_i2c_read(ts->client, GOODIX_READ_COOR_ADDR,
-					data, GOODIX_CONTACT_SIZE + 1);
+					data, ts->contact_size + 1);
 		if (error) {
 			dev_err(&ts->client->dev, "I2C transfer error: %d\n",
 					error);
 				return -EPROTO;
 			if (touch_num > 1) {
-				data += 1 + GOODIX_CONTACT_SIZE;
+				data += 1 + ts->contact_size;
 				error = goodix_i2c_read(ts->client,
 						GOODIX_READ_COOR_ADDR +
-							1 + GOODIX_CONTACT_SIZE,
+							1 + ts->contact_size,
 						data,
-						GOODIX_CONTACT_SIZE *
+						ts->contact_size *
 							(touch_num - 1));
 				if (error)
 					return error;
 	return 0;
 }
-static void goodix_ts_report_touch(struct goodix_ts_data *ts, u8 *coor_data)
+static void goodix_ts_report_touch_8b(struct goodix_ts_data *ts, u8 *coor_data)
 {
 	int id = coor_data[0] & 0x0F;
 	int input_x = get_unaligned_le16(&coor_data[1]);
 	input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
 }
+static void goodix_ts_report_touch_9b(struct goodix_ts_data *ts, u8 *coor_data)
+{
+	int id = coor_data[1] & 0x0F;
+	int input_x = get_unaligned_le16(&coor_data[3]);
+	int input_y = get_unaligned_le16(&coor_data[5]);
+	int input_w = get_unaligned_le16(&coor_data[7]);
+	input_mt_slot(ts->input_dev, id);
+	input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
+	touchscreen_report_pos(ts->input_dev, &ts->prop,
+			       input_x, input_y, true);
+	input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
+	input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
+}
 /**
  * goodix_process_events - Process incoming events
  *
  */
 static void goodix_process_events(struct goodix_ts_data *ts)
 {
-	u8  point_data[1 + GOODIX_CONTACT_SIZE * GOODIX_MAX_CONTACTS];
+	u8  point_data[1 + GOODIX_MAX_CONTACT_SIZE * GOODIX_MAX_CONTACTS];
 	int touch_num;
 	int i;
 	input_report_key(ts->input_dev, KEY_LEFTMETA, point_data[0] & BIT(4));
 	for (i = 0; i < touch_num; i++)
-		goodix_ts_report_touch(ts,
+		if (ts->contact_size == 9)
-				&point_data[1 + GOODIX_CONTACT_SIZE * i]);
+			goodix_ts_report_touch_9b(ts,
+				&point_data[1 + ts->contact_size * i]);
+		else
+			goodix_ts_report_touch_8b(ts,
+				&point_data[1 + ts->contact_size * i]);
 	input_mt_sync_frame(ts->input_dev);
 	input_sync(ts->input_dev);
 			"Applying '180 degrees rotated screen' quirk\n");
 	}
+	if (dmi_check_system(nine_bytes_report)) {
+		ts->contact_size = 9;
+		dev_dbg(&ts->client->dev,
+			"Non-standard 9-bytes report format quirk\n");
+	}
 	error = input_mt_init_slots(ts->input_dev, ts->max_touch_num,
 				    INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
 	if (error) {
 	ts->client = client;
 	i2c_set_clientdata(client, ts);
 	init_completion(&ts->firmware_loading_complete);
+	ts->contact_size = GOODIX_CONTACT_SIZE;
 	error = goodix_get_gpio_config(ts);
 	if (error)

drivers/iommu/amd_iommu.c+7−5

 retry:
 	type    = (event[1] >> EVENT_TYPE_SHIFT)  & EVENT_TYPE_MASK;
 	devid   = (event[0] >> EVENT_DEVID_SHIFT) & EVENT_DEVID_MASK;
-	pasid   = PPR_PASID(*(u64 *)&event[0]);
+	pasid   = (event[0] & EVENT_DOMID_MASK_HI) |
+		  (event[1] & EVENT_DOMID_MASK_LO);
 	flags   = (event[1] >> EVENT_FLAGS_SHIFT) & EVENT_FLAGS_MASK;
 	address = (u64)(((u64)event[3]) << 32) | event[2];
 			address, flags);
 		break;
 	case EVENT_TYPE_PAGE_TAB_ERR:
-		dev_err(dev, "Event logged [PAGE_TAB_HARDWARE_ERROR device=%02x:%02x.%x domain=0x%04x address=0x%llx flags=0x%04x]\n",
+		dev_err(dev, "Event logged [PAGE_TAB_HARDWARE_ERROR device=%02x:%02x.%x pasid=0x%04x address=0x%llx flags=0x%04x]\n",
 			PCI_BUS_NUM(devid), PCI_SLOT(devid), PCI_FUNC(devid),
 			pasid, address, flags);
 		break;
  * to 64 bits.
  */
 static bool increase_address_space(struct protection_domain *domain,
+				   unsigned long address,
 				   gfp_t gfp)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&domain->lock, flags);
-	if (WARN_ON_ONCE(domain->mode == PAGE_MODE_6_LEVEL))
+	if (address <= PM_LEVEL_SIZE(domain->mode) ||
-		/* address space already 64 bit large */
+	    WARN_ON_ONCE(domain->mode == PAGE_MODE_6_LEVEL))
 		goto out;
 	pte = (void *)get_zeroed_page(gfp);
 	BUG_ON(!is_power_of_2(page_size));
 	while (address > PM_LEVEL_SIZE(domain->mode))
-		*updated = increase_address_space(domain, gfp) || *updated;
+		*updated = increase_address_space(domain, address, gfp) || *updated;
 	level   = domain->mode - 1;
 	pte     = &domain->pt_root[PM_LEVEL_INDEX(level, address)];

drivers/iommu/amd_iommu_types.h+2−2

@@ -130,8 +130,8 @@ · 129 unmodified lines
130	#define EVENT_TYPE_INV_PPR_REQ 0x9	130	#define EVENT_TYPE_INV_PPR_REQ 0x9
131	#define EVENT_DEVID_MASK 0xffff	131	#define EVENT_DEVID_MASK 0xffff
132	#define EVENT_DEVID_SHIFT 0	132	#define EVENT_DEVID_SHIFT 0
133	#define EVENT_DOMID_MASK 0xffff	133	#define EVENT_DOMID_MASK_LO 0xffff
134	#define EVENT_DOMID_SHIFT 0	134	#define EVENT_DOMID_MASK_HI 0xf0000
135	#define EVENT_FLAGS_MASK 0xfff	135	#define EVENT_FLAGS_MASK 0xfff
136	#define EVENT_FLAGS_SHIFT 0x10	136	#define EVENT_FLAGS_SHIFT 0x10
137		137

drivers/iommu/arm-smmu.c+1−0

@@ -812,6 +812,7 @@ static int arm_smmu_init_domain_context(struct iommu_domain *domain, · 811 unmodified lines
812	return 0;	812	return 0;
813		813
814	out_clear_smmu:	814	out_clear_smmu:
		815	__arm_smmu_free_bitmap(smmu->context_map, cfg->cbndx);
815	smmu_domain->smmu = NULL;	816	smmu_domain->smmu = NULL;
816	out_unlock:	817	out_unlock:
817	mutex_unlock(&smmu_domain->init_mutex);	818	mutex_unlock(&smmu_domain->init_mutex);

drivers/iommu/io-pgtable-arm.c+45−13

@@ -166,6 +166,9 @@ · 165 unmodified lines
166	#define ARM_MALI_LPAE_TTBR_READ_INNER BIT(2)	166	#define ARM_MALI_LPAE_TTBR_READ_INNER BIT(2)
167	#define ARM_MALI_LPAE_TTBR_SHARE_OUTER BIT(4)	167	#define ARM_MALI_LPAE_TTBR_SHARE_OUTER BIT(4)
168		168
		169	#define ARM_MALI_LPAE_MEMATTR_IMP_DEF 0x88ULL
		170	#define ARM_MALI_LPAE_MEMATTR_WRITE_ALLOC 0x8DULL
		171
169	/* IOPTE accessors */	172	/* IOPTE accessors */
170	#define iopte_deref(pte,d) __va(iopte_to_paddr(pte, d))	173	#define iopte_deref(pte,d) __va(iopte_to_paddr(pte, d))
171		174
@@ -1015,27 +1018,56 @@ arm_32_lpae_alloc_pgtable_s2(struct io_pgtable_cfg cfg, void cookie) · 843 unmodified lines
1015	static struct io_pgtable *	1018	static struct io_pgtable *
1016	arm_mali_lpae_alloc_pgtable(struct io_pgtable_cfg cfg, void cookie)	1019	arm_mali_lpae_alloc_pgtable(struct io_pgtable_cfg cfg, void cookie)
1017	{	1020	{
1018	struct io_pgtable *iop;	1021	struct arm_lpae_io_pgtable *data;
1019		1022
1020	if (cfg->ias != 48 \|\| cfg->oas > 40)	1023	/* No quirks for Mali (hopefully) */
		1024	if (cfg->quirks)
		1025	return NULL;
		1026
		1027	if (cfg->ias > 48 \|\| cfg->oas > 40)
1021	return NULL;	1028	return NULL;
1022		1029
1023	cfg->pgsize_bitmap &= (SZ_4K \| SZ_2M \| SZ_1G);	1030	cfg->pgsize_bitmap &= (SZ_4K \| SZ_2M \| SZ_1G);
1024	iop = arm_64_lpae_alloc_pgtable_s1(cfg, cookie);
1025	if (iop) {
1026	u64 mair, ttbr;
1027		1031
1028	/* Copy values as union fields overlap */	1032	data = arm_lpae_alloc_pgtable(cfg);
1029	mair = cfg->arm_lpae_s1_cfg.mair[0];	1033	if (!data)
1030	ttbr = cfg->arm_lpae_s1_cfg.ttbr[0];	1034	return NULL;
1031		1035
1032	cfg->arm_mali_lpae_cfg.memattr = mair;	1036	/* Mali seems to need a full 4-level table regardless of IAS */
1033	cfg->arm_mali_lpae_cfg.transtab = ttbr \|	1037	if (data->levels < ARM_LPAE_MAX_LEVELS) {
1034	ARM_MALI_LPAE_TTBR_READ_INNER \|	1038	data->levels = ARM_LPAE_MAX_LEVELS;
1035	ARM_MALI_LPAE_TTBR_ADRMODE_TABLE;	1039	data->pgd_size = sizeof(arm_lpae_iopte);
1036	}	1040	}
		1041	/*
		1042	* MEMATTR: Mali has no actual notion of a non-cacheable type, so the
		1043	* best we can do is mimic the out-of-tree driver and hope that the
		1044	* "implementation-defined caching policy" is good enough. Similarly,
		1045	* we'll use it for the sake of a valid attribute for our 'device'
		1046	* index, although callers should never request that in practice.
		1047	*/
		1048	cfg->arm_mali_lpae_cfg.memattr =
		1049	(ARM_MALI_LPAE_MEMATTR_IMP_DEF
		1050	<< ARM_LPAE_MAIR_ATTR_SHIFT(ARM_LPAE_MAIR_ATTR_IDX_NC)) \|
		1051	(ARM_MALI_LPAE_MEMATTR_WRITE_ALLOC
		1052	<< ARM_LPAE_MAIR_ATTR_SHIFT(ARM_LPAE_MAIR_ATTR_IDX_CACHE)) \|
		1053	(ARM_MALI_LPAE_MEMATTR_IMP_DEF
		1054	<< ARM_LPAE_MAIR_ATTR_SHIFT(ARM_LPAE_MAIR_ATTR_IDX_DEV));
1037		1055
1038	return iop;	1056	data->pgd = __arm_lpae_alloc_pages(data->pgd_size, GFP_KERNEL, cfg);
		1057	if (!data->pgd)
		1058	goto out_free_data;
		1059
		1060	/* Ensure the empty pgd is visible before TRANSTAB can be written */
		1061	wmb();
		1062
		1063	cfg->arm_mali_lpae_cfg.transtab = virt_to_phys(data->pgd) \|
		1064	ARM_MALI_LPAE_TTBR_READ_INNER \|
		1065	ARM_MALI_LPAE_TTBR_ADRMODE_TABLE;
		1066	return &data->iop;
		1067
		1068	out_free_data:
		1069	kfree(data);
		1070	return NULL;
1039	}	1071	}
1040		1072
1041	struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = {	1073	struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = {

drivers/iommu/ipmmu-vmsa.c+1−2

 	mmu->num_ctx = min(IPMMU_CTX_MAX, mmu->features->number_of_contexts);
-	irq = platform_get_irq(pdev, 0);
 	/*
 	 * Determine if this IPMMU instance is a root device by checking for
 	 * the lack of has_cache_leaf_nodes flag or renesas,ipmmu-main property.
 	/* Root devices have mandatory IRQs */
 	if (ipmmu_is_root(mmu)) {
+		irq = platform_get_irq(pdev, 0);
 		if (irq < 0) {
 			dev_err(&pdev->dev, "no IRQ found\n");
 			return irq;

drivers/iommu/rockchip-iommu.c+14−5

 	struct device *dev;
 	void __iomem **bases;
 	int num_mmu;
+	int num_irq;
 	struct clk_bulk_data *clocks;
 	int num_clocks;
 	bool reset_disabled;
 	struct rk_iommu *iommu;
 	struct resource *res;
 	int num_res = pdev->num_resources;
-	int err, i, irq;
+	int err, i;
 	iommu = devm_kzalloc(dev, sizeof(*iommu), GFP_KERNEL);
 	if (!iommu)
 	if (iommu->num_mmu == 0)
 		return PTR_ERR(iommu->bases[0]);
+	iommu->num_irq = platform_irq_count(pdev);
+	if (iommu->num_irq < 0)
+		return iommu->num_irq;
 	iommu->reset_disabled = device_property_read_bool(dev,
 					"rockchip,disable-mmu-reset");
 	pm_runtime_enable(dev);
-	i = 0;
+	for (i = 0; i < iommu->num_irq; i++) {
-	while ((irq = platform_get_irq(pdev, i++)) != -ENXIO) {
+		int irq = platform_get_irq(pdev, i);
 		if (irq < 0)
 			return irq;
 static void rk_iommu_shutdown(struct platform_device *pdev)
 {
 	struct rk_iommu *iommu = platform_get_drvdata(pdev);
-	int i = 0, irq;
+	int i;
+	for (i = 0; i < iommu->num_irq; i++) {
+		int irq = platform_get_irq(pdev, i);
-	while ((irq = platform_get_irq(pdev, i++)) != -ENXIO)
 		devm_free_irq(iommu->dev, irq, iommu);
+	}
 	pm_runtime_force_suspend(&pdev->dev);
 }

drivers/irqchip/irq-al-fic.c+12−0

 /* FIC Registers */
 #define AL_FIC_CAUSE		0x00
+#define AL_FIC_SET_CAUSE	0x08
 #define AL_FIC_MASK		0x10
 #define AL_FIC_CONTROL		0x28
 	chained_irq_exit(irqchip, desc);
 }
+static int al_fic_irq_retrigger(struct irq_data *data)
+{
+	struct irq_chip_generic *gc = irq_data_get_irq_chip_data(data);
+	struct al_fic *fic = gc->private;
+	writel_relaxed(BIT(data->hwirq), fic->base + AL_FIC_SET_CAUSE);
+	return 1;
+}
 static int al_fic_register(struct device_node *node,
 			   struct al_fic *fic)
 {
 	gc->chip_types->chip.irq_unmask = irq_gc_mask_clr_bit;
 	gc->chip_types->chip.irq_ack = irq_gc_ack_clr_bit;
 	gc->chip_types->chip.irq_set_type = al_fic_irq_set_type;
+	gc->chip_types->chip.irq_retrigger = al_fic_irq_retrigger;
 	gc->chip_types->chip.flags = IRQCHIP_SKIP_SET_WAKE;
 	gc->private = fic;

drivers/irqchip/irq-atmel-aic5.c+10−0

@@ -313,6 +313,7 @@ static void __init sama5d3_aic_irq_fixup(void) · 312 unmodified lines
313	static const struct of_device_id aic5_irq_fixups[] __initconst = {	313	static const struct of_device_id aic5_irq_fixups[] __initconst = {
314	{ .compatible = "atmel,sama5d3", .data = sama5d3_aic_irq_fixup },	314	{ .compatible = "atmel,sama5d3", .data = sama5d3_aic_irq_fixup },
315	{ .compatible = "atmel,sama5d4", .data = sama5d3_aic_irq_fixup },	315	{ .compatible = "atmel,sama5d4", .data = sama5d3_aic_irq_fixup },
		316	{ .compatible = "microchip,sam9x60", .data = sama5d3_aic_irq_fixup },
316	{ /* sentinel */ },	317	{ /* sentinel */ },
317	};	318	};
318		319
@@ -390,3 +391,12 @@ static int __init sama5d4_aic5_of_init(struct device_node *node, · 71 unmodified lines
390	return aic5_of_init(node, parent, NR_SAMA5D4_IRQS);	391	return aic5_of_init(node, parent, NR_SAMA5D4_IRQS);
391	}	392	}
392	IRQCHIP_DECLARE(sama5d4_aic5, "atmel,sama5d4-aic", sama5d4_aic5_of_init);	393	IRQCHIP_DECLARE(sama5d4_aic5, "atmel,sama5d4-aic", sama5d4_aic5_of_init);
		394
		395	#define NR_SAM9X60_IRQS 50
		396
		397	static int __init sam9x60_aic5_of_init(struct device_node *node,
		398	struct device_node *parent)
		399	{
		400	return aic5_of_init(node, parent, NR_SAM9X60_IRQS);
		401	}
		402	IRQCHIP_DECLARE(sam9x60_aic5, "microchip,sam9x60-aic", sam9x60_aic5_of_init);

drivers/irqchip/irq-gic-v3.c+1−1

@@ -59,7 +59,7 @@ static struct gic_chip_data gic_data __read_mostly; · 58 unmodified lines
59	static DEFINE_STATIC_KEY_TRUE(supports_deactivate_key);	59	static DEFINE_STATIC_KEY_TRUE(supports_deactivate_key);
60		60
61	#define GIC_ID_NR (1U << GICD_TYPER_ID_BITS(gic_data.rdists.gicd_typer))	61	#define GIC_ID_NR (1U << GICD_TYPER_ID_BITS(gic_data.rdists.gicd_typer))
62	#define GIC_LINE_NR max(GICD_TYPER_SPIS(gic_data.rdists.gicd_typer), 1020U)	62	#define GIC_LINE_NR min(GICD_TYPER_SPIS(gic_data.rdists.gicd_typer), 1020U)
63	#define GIC_ESPI_NR GICD_TYPER_ESPIS(gic_data.rdists.gicd_typer)	63	#define GIC_ESPI_NR GICD_TYPER_ESPIS(gic_data.rdists.gicd_typer)
64		64
65	/*	65	/*

drivers/irqchip/irq-sifive-plic.c+15−14

 	}
 }
-static void plic_irq_enable(struct irq_data *d)
+static void plic_irq_unmask(struct irq_data *d)
 {
 	unsigned int cpu = cpumask_any_and(irq_data_get_affinity_mask(d),
 					   cpu_online_mask);
 	plic_irq_toggle(cpumask_of(cpu), d->hwirq, 1);
 }
-static void plic_irq_disable(struct irq_data *d)
+static void plic_irq_mask(struct irq_data *d)
 {
 	plic_irq_toggle(cpu_possible_mask, d->hwirq, 0);
 }
 	if (cpu >= nr_cpu_ids)
 		return -EINVAL;
-	if (!irqd_irq_disabled(d)) {
+	plic_irq_toggle(cpu_possible_mask, d->hwirq, 0);
-		plic_irq_toggle(cpu_possible_mask, d->hwirq, 0);
+	plic_irq_toggle(cpumask_of(cpu), d->hwirq, 1);
-		plic_irq_toggle(cpumask_of(cpu), d->hwirq, 1);
-	}
 	irq_data_update_effective_affinity(d, cpumask_of(cpu));
 }
 #endif
+static void plic_irq_eoi(struct irq_data *d)
+{
+	struct plic_handler *handler = this_cpu_ptr(&plic_handlers);
+	writel(d->hwirq, handler->hart_base + CONTEXT_CLAIM);
+}
 static struct irq_chip plic_chip = {
 	.name		= "SiFive PLIC",
-	/*
+	.irq_mask	= plic_irq_mask,
-	 * There is no need to mask/unmask PLIC interrupts.  They are "masked"
+	.irq_unmask	= plic_irq_unmask,
-	 * by reading claim and "unmasked" when writing it back.
+	.irq_eoi	= plic_irq_eoi,
-	 */
-	.irq_enable	= plic_irq_enable,
-	.irq_disable	= plic_irq_disable,
 #ifdef CONFIG_SMP
 	.irq_set_affinity = plic_set_affinity,
 #endif
 static int plic_irqdomain_map(struct irq_domain *d, unsigned int irq,
 			      irq_hw_number_t hwirq)
 {
-	irq_set_chip_and_handler(irq, &plic_chip, handle_simple_irq);
+	irq_set_chip_and_handler(irq, &plic_chip, handle_fasteoi_irq);
 	irq_set_chip_data(irq, NULL);
 	irq_set_noprobe(irq);
 	return 0;
 					hwirq);
 		else
 			generic_handle_irq(irq);
-		writel(hwirq, claim);
 	}
 	csr_set(sie, SIE_SEIE);
 }

drivers/md/dm-cache-target.c+2−26

 static struct dm_bio_prison_cell_v2 *alloc_prison_cell(struct cache *cache)
 {
-	return dm_bio_prison_alloc_cell_v2(cache->prison, GFP_NOWAIT);
+	return dm_bio_prison_alloc_cell_v2(cache->prison, GFP_NOIO);
 }
 static void free_prison_cell(struct cache *cache, struct dm_bio_prison_cell_v2 *cell)
 {
 	struct dm_cache_migration *mg;
-	mg = mempool_alloc(&cache->migration_pool, GFP_NOWAIT);
+	mg = mempool_alloc(&cache->migration_pool, GFP_NOIO);
-	if (!mg)
-		return NULL;
 	memset(mg, 0, sizeof(*mg));
 	struct dm_bio_prison_cell_v2 *cell_prealloc, *cell;
 	cell_prealloc = alloc_prison_cell(cache); /* FIXME: allow wait if calling from worker */
-	if (!cell_prealloc) {
-		defer_bio(cache, bio);
-		return false;
-	}
 	build_key(oblock, end, &key);
 	r = dm_cell_get_v2(cache->prison, &key, lock_level(bio), bio, cell_prealloc, &cell);
 	struct dm_bio_prison_cell_v2 *prealloc;
 	prealloc = alloc_prison_cell(cache);
-	if (!prealloc) {
-		DMERR_LIMIT("%s: alloc_prison_cell failed", cache_device_name(cache));
-		mg_complete(mg, false);
-		return -ENOMEM;
-	}
 	/*
 	 * Prevent writes to the block, but allow reads to continue.
 	}
 	mg = alloc_migration(cache);
-	if (!mg) {
-		policy_complete_background_work(cache->policy, op, false);
-		background_work_end(cache);
-		return -ENOMEM;
-	}
 	mg->op = op;
 	mg->overwrite_bio = bio;
 	struct dm_bio_prison_cell_v2 *prealloc;
 	prealloc = alloc_prison_cell(cache);
-	if (!prealloc) {
-		invalidate_complete(mg, false);
-		return -ENOMEM;
-	}
 	build_key(mg->invalidate_oblock, oblock_succ(mg->invalidate_oblock), &key);
 	r = dm_cell_lock_v2(cache->prison, &key,
 		return -EPERM;
 	mg = alloc_migration(cache);
-	if (!mg) {
-		background_work_end(cache);
-		return -ENOMEM;
-	}
 	mg->overwrite_bio = bio;
 	mg->invalidate_cblock = cblock;

drivers/md/dm-clone-target.c+2−2

@@ -591,8 +591,8 @@ static struct hash_table_bucket get_hash_table_bucket(struct clone clone, · 590 unmodified lines
591	*	591	*
592	* NOTE: Must be called with the bucket lock held	592	* NOTE: Must be called with the bucket lock held
593	*/	593	*/
594	struct dm_clone_region_hydration __hash_find(struct hash_table_bucket bucket,	594	static struct dm_clone_region_hydration __hash_find(struct hash_table_bucket bucket,
595	unsigned long region_nr)	595	unsigned long region_nr)
596	{	596	{
597	struct dm_clone_region_hydration *hd;	597	struct dm_clone_region_hydration *hd;
598		598

drivers/md/dm-snap.c+77−17

 #include <linux/vmalloc.h>
 #include <linux/log2.h>
 #include <linux/dm-kcopyd.h>
-#include <linux/semaphore.h>
 #include "dm.h"
 	/* The on disk metadata handler */
 	struct dm_exception_store *store;
-	/* Maximum number of in-flight COW jobs. */
+	unsigned in_progress;
-	struct semaphore cow_count;
+	struct wait_queue_head in_progress_wait;
 	struct dm_kcopyd_client *kcopyd_client;
  */
 #define DEFAULT_COW_THRESHOLD 2048
-static int cow_threshold = DEFAULT_COW_THRESHOLD;
+static unsigned cow_threshold = DEFAULT_COW_THRESHOLD;
-module_param_named(snapshot_cow_threshold, cow_threshold, int, 0644);
+module_param_named(snapshot_cow_threshold, cow_threshold, uint, 0644);
 MODULE_PARM_DESC(snapshot_cow_threshold, "Maximum number of chunks being copied on write");
 DECLARE_DM_KCOPYD_THROTTLE_WITH_MODULE_PARM(snapshot_copy_throttle,
 		goto bad_hash_tables;
 	}
-	sema_init(&s->cow_count, (cow_threshold > 0) ? cow_threshold : INT_MAX);
+	init_waitqueue_head(&s->in_progress_wait);
 	s->kcopyd_client = dm_kcopyd_client_create(&dm_kcopyd_throttle);
 	if (IS_ERR(s->kcopyd_client)) {
 	dm_put_device(ti, s->origin);
+	WARN_ON(s->in_progress);
 	kfree(s);
 }
+static void account_start_copy(struct dm_snapshot *s)
+{
+	spin_lock(&s->in_progress_wait.lock);
+	s->in_progress++;
+	spin_unlock(&s->in_progress_wait.lock);
+}
+static void account_end_copy(struct dm_snapshot *s)
+{
+	spin_lock(&s->in_progress_wait.lock);
+	BUG_ON(!s->in_progress);
+	s->in_progress--;
+	if (likely(s->in_progress <= cow_threshold) &&
+	    unlikely(waitqueue_active(&s->in_progress_wait)))
+		wake_up_locked(&s->in_progress_wait);
+	spin_unlock(&s->in_progress_wait.lock);
+}
+static bool wait_for_in_progress(struct dm_snapshot *s, bool unlock_origins)
+{
+	if (unlikely(s->in_progress > cow_threshold)) {
+		spin_lock(&s->in_progress_wait.lock);
+		if (likely(s->in_progress > cow_threshold)) {
+			/*
+			 * NOTE: this throttle doesn't account for whether
+			 * the caller is servicing an IO that will trigger a COW
+			 * so excess throttling may result for chunks not required
+			 * to be COW'd.  But if cow_threshold was reached, extra
+			 * throttling is unlikely to negatively impact performance.
+			 */
+			DECLARE_WAITQUEUE(wait, current);
+			__add_wait_queue(&s->in_progress_wait, &wait);
+			__set_current_state(TASK_UNINTERRUPTIBLE);
+			spin_unlock(&s->in_progress_wait.lock);
+			if (unlock_origins)
+				up_read(&_origins_lock);
+			io_schedule();
+			remove_wait_queue(&s->in_progress_wait, &wait);
+			return false;
+		}
+		spin_unlock(&s->in_progress_wait.lock);
+	}
+	return true;
+}
 /*
  * Flush a list of buffers.
  */
 	}
 }
-static int do_origin(struct dm_dev *origin, struct bio *bio);
+static int do_origin(struct dm_dev *origin, struct bio *bio, bool limit);
 /*
  * Flush a list of buffers.
 	while (bio) {
 		n = bio->bi_next;
 		bio->bi_next = NULL;
-		r = do_origin(s->origin, bio);
+		r = do_origin(s->origin, bio, false);
 		if (r == DM_MAPIO_REMAPPED)
 			generic_make_request(bio);
 		bio = n;
 		rb_link_node(&pe->out_of_order_node, parent, p);
 		rb_insert_color(&pe->out_of_order_node, &s->out_of_order_tree);
 	}
-	up(&s->cow_count);
+	account_end_copy(s);
 }
 /*
 	dest.count = src.count;
 	/* Hand over to kcopyd */
-	down(&s->cow_count);
+	account_start_copy(s);
 	dm_kcopyd_copy(s->kcopyd_client, &src, 1, &dest, 0, copy_callback, pe);
 }
 	pe->full_bio = bio;
 	pe->full_bio_end_io = bio->bi_end_io;
-	down(&s->cow_count);
+	account_start_copy(s);
 	callback_data = dm_kcopyd_prepare_callback(s->kcopyd_client,
 						   copy_callback, pe);
 	struct bio *bio = context;
 	struct dm_snapshot *s = bio->bi_private;
-	up(&s->cow_count);
+	account_end_copy(s);
 	bio->bi_status = write_err ? BLK_STS_IOERR : 0;
 	bio_endio(bio);
 }
 	dest.sector = bio->bi_iter.bi_sector;
 	dest.count = s->store->chunk_size;
-	down(&s->cow_count);
+	account_start_copy(s);
 	WARN_ON_ONCE(bio->bi_private);
 	bio->bi_private = s;
 	dm_kcopyd_zero(s->kcopyd_client, 1, &dest, 0, zero_callback, bio);
 	if (!s->valid)
 		return DM_MAPIO_KILL;
+	if (bio_data_dir(bio) == WRITE) {
+		while (unlikely(!wait_for_in_progress(s, false)))
+			; /* wait_for_in_progress() has slept */
+	}
 	down_read(&s->lock);
 	dm_exception_table_lock(&lock);
 	if (bio_data_dir(bio) == WRITE) {
 		up_write(&s->lock);
-		return do_origin(s->origin, bio);
+		return do_origin(s->origin, bio, false);
 	}
 out_unlock:
 /*
  * Called on a write from the origin driver.
  */
-static int do_origin(struct dm_dev *origin, struct bio *bio)
+static int do_origin(struct dm_dev *origin, struct bio *bio, bool limit)
 {
 	struct origin *o;
 	int r = DM_MAPIO_REMAPPED;
+again:
 	down_read(&_origins_lock);
 	o = __lookup_origin(origin->bdev);
-	if (o)
+	if (o) {
+		if (limit) {
+			struct dm_snapshot *s;
+			list_for_each_entry(s, &o->snapshots, list)
+				if (unlikely(!wait_for_in_progress(s, true)))
+					goto again;
+		}
 		r = __origin_write(&o->snapshots, bio->bi_iter.bi_sector, bio);
+	}
 	up_read(&_origins_lock);
 	return r;
 		dm_accept_partial_bio(bio, available_sectors);
 	/* Only tell snapshots if this is a write */
-	return do_origin(o->dev, bio);
+	return do_origin(o->dev, bio, true);
 }
 /*

drivers/md/raid0.c+1−1

@@ -154,7 +154,7 @@ static int create_strip_zones(struct mddev mddev, struct r0conf *private_conf) · 153 unmodified lines
154	} else {	154	} else {
155	pr_err("md/raid0:%s: cannot assemble multi-zone RAID0 with default_layout setting\n",	155	pr_err("md/raid0:%s: cannot assemble multi-zone RAID0 with default_layout setting\n",
156	mdname(mddev));	156	mdname(mddev));
157	pr_err("md/raid0: please set raid.default_layout to 1 or 2\n");	157	pr_err("md/raid0: please set raid0.default_layout to 1 or 2\n");
158	err = -ENOTSUPP;	158	err = -ENOTSUPP;
159	goto abort;	159	goto abort;
160	}	160	}

drivers/media/usb/stkwebcam/stk-webcam.c+1−2

@@ -643,8 +643,7 @@ static int v4l_stk_release(struct file *fp) · 642 unmodified lines
643	dev->owner = NULL;	643	dev->owner = NULL;
644	}	644	}
645		645
646	if (is_present(dev))	646	usb_autopm_put_interface(dev->interface);
647	usb_autopm_put_interface(dev->interface);
648	mutex_unlock(&dev->lock);	647	mutex_unlock(&dev->lock);
649	return v4l2_fh_release(fp);	648	return v4l2_fh_release(fp);
650	}	649	}

drivers/memstick/host/jmb38x_ms.c+1−1

@@ -941,7 +941,7 @@ static int jmb38x_ms_probe(struct pci_dev *pdev, · 940 unmodified lines
941	if (!cnt) {	941	if (!cnt) {
942	rc = -ENODEV;	942	rc = -ENODEV;
943	pci_dev_busy = 1;	943	pci_dev_busy = 1;
944	goto err_out;	944	goto err_out_int;
945	}	945	}
946		946
947	jm = kzalloc(sizeof(struct jmb38x_ms)	947	jm = kzalloc(sizeof(struct jmb38x_ms)

drivers/misc/fastrpc.c+1−0

@@ -527,6 +527,7 @@ static int fastrpc_dma_buf_attach(struct dma_buf *dmabuf, · 526 unmodified lines
527	FASTRPC_PHYS(buffer->phys), buffer->size);	527	FASTRPC_PHYS(buffer->phys), buffer->size);
528	if (ret < 0) {	528	if (ret < 0) {
529	dev_err(buffer->dev, "failed to get scatterlist from DMA API\n");	529	dev_err(buffer->dev, "failed to get scatterlist from DMA API\n");
		530	kfree(a);
530	return -EINVAL;	531	return -EINVAL;
531	}	532	}
532		533

drivers/misc/mei/bus-fixup.c+11−3

 {
 	int ret;
+	/* No need to enable the client if nothing is needed from it */
+	if (!cldev->bus->fw_f_fw_ver_supported &&
+	    !cldev->bus->hbm_f_os_supported)
+		return;
 	ret = mei_cldev_enable(cldev);
 	if (ret)
 		return;
-	ret = mei_fwver(cldev);
+	if (cldev->bus->fw_f_fw_ver_supported) {
-	if (ret < 0)
+		ret = mei_fwver(cldev);
-		dev_err(&cldev->dev, "FW version command failed %d\n", ret);
+		if (ret < 0)
+			dev_err(&cldev->dev, "FW version command failed %d\n",
+				ret);
+	}
 	if (cldev->bus->hbm_f_os_supported) {
 		ret = mei_osver(cldev);

drivers/misc/mei/hw-me-regs.h+3−0

@@ -79,6 +79,9 @@ · 78 unmodified lines
79	#define MEI_DEV_ID_CNP_H 0xA360 /* Cannon Point H */	79	#define MEI_DEV_ID_CNP_H 0xA360 /* Cannon Point H */
80	#define MEI_DEV_ID_CNP_H_4 0xA364 /* Cannon Point H 4 (iTouch) */	80	#define MEI_DEV_ID_CNP_H_4 0xA364 /* Cannon Point H 4 (iTouch) */
81		81
		82	#define MEI_DEV_ID_CMP_LP 0x02e0 /* Comet Point LP */
		83	#define MEI_DEV_ID_CMP_LP_3 0x02e4 /* Comet Point LP 3 (iTouch) */
		84
82	#define MEI_DEV_ID_ICP_LP 0x34E0 /* Ice Lake Point LP */	85	#define MEI_DEV_ID_ICP_LP 0x34E0 /* Ice Lake Point LP */
83		86
84	#define MEI_DEV_ID_TGP_LP 0xA0E0 /* Tiger Lake Point LP */	87	#define MEI_DEV_ID_TGP_LP 0xA0E0 /* Tiger Lake Point LP */

drivers/misc/mei/hw-me.c+18−3

 #define MEI_CFG_FW_SPS                           \
 	.quirk_probe = mei_me_fw_type_sps
+#define MEI_CFG_FW_VER_SUPP                     \
+	.fw_ver_supported = 1
 #define MEI_CFG_ICH_HFS                      \
 	.fw_status.count = 0
 	MEI_CFG_ICH10_HFS,
 };
-/* PCH devices */
+/* PCH6 devices */
-static const struct mei_cfg mei_me_pch_cfg = {
+static const struct mei_cfg mei_me_pch6_cfg = {
 	MEI_CFG_PCH_HFS,
 };
+/* PCH7 devices */
+static const struct mei_cfg mei_me_pch7_cfg = {
+	MEI_CFG_PCH_HFS,
+	MEI_CFG_FW_VER_SUPP,
+};
 /* PCH Cougar Point and Patsburg with quirk for Node Manager exclusion */
 static const struct mei_cfg mei_me_pch_cpt_pbg_cfg = {
 	MEI_CFG_PCH_HFS,
+	MEI_CFG_FW_VER_SUPP,
 	MEI_CFG_FW_NM,
 };
 /* PCH8 Lynx Point and newer devices */
 static const struct mei_cfg mei_me_pch8_cfg = {
 	MEI_CFG_PCH8_HFS,
+	MEI_CFG_FW_VER_SUPP,
 };
 /* PCH8 Lynx Point with quirk for SPS Firmware exclusion */
 static const struct mei_cfg mei_me_pch8_sps_cfg = {
 	MEI_CFG_PCH8_HFS,
+	MEI_CFG_FW_VER_SUPP,
 	MEI_CFG_FW_SPS,
 };
 /* Cannon Lake and newer devices */
 static const struct mei_cfg mei_me_pch12_cfg = {
 	MEI_CFG_PCH8_HFS,
+	MEI_CFG_FW_VER_SUPP,
 	MEI_CFG_DMA_128,
 };
 	[MEI_ME_UNDEF_CFG] = NULL,
 	[MEI_ME_ICH_CFG] = &mei_me_ich_cfg,
 	[MEI_ME_ICH10_CFG] = &mei_me_ich10_cfg,
-	[MEI_ME_PCH_CFG] = &mei_me_pch_cfg,
+	[MEI_ME_PCH6_CFG] = &mei_me_pch6_cfg,
+	[MEI_ME_PCH7_CFG] = &mei_me_pch7_cfg,
 	[MEI_ME_PCH_CPT_PBG_CFG] = &mei_me_pch_cpt_pbg_cfg,
 	[MEI_ME_PCH8_CFG] = &mei_me_pch8_cfg,
 	[MEI_ME_PCH8_SPS_CFG] = &mei_me_pch8_sps_cfg,
 	mei_device_init(dev, &pdev->dev, &mei_me_hw_ops);
 	hw->cfg = cfg;
+	dev->fw_f_fw_ver_supported = cfg->fw_ver_supported;
 	return dev;
 }

drivers/misc/mei/hw-me.h+6−2

  * @fw_status: FW status
  * @quirk_probe: device exclusion quirk
  * @dma_size: device DMA buffers size
+ * @fw_ver_supported: is fw version retrievable from FW
  */
 struct mei_cfg {
 	const struct mei_fw_status fw_status;
 	bool (*quirk_probe)(struct pci_dev *pdev);
 	size_t dma_size[DMA_DSCR_NUM];
+	u32 fw_ver_supported:1;
 };
  * @MEI_ME_UNDEF_CFG:      Lower sentinel.
  * @MEI_ME_ICH_CFG:        I/O Controller Hub legacy devices.
  * @MEI_ME_ICH10_CFG:      I/O Controller Hub platforms Gen10
- * @MEI_ME_PCH_CFG:        Platform Controller Hub platforms (Up to Gen8).
+ * @MEI_ME_PCH6_CFG:       Platform Controller Hub platforms (Gen6).
+ * @MEI_ME_PCH7_CFG:       Platform Controller Hub platforms (Gen7).
  * @MEI_ME_PCH_CPT_PBG_CFG:Platform Controller Hub workstations
  *                         with quirk for Node Manager exclusion.
  * @MEI_ME_PCH8_CFG:       Platform Controller Hub Gen8 and newer
 	MEI_ME_UNDEF_CFG,
 	MEI_ME_ICH_CFG,
 	MEI_ME_ICH10_CFG,
-	MEI_ME_PCH_CFG,
+	MEI_ME_PCH6_CFG,
+	MEI_ME_PCH7_CFG,
 	MEI_ME_PCH_CPT_PBG_CFG,
 	MEI_ME_PCH8_CFG,
 	MEI_ME_PCH8_SPS_CFG,

drivers/misc/mei/mei_dev.h+4−0

  *
  * @fw_ver : FW versions
  *
+ * @fw_f_fw_ver_supported : fw feature: fw version supported
+ *
  * @me_clients_rwsem: rw lock over me_clients list
  * @me_clients  : list of FW clients
  * @me_clients_map : FW clients bit map
 	struct mei_fw_version fw_ver[MEI_MAX_FW_VER_BLOCKS];
+	unsigned int fw_f_fw_ver_supported:1;
 	struct rw_semaphore me_clients_rwsem;
 	struct list_head me_clients;
 	DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX);

drivers/misc/mei/pci-me.c+8−5

 	{MEI_PCI_DEVICE(MEI_DEV_ID_ICH10_3, MEI_ME_ICH10_CFG)},
 	{MEI_PCI_DEVICE(MEI_DEV_ID_ICH10_4, MEI_ME_ICH10_CFG)},
-	{MEI_PCI_DEVICE(MEI_DEV_ID_IBXPK_1, MEI_ME_PCH_CFG)},
+	{MEI_PCI_DEVICE(MEI_DEV_ID_IBXPK_1, MEI_ME_PCH6_CFG)},
-	{MEI_PCI_DEVICE(MEI_DEV_ID_IBXPK_2, MEI_ME_PCH_CFG)},
+	{MEI_PCI_DEVICE(MEI_DEV_ID_IBXPK_2, MEI_ME_PCH6_CFG)},
 	{MEI_PCI_DEVICE(MEI_DEV_ID_CPT_1, MEI_ME_PCH_CPT_PBG_CFG)},
 	{MEI_PCI_DEVICE(MEI_DEV_ID_PBG_1, MEI_ME_PCH_CPT_PBG_CFG)},
-	{MEI_PCI_DEVICE(MEI_DEV_ID_PPT_1, MEI_ME_PCH_CFG)},
+	{MEI_PCI_DEVICE(MEI_DEV_ID_PPT_1, MEI_ME_PCH7_CFG)},
-	{MEI_PCI_DEVICE(MEI_DEV_ID_PPT_2, MEI_ME_PCH_CFG)},
+	{MEI_PCI_DEVICE(MEI_DEV_ID_PPT_2, MEI_ME_PCH7_CFG)},
-	{MEI_PCI_DEVICE(MEI_DEV_ID_PPT_3, MEI_ME_PCH_CFG)},
+	{MEI_PCI_DEVICE(MEI_DEV_ID_PPT_3, MEI_ME_PCH7_CFG)},
 	{MEI_PCI_DEVICE(MEI_DEV_ID_LPT_H, MEI_ME_PCH8_SPS_CFG)},
 	{MEI_PCI_DEVICE(MEI_DEV_ID_LPT_W, MEI_ME_PCH8_SPS_CFG)},
 	{MEI_PCI_DEVICE(MEI_DEV_ID_LPT_LP, MEI_ME_PCH8_CFG)},
 	{MEI_PCI_DEVICE(MEI_DEV_ID_CNP_H, MEI_ME_PCH12_CFG)},
 	{MEI_PCI_DEVICE(MEI_DEV_ID_CNP_H_4, MEI_ME_PCH8_CFG)},
+	{MEI_PCI_DEVICE(MEI_DEV_ID_CMP_LP, MEI_ME_PCH12_CFG)},
+	{MEI_PCI_DEVICE(MEI_DEV_ID_CMP_LP_3, MEI_ME_PCH8_CFG)},
 	{MEI_PCI_DEVICE(MEI_DEV_ID_ICP_LP, MEI_ME_PCH12_CFG)},
 	{MEI_PCI_DEVICE(MEI_DEV_ID_TGP_LP, MEI_ME_PCH12_CFG)},

drivers/mmc/host/renesas_sdhi_core.c+19−12

 	struct tmio_mmc_dma *dma_priv;
 	struct tmio_mmc_host *host;
 	struct renesas_sdhi *priv;
+	int num_irqs, irq, ret, i;
 	struct resource *res;
-	int irq, ret, i;
 	u16 ver;
 	of_data = of_device_get_match_data(&pdev->dev);
 		host->hs400_complete = renesas_sdhi_hs400_complete;
 	}
-	i = 0;
+	num_irqs = platform_irq_count(pdev);
-	while (1) {
+	if (num_irqs < 0) {
+		ret = num_irqs;
+		goto eirq;
+	}
+	/* There must be at least one IRQ source */
+	if (!num_irqs) {
+		ret = -ENXIO;
+		goto eirq;
+	}
+	for (i = 0; i < num_irqs; i++) {
 		irq = platform_get_irq(pdev, i);
-		if (irq < 0)
+		if (irq < 0) {
-			break;
+			ret = irq;
-		i++;
+			goto eirq;
+		}
 		ret = devm_request_irq(&pdev->dev, irq, tmio_mmc_irq, 0,
 				       dev_name(&pdev->dev), host);
 		if (ret)
 			goto eirq;
 	}
-	/* There must be at least one IRQ source */
-	if (!i) {
-		ret = irq;
-		goto eirq;
-	}
 	dev_info(&pdev->dev, "%s base at 0x%08lx max clock rate %u MHz\n",
 		 mmc_hostname(host->mmc), (unsigned long)
 		 (platform_get_resource(pdev, IORESOURCE_MEM, 0)->start),

drivers/mmc/host/sdhci-iproc.c+1−0

@@ -262,6 +262,7 @@ static const struct sdhci_iproc_data bcm2835_data = { · 261 unmodified lines
262	};	262	};
263		263
264	static const struct sdhci_pltfm_data sdhci_bcm2711_pltfm_data = {	264	static const struct sdhci_pltfm_data sdhci_bcm2711_pltfm_data = {
		265	.quirks = SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12,
265	.ops = &sdhci_iproc_32only_ops,	266	.ops = &sdhci_iproc_32only_ops,
266	};	267	};
267		268

drivers/mmc/host/sh_mmcif.c+2−4

 	const char *name;
 	irq[0] = platform_get_irq(pdev, 0);
-	irq[1] = platform_get_irq(pdev, 1);
+	irq[1] = platform_get_irq_optional(pdev, 1);
-	if (irq[0] < 0) {
+	if (irq[0] < 0)
-		dev_err(dev, "Get irq error\n");
 		return -ENXIO;
-	}
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	reg = devm_ioremap_resource(dev, res);

drivers/mtd/nand/raw/au1550nd.c+2−3

 /**
  * au_read_buf16 -  read chip data into buffer
- * @mtd:	MTD device structure
+ * @this:	NAND chip object
  * @buf:	buffer to store date
  * @len:	number of bytes to read
  *
  * read function for 16bit buswidth
  */
-static void au_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
+static void au_read_buf16(struct nand_chip *this, u_char *buf, int len)
 {
 	int i;
-	struct nand_chip *this = mtd_to_nand(mtd);
 	u16 *p = (u16 *) buf;
 	len >>= 1;

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

@@ -487,7 +487,7 @@ static int write_sr(struct spi_nor *nor, u8 val) · 486 unmodified lines
487	SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_WRSR, 1),	487	SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_WRSR, 1),
488	SPI_MEM_OP_NO_ADDR,	488	SPI_MEM_OP_NO_ADDR,
489	SPI_MEM_OP_NO_DUMMY,	489	SPI_MEM_OP_NO_DUMMY,
490	SPI_MEM_OP_DATA_IN(1, nor->bouncebuf, 1));	490	SPI_MEM_OP_DATA_OUT(1, nor->bouncebuf, 1));
491		491
492	return spi_mem_exec_op(nor->spimem, &op);	492	return spi_mem_exec_op(nor->spimem, &op);
493	}	493	}

drivers/net/bonding/bond_main.c+1−1

@@ -4039,7 +4039,7 @@ out: · 4038 unmodified lines
4039	* this to-be-skipped slave to send a packet out.	4039	* this to-be-skipped slave to send a packet out.
4040	*/	4040	*/
4041	old_arr = rtnl_dereference(bond->slave_arr);	4041	old_arr = rtnl_dereference(bond->slave_arr);
4042	for (idx = 0; idx < old_arr->count; idx++) {	4042	for (idx = 0; old_arr != NULL && idx < old_arr->count; idx++) {
4043	if (skipslave == old_arr->arr[idx]) {	4043	if (skipslave == old_arr->arr[idx]) {
4044	old_arr->arr[idx] =	4044	old_arr->arr[idx] =
4045	old_arr->arr[old_arr->count-1];	4045	old_arr->arr[old_arr->count-1];

drivers/net/dsa/b53/b53_common.c+0−1

@@ -1845,7 +1845,6 @@ int b53_mirror_add(struct dsa_switch *ds, int port, · 1844 unmodified lines
1845	loc = B53_EG_MIR_CTL;	1845	loc = B53_EG_MIR_CTL;
1846		1846
1847	b53_read16(dev, B53_MGMT_PAGE, loc, &reg);	1847	b53_read16(dev, B53_MGMT_PAGE, loc, &reg);
1848	reg &= ~MIRROR_MASK;
1849	reg \|= BIT(port);	1848	reg \|= BIT(port);
1850	b53_write16(dev, B53_MGMT_PAGE, loc, reg);	1849	b53_write16(dev, B53_MGMT_PAGE, loc, reg);
1851		1850

drivers/net/dsa/microchip/ksz8795.c+0−4

@@ -1224,10 +1224,6 @@ static int ksz8795_switch_init(struct ksz_device *dev) · 1223 unmodified lines
1224	{	1224	{
1225	int i;	1225	int i;
1226		1226
1227	mutex_init(&dev->stats_mutex);
1228	mutex_init(&dev->alu_mutex);
1229	mutex_init(&dev->vlan_mutex);
1230
1231	dev->ds->ops = &ksz8795_switch_ops;	1227	dev->ds->ops = &ksz8795_switch_ops;
1232		1228
1233	for (i = 0; i < ARRAY_SIZE(ksz8795_switch_chips); i++) {	1229	for (i = 0; i < ARRAY_SIZE(ksz8795_switch_chips); i++) {

drivers/net/dsa/microchip/ksz8795_spi.c+4−3

 static int ksz8795_spi_probe(struct spi_device *spi)
 {
+	struct regmap_config rc;
 	struct ksz_device *dev;
 	int i, ret;
 		return -ENOMEM;
 	for (i = 0; i < ARRAY_SIZE(ksz8795_regmap_config); i++) {
-		dev->regmap[i] = devm_regmap_init_spi(spi,
+		rc = ksz8795_regmap_config[i];
-						      &ksz8795_regmap_config
+		rc.lock_arg = &dev->regmap_mutex;
-						      [i]);
+		dev->regmap[i] = devm_regmap_init_spi(spi, &rc);
 		if (IS_ERR(dev->regmap[i])) {
 			ret = PTR_ERR(dev->regmap[i]);
 			dev_err(&spi->dev,

drivers/net/dsa/microchip/ksz9477_i2c.c+4−2

 static int ksz9477_i2c_probe(struct i2c_client *i2c,
 			     const struct i2c_device_id *i2c_id)
 {
+	struct regmap_config rc;
 	struct ksz_device *dev;
 	int i, ret;
 		return -ENOMEM;
 	for (i = 0; i < ARRAY_SIZE(ksz9477_regmap_config); i++) {
-		dev->regmap[i] = devm_regmap_init_i2c(i2c,
+		rc = ksz9477_regmap_config[i];
-					&ksz9477_regmap_config[i]);
+		rc.lock_arg = &dev->regmap_mutex;
+		dev->regmap[i] = devm_regmap_init_i2c(i2c, &rc);
 		if (IS_ERR(dev->regmap[i])) {
 			ret = PTR_ERR(dev->regmap[i]);
 			dev_err(&i2c->dev,

drivers/net/dsa/microchip/ksz9477_reg.h+2−2

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	*	2	/*
3	* Microchip KSZ9477 register definitions	3	* Microchip KSZ9477 register definitions
4	*	4	*
5	* Copyright (C) 2017-2018 Microchip Technology Inc.	5	* Copyright (C) 2017-2018 Microchip Technology Inc.

drivers/net/dsa/microchip/ksz9477_spi.c+4−2

 static int ksz9477_spi_probe(struct spi_device *spi)
 {
+	struct regmap_config rc;
 	struct ksz_device *dev;
 	int i, ret;
 		return -ENOMEM;
 	for (i = 0; i < ARRAY_SIZE(ksz9477_regmap_config); i++) {
-		dev->regmap[i] = devm_regmap_init_spi(spi,
+		rc = ksz9477_regmap_config[i];
-					&ksz9477_regmap_config[i]);
+		rc.lock_arg = &dev->regmap_mutex;
+		dev->regmap[i] = devm_regmap_init_spi(spi, &rc);
 		if (IS_ERR(dev->regmap[i])) {
 			ret = PTR_ERR(dev->regmap[i]);
 			dev_err(&spi->dev,

drivers/net/dsa/microchip/ksz_common.c+1−1

@@ -436,7 +436,7 @@ int ksz_switch_register(struct ksz_device *dev, · 435 unmodified lines
436	}	436	}
437		437
438	mutex_init(&dev->dev_mutex);	438	mutex_init(&dev->dev_mutex);
439	mutex_init(&dev->stats_mutex);	439	mutex_init(&dev->regmap_mutex);
440	mutex_init(&dev->alu_mutex);	440	mutex_init(&dev->alu_mutex);
441	mutex_init(&dev->vlan_mutex);	441	mutex_init(&dev->vlan_mutex);
442		442

drivers/net/dsa/microchip/ksz_common.h+17−3

-/* SPDX-License-Identifier: GPL-2.0
+/* SPDX-License-Identifier: GPL-2.0 */
- * Microchip switch driver common header
+/* Microchip switch driver common header
  *
  * Copyright (C) 2017-2019 Microchip Technology Inc.
  */
 	const char *name;
 	struct mutex dev_mutex;		/* device access */
-	struct mutex stats_mutex;	/* status access */
+	struct mutex regmap_mutex;	/* regmap access */
 	struct mutex alu_mutex;		/* ALU access */
 	struct mutex vlan_mutex;	/* vlan access */
 	const struct ksz_dev_ops *dev_ops;
 	ksz_write32(dev, dev->dev_ops->get_port_addr(port, offset), data);
 }
+static inline void ksz_regmap_lock(void *__mtx)
+{
+	struct mutex *mtx = __mtx;
+	mutex_lock(mtx);
+}
+static inline void ksz_regmap_unlock(void *__mtx)
+{
+	struct mutex *mtx = __mtx;
+	mutex_unlock(mtx);
+}
 /* Regmap tables generation */
 #define KSZ_SPI_OP_RD		3
 #define KSZ_SPI_OP_WR		2
 		.write_flag_mask =					\
 			KSZ_SPI_OP_FLAG_MASK(KSZ_SPI_OP_WR, swp,	\
 					     regbits, regpad),		\
+		.lock = ksz_regmap_lock,				\
+		.unlock = ksz_regmap_unlock,				\
 		.reg_format_endian = REGMAP_ENDIAN_BIG,			\
 		.val_format_endian = REGMAP_ENDIAN_BIG			\
 	}

drivers/net/dsa/sja1105/sja1105.h+2−2

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	* Copyright (c) 2018, Sensor-Technik Wiedemann GmbH	2	/* Copyright (c) 2018, Sensor-Technik Wiedemann GmbH
3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>	3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
4	*/	4	*/
5	#ifndef _SJA1105_H	5	#ifndef _SJA1105_H

drivers/net/dsa/sja1105/sja1105_dynamic_config.h+2−2

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	* Copyright (c) 2019, Vladimir Oltean <olteanv@gmail.com>	2	/* Copyright (c) 2019, Vladimir Oltean <olteanv@gmail.com>
3	*/	3	*/
4	#ifndef _SJA1105_DYNAMIC_CONFIG_H	4	#ifndef _SJA1105_DYNAMIC_CONFIG_H
5	#define _SJA1105_DYNAMIC_CONFIG_H	5	#define _SJA1105_DYNAMIC_CONFIG_H

drivers/net/dsa/sja1105/sja1105_ptp.h+2−2

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	* Copyright (c) 2019, Vladimir Oltean <olteanv@gmail.com>	2	/* Copyright (c) 2019, Vladimir Oltean <olteanv@gmail.com>
3	*/	3	*/
4	#ifndef _SJA1105_PTP_H	4	#ifndef _SJA1105_PTP_H
5	#define _SJA1105_PTP_H	5	#define _SJA1105_PTP_H

drivers/net/dsa/sja1105/sja1105_static_config.h+2−2

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: BSD-3-Clause	1	/* SPDX-License-Identifier: BSD-3-Clause */
2	* Copyright (c) 2016-2018, NXP Semiconductors	2	/* Copyright (c) 2016-2018, NXP Semiconductors
3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>	3	* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
4	*/	4	*/
5	#ifndef _SJA1105_STATIC_CONFIG_H	5	#ifndef _SJA1105_STATIC_CONFIG_H

drivers/net/dsa/sja1105/sja1105_tas.h+2−2

@@ -1,5 +1,5 @@
1	/* SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	* Copyright (c) 2019, Vladimir Oltean <olteanv@gmail.com>	2	/* Copyright (c) 2019, Vladimir Oltean <olteanv@gmail.com>
3	*/	3	*/
4	#ifndef _SJA1105_TAS_H	4	#ifndef _SJA1105_TAS_H
5	#define _SJA1105_TAS_H	5	#define _SJA1105_TAS_H

drivers/net/ethernet/aquantia/atlantic/aq_main.c+1−3

@@ -194,9 +194,7 @@ static void aq_ndev_set_multicast_settings(struct net_device *ndev) · 193 unmodified lines
194	{	194	{
195	struct aq_nic_s *aq_nic = netdev_priv(ndev);	195	struct aq_nic_s *aq_nic = netdev_priv(ndev);
196		196
197	aq_nic_set_packet_filter(aq_nic, ndev->flags);	197	(void)aq_nic_set_multicast_list(aq_nic, ndev);
198
199	aq_nic_set_multicast_list(aq_nic, ndev);
200	}	198	}
201		199
202	static int aq_ndo_vlan_rx_add_vid(struct net_device *ndev, __be16 proto,	200	static int aq_ndo_vlan_rx_add_vid(struct net_device *ndev, __be16 proto,

drivers/net/ethernet/aquantia/atlantic/aq_nic.c+18−16

@@ -631,9 +631,12 @@ err_exit: · 630 unmodified lines
631		631
632	int aq_nic_set_multicast_list(struct aq_nic_s self, struct net_device ndev)	632	int aq_nic_set_multicast_list(struct aq_nic_s self, struct net_device ndev)
633	{	633	{
634	unsigned int packet_filter = self->packet_filter;	634	const struct aq_hw_ops *hw_ops = self->aq_hw_ops;
		635	struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg;
		636	unsigned int packet_filter = ndev->flags;
635	struct netdev_hw_addr *ha = NULL;	637	struct netdev_hw_addr *ha = NULL;
636	unsigned int i = 0U;	638	unsigned int i = 0U;
		639	int err = 0;
637		640
638	self->mc_list.count = 0;	641	self->mc_list.count = 0;
639	if (netdev_uc_count(ndev) > AQ_HW_MULTICAST_ADDRESS_MAX) {	642	if (netdev_uc_count(ndev) > AQ_HW_MULTICAST_ADDRESS_MAX) {
@@ -641,29 +644,28 @@ int aq_nic_set_multicast_list(struct aq_nic_s self, struct net_device ndev) · 1 unmodified line
641	} else {	644	} else {
642	netdev_for_each_uc_addr(ha, ndev) {	645	netdev_for_each_uc_addr(ha, ndev) {
643	ether_addr_copy(self->mc_list.ar[i++], ha->addr);	646	ether_addr_copy(self->mc_list.ar[i++], ha->addr);
644
645	if (i >= AQ_HW_MULTICAST_ADDRESS_MAX)
646	break;
647	}	647	}
648	}	648	}
649		649
650	if (i + netdev_mc_count(ndev) > AQ_HW_MULTICAST_ADDRESS_MAX) {	650	cfg->is_mc_list_enabled = !!(packet_filter & IFF_MULTICAST);
651	packet_filter \|= IFF_ALLMULTI;	651	if (cfg->is_mc_list_enabled) {
652	} else {	652	if (i + netdev_mc_count(ndev) > AQ_HW_MULTICAST_ADDRESS_MAX) {
653	netdev_for_each_mc_addr(ha, ndev) {	653	packet_filter \|= IFF_ALLMULTI;
654	ether_addr_copy(self->mc_list.ar[i++], ha->addr);	654	} else {
655		655	netdev_for_each_mc_addr(ha, ndev) {
656	if (i >= AQ_HW_MULTICAST_ADDRESS_MAX)	656	ether_addr_copy(self->mc_list.ar[i++],
657	break;	657	ha->addr);
		658	}
658	}	659	}
659	}	660	}
660		661
661	if (i > 0 && i <= AQ_HW_MULTICAST_ADDRESS_MAX) {	662	if (i > 0 && i <= AQ_HW_MULTICAST_ADDRESS_MAX) {
662	packet_filter \|= IFF_MULTICAST;
663	self->mc_list.count = i;	663	self->mc_list.count = i;
664	self->aq_hw_ops->hw_multicast_list_set(self->aq_hw,	664	err = hw_ops->hw_multicast_list_set(self->aq_hw,
665	self->mc_list.ar,	665	self->mc_list.ar,
666	self->mc_list.count);	666	self->mc_list.count);
		667	if (err < 0)
		668	return err;
667	}	669	}
668	return aq_nic_set_packet_filter(self, packet_filter);	670	return aq_nic_set_packet_filter(self, packet_filter);
669	}	671	}

drivers/net/ethernet/aquantia/atlantic/aq_ring.c+2−1

 					break;
 				buff->is_error |= buff_->is_error;
+				buff->is_cso_err |= buff_->is_cso_err;
 			} while (!buff_->is_eop);
 				err = 0;
 				goto err_exit;
 			}
-			if (buff->is_error) {
+			if (buff->is_error || buff->is_cso_err) {
 				buff_ = buff;
 				do {
 					next_ = buff_->next,

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c+18−5

 				     cfg->is_vlan_force_promisc);
 	hw_atl_rpfl2multicast_flr_en_set(self,
-					 IS_FILTER_ENABLED(IFF_ALLMULTI), 0);
+					 IS_FILTER_ENABLED(IFF_ALLMULTI) &&
+					 IS_FILTER_ENABLED(IFF_MULTICAST), 0);
 	hw_atl_rpfl2_accept_all_mc_packets_set(self,
-					       IS_FILTER_ENABLED(IFF_ALLMULTI));
+					      IS_FILTER_ENABLED(IFF_ALLMULTI) &&
+					      IS_FILTER_ENABLED(IFF_MULTICAST));
 	hw_atl_rpfl2broadcast_en_set(self, IS_FILTER_ENABLED(IFF_BROADCAST));
-	cfg->is_mc_list_enabled = IS_FILTER_ENABLED(IFF_MULTICAST);
 	for (i = HW_ATL_B0_MAC_MIN; i < HW_ATL_B0_MAC_MAX; ++i)
 		hw_atl_rpfl2_uc_flr_en_set(self,
 static int hw_atl_b0_hw_stop(struct aq_hw_s *self)
 {
+	int err;
+	u32 val;
 	hw_atl_b0_hw_irq_disable(self, HW_ATL_B0_INT_MASK);
 	/* Invalidate Descriptor Cache to prevent writing to the cached
 	 * descriptors and to the data pointer of those descriptors
 	 */
-	hw_atl_rdm_rx_dma_desc_cache_init_set(self, 1);
+	hw_atl_rdm_rx_dma_desc_cache_init_tgl(self);
-	return aq_hw_err_from_flags(self);
+	err = aq_hw_err_from_flags(self);
+	if (err)
+		goto err_exit;
+	readx_poll_timeout_atomic(hw_atl_rdm_rx_dma_desc_cache_init_done_get,
+				  self, val, val == 1, 1000U, 10000U);
+err_exit:
+	return err;
 }
 static int hw_atl_b0_hw_ring_tx_stop(struct aq_hw_s *self,

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c+15−2

@@ -606,12 +606,25 @@ void hw_atl_rpb_rx_flow_ctl_mode_set(struct aq_hw_s *aq_hw, u32 rx_flow_ctl_mode · 605 unmodified lines
606	HW_ATL_RPB_RX_FC_MODE_SHIFT, rx_flow_ctl_mode);	606	HW_ATL_RPB_RX_FC_MODE_SHIFT, rx_flow_ctl_mode);
607	}	607	}
608		608
609	void hw_atl_rdm_rx_dma_desc_cache_init_set(struct aq_hw_s *aq_hw, u32 init)	609	void hw_atl_rdm_rx_dma_desc_cache_init_tgl(struct aq_hw_s *aq_hw)
610	{	610	{
		611	u32 val;
		612
		613	val = aq_hw_read_reg_bit(aq_hw, HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_ADR,
		614	HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_MSK,
		615	HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_SHIFT);
		616
611	aq_hw_write_reg_bit(aq_hw, HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_ADR,	617	aq_hw_write_reg_bit(aq_hw, HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_ADR,
612	HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_MSK,	618	HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_MSK,
613	HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_SHIFT,	619	HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_SHIFT,
614	init);	620	val ^ 1);
		621	}
		622
		623	u32 hw_atl_rdm_rx_dma_desc_cache_init_done_get(struct aq_hw_s *aq_hw)
		624	{
		625	return aq_hw_read_reg_bit(aq_hw, RDM_RX_DMA_DESC_CACHE_INIT_DONE_ADR,
		626	RDM_RX_DMA_DESC_CACHE_INIT_DONE_MSK,
		627	RDM_RX_DMA_DESC_CACHE_INIT_DONE_SHIFT);
615	}	628	}
616		629
617	void hw_atl_rpb_rx_pkt_buff_size_per_tc_set(struct aq_hw_s *aq_hw,	630	void hw_atl_rpb_rx_pkt_buff_size_per_tc_set(struct aq_hw_s *aq_hw,

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h+5−2

 					    u32 rx_pkt_buff_size_per_tc,
 					    u32 buffer);
-/* set rdm rx dma descriptor cache init */
+/* toggle rdm rx dma descriptor cache init */
-void hw_atl_rdm_rx_dma_desc_cache_init_set(struct aq_hw_s *aq_hw, u32 init);
+void hw_atl_rdm_rx_dma_desc_cache_init_tgl(struct aq_hw_s *aq_hw);
+/* get rdm rx dma descriptor cache init done */
+u32 hw_atl_rdm_rx_dma_desc_cache_init_done_get(struct aq_hw_s *aq_hw);
 /* set rx xoff enable (per tc) */
 void hw_atl_rpb_rx_xoff_en_per_tc_set(struct aq_hw_s *aq_hw, u32 rx_xoff_en_per_tc,

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h+19−0

@@ -318,6 +318,25 @@ · 317 unmodified lines
318	/* default value of bitfield rdm_desc_init_i */	318	/* default value of bitfield rdm_desc_init_i */
319	#define HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_DEFAULT 0x0	319	#define HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_DEFAULT 0x0
320		320
		321	/* rdm_desc_init_done_i bitfield definitions
		322	* preprocessor definitions for the bitfield rdm_desc_init_done_i.
		323	* port="pif_rdm_desc_init_done_i"
		324	*/
		325
		326	/* register address for bitfield rdm_desc_init_done_i */
		327	#define RDM_RX_DMA_DESC_CACHE_INIT_DONE_ADR 0x00005a10
		328	/* bitmask for bitfield rdm_desc_init_done_i */
		329	#define RDM_RX_DMA_DESC_CACHE_INIT_DONE_MSK 0x00000001U
		330	/* inverted bitmask for bitfield rdm_desc_init_done_i */
		331	#define RDM_RX_DMA_DESC_CACHE_INIT_DONE_MSKN 0xfffffffe
		332	/* lower bit position of bitfield rdm_desc_init_done_i */
		333	#define RDM_RX_DMA_DESC_CACHE_INIT_DONE_SHIFT 0U
		334	/* width of bitfield rdm_desc_init_done_i */
		335	#define RDM_RX_DMA_DESC_CACHE_INIT_DONE_WIDTH 1
		336	/* default value of bitfield rdm_desc_init_done_i */
		337	#define RDM_RX_DMA_DESC_CACHE_INIT_DONE_DEFAULT 0x0
		338
		339
321	/* rx int_desc_wrb_en bitfield definitions	340	/* rx int_desc_wrb_en bitfield definitions
322	* preprocessor definitions for the bitfield "int_desc_wrb_en".	341	* preprocessor definitions for the bitfield "int_desc_wrb_en".
323	* port="pif_rdm_int_desc_wrb_en_i"	342	* port="pif_rdm_int_desc_wrb_en_i"

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils_fw2x.c+1−1

@@ -337,7 +337,7 @@ static int aq_fw2x_get_phy_temp(struct aq_hw_s self, int temp) · 336 unmodified lines
337	/* Convert PHY temperature from 1/256 degree Celsius	337	/* Convert PHY temperature from 1/256 degree Celsius
338	* to 1/1000 degree Celsius.	338	* to 1/1000 degree Celsius.
339	*/	339	*/
340	temp = temp_res 1000 / 256;	340	temp = (temp_res & 0xFFFF) 1000 / 256;
341		341
342	return 0;	342	return 0;
343	}	343	}

drivers/net/ethernet/broadcom/Kconfig+3−1

 	default y
 	depends on (SSB_POSSIBLE && HAS_DMA) || PCI || BCM63XX || \
 		   SIBYTE_SB1xxx_SOC
-	select DIMLIB
 	---help---
 	  If you have a network (Ethernet) chipset belonging to this class,
 	  say Y.
 	select FIXED_PHY
 	select BCM7XXX_PHY
 	select MDIO_BCM_UNIMAC
+	select DIMLIB
 	help
 	  This driver supports the built-in Ethernet MACs found in the
 	  Broadcom BCM7xxx Set Top Box family chipset.
 	select MII
 	select PHYLIB
 	select FIXED_PHY
+	select DIMLIB
 	help
 	  This driver supports the built-in Ethernet MACs found in the
 	  Broadcom BCM7xxx Set Top Box family chipset using an internal
 	select LIBCRC32C
 	select NET_DEVLINK
 	select PAGE_POOL
+	select DIMLIB
 	---help---
 	  This driver supports Broadcom NetXtreme-C/E 10/25/40/50 gigabit
 	  Ethernet cards.  To compile this driver as a module, choose M here:

drivers/net/ethernet/broadcom/genet/bcmgenet.c+26−15

@@ -2018,6 +2018,8 @@ static void bcmgenet_link_intr_enable(struct bcmgenet_priv *priv) · 2017 unmodified lines
2018	*/	2018	*/
2019	if (priv->internal_phy) {	2019	if (priv->internal_phy) {
2020	int0_enable \|= UMAC_IRQ_LINK_EVENT;	2020	int0_enable \|= UMAC_IRQ_LINK_EVENT;
		2021	if (GENET_IS_V1(priv) \|\| GENET_IS_V2(priv) \|\| GENET_IS_V3(priv))
		2022	int0_enable \|= UMAC_IRQ_PHY_DET_R;
2021	} else if (priv->ext_phy) {	2023	} else if (priv->ext_phy) {
2022	int0_enable \|= UMAC_IRQ_LINK_EVENT;	2024	int0_enable \|= UMAC_IRQ_LINK_EVENT;
2023	} else if (priv->phy_interface == PHY_INTERFACE_MODE_MOCA) {	2025	} else if (priv->phy_interface == PHY_INTERFACE_MODE_MOCA) {
@@ -2611,11 +2613,14 @@ static void bcmgenet_irq_task(struct work_struct *work) · 587 unmodified lines
2611	priv->irq0_stat = 0;	2613	priv->irq0_stat = 0;
2612	spin_unlock_irq(&priv->lock);	2614	spin_unlock_irq(&priv->lock);
2613		2615
		2616	if (status & UMAC_IRQ_PHY_DET_R &&
		2617	priv->dev->phydev->autoneg != AUTONEG_ENABLE)
		2618	phy_init_hw(priv->dev->phydev);
		2619
2614	/* Link UP/DOWN event */	2620	/* Link UP/DOWN event */
2615	if (status & UMAC_IRQ_LINK_EVENT) {	2621	if (status & UMAC_IRQ_LINK_EVENT)
2616	priv->dev->phydev->link = !!(status & UMAC_IRQ_LINK_UP);
2617	phy_mac_interrupt(priv->dev->phydev);	2622	phy_mac_interrupt(priv->dev->phydev);
2618	}	2623
2619	}	2624	}
2620		2625
2621	/* bcmgenet_isr1: handle Rx and Tx priority queues */	2626	/* bcmgenet_isr1: handle Rx and Tx priority queues */
@@ -2710,7 +2715,7 @@ static irqreturn_t bcmgenet_isr0(int irq, void *dev_id) · 88 unmodified lines
2710	}	2715	}
2711		2716
2712	/* all other interested interrupts handled in bottom half */	2717	/* all other interested interrupts handled in bottom half */
2713	status &= UMAC_IRQ_LINK_EVENT;	2718	status &= (UMAC_IRQ_LINK_EVENT \| UMAC_IRQ_PHY_DET_R);
2714	if (status) {	2719	if (status) {
2715	/* Save irq status for bottom-half processing. */	2720	/* Save irq status for bottom-half processing. */
2716	spin_lock_irqsave(&priv->lock, flags);	2721	spin_lock_irqsave(&priv->lock, flags);
@@ -2874,6 +2879,12 @@ static int bcmgenet_open(struct net_device *dev) · 157 unmodified lines
2874	if (priv->internal_phy)	2879	if (priv->internal_phy)
2875	bcmgenet_power_up(priv, GENET_POWER_PASSIVE);	2880	bcmgenet_power_up(priv, GENET_POWER_PASSIVE);
2876		2881
		2882	ret = bcmgenet_mii_connect(dev);
		2883	if (ret) {
		2884	netdev_err(dev, "failed to connect to PHY\n");
		2885	goto err_clk_disable;
		2886	}
		2887
2877	/* take MAC out of reset */	2888	/* take MAC out of reset */
2878	bcmgenet_umac_reset(priv);	2889	bcmgenet_umac_reset(priv);
2879		2890
@@ -2883,6 +2894,12 @@ static int bcmgenet_open(struct net_device *dev) · 3 unmodified lines
2883	reg = bcmgenet_umac_readl(priv, UMAC_CMD);	2894	reg = bcmgenet_umac_readl(priv, UMAC_CMD);
2884	priv->crc_fwd_en = !!(reg & CMD_CRC_FWD);	2895	priv->crc_fwd_en = !!(reg & CMD_CRC_FWD);
2885		2896
		2897	ret = bcmgenet_mii_config(dev, true);
		2898	if (ret) {
		2899	netdev_err(dev, "unsupported PHY\n");
		2900	goto err_disconnect_phy;
		2901	}
		2902
2886	bcmgenet_set_hw_addr(priv, dev->dev_addr);	2903	bcmgenet_set_hw_addr(priv, dev->dev_addr);
2887		2904
2888	if (priv->internal_phy) {	2905	if (priv->internal_phy) {
@@ -2898,7 +2915,7 @@ static int bcmgenet_open(struct net_device *dev) · 9 unmodified lines
2898	ret = bcmgenet_init_dma(priv);	2915	ret = bcmgenet_init_dma(priv);
2899	if (ret) {	2916	if (ret) {
2900	netdev_err(dev, "failed to initialize DMA\n");	2917	netdev_err(dev, "failed to initialize DMA\n");
2901	goto err_clk_disable;	2918	goto err_disconnect_phy;
2902	}	2919	}
2903		2920
2904	/* Always enable ring 16 - descriptor ring */	2921	/* Always enable ring 16 - descriptor ring */
@@ -2921,25 +2938,19 @@ static int bcmgenet_open(struct net_device *dev) · 16 unmodified lines
2921	goto err_irq0;	2938	goto err_irq0;
2922	}	2939	}
2923		2940
2924	ret = bcmgenet_mii_probe(dev);
2925	if (ret) {
2926	netdev_err(dev, "failed to connect to PHY\n");
2927	goto err_irq1;
2928	}
2929
2930	bcmgenet_netif_start(dev);	2941	bcmgenet_netif_start(dev);
2931		2942
2932	netif_tx_start_all_queues(dev);	2943	netif_tx_start_all_queues(dev);
2933		2944
2934	return 0;	2945	return 0;
2935		2946
2936	err_irq1:
2937	free_irq(priv->irq1, priv);
2938	err_irq0:	2947	err_irq0:
2939	free_irq(priv->irq0, priv);	2948	free_irq(priv->irq0, priv);
2940	err_fini_dma:	2949	err_fini_dma:
2941	bcmgenet_dma_teardown(priv);	2950	bcmgenet_dma_teardown(priv);
2942	bcmgenet_fini_dma(priv);	2951	bcmgenet_fini_dma(priv);
		2952	err_disconnect_phy:
		2953	phy_disconnect(dev->phydev);
2943	err_clk_disable:	2954	err_clk_disable:
2944	if (priv->internal_phy)	2955	if (priv->internal_phy)
2945	bcmgenet_power_down(priv, GENET_POWER_PASSIVE);	2956	bcmgenet_power_down(priv, GENET_POWER_PASSIVE);
@@ -3620,6 +3631,8 @@ static int bcmgenet_resume(struct device *d) · 674 unmodified lines
3620	if (priv->internal_phy)	3631	if (priv->internal_phy)
3621	bcmgenet_power_up(priv, GENET_POWER_PASSIVE);	3632	bcmgenet_power_up(priv, GENET_POWER_PASSIVE);
3622		3633
		3634	phy_init_hw(dev->phydev);
		3635
3623	bcmgenet_umac_reset(priv);	3636	bcmgenet_umac_reset(priv);
3624		3637
3625	init_umac(priv);	3638	init_umac(priv);
@@ -3628,8 +3641,6 @@ static int bcmgenet_resume(struct device *d) · 2 unmodified lines
3628	if (priv->wolopts)	3641	if (priv->wolopts)
3629	clk_disable_unprepare(priv->clk_wol);	3642	clk_disable_unprepare(priv->clk_wol);
3630		3643
3631	phy_init_hw(dev->phydev);
3632
3633	/* Speed settings must be restored */	3644	/* Speed settings must be restored */
3634	bcmgenet_mii_config(priv->dev, false);	3645	bcmgenet_mii_config(priv->dev, false);
3635		3646

drivers/net/ethernet/broadcom/genet/bcmgenet.h+2−1

 #define  EXT_PWR_DOWN_PHY_EN		(1 << 20)
 #define EXT_RGMII_OOB_CTRL		0x0C
+#define  RGMII_MODE_EN_V123		(1 << 0)
 #define  RGMII_LINK			(1 << 4)
 #define  OOB_DISABLE			(1 << 5)
 #define  RGMII_MODE_EN			(1 << 6)
 /* MDIO routines */
 int bcmgenet_mii_init(struct net_device *dev);
+int bcmgenet_mii_connect(struct net_device *dev);
 int bcmgenet_mii_config(struct net_device *dev, bool init);
-int bcmgenet_mii_probe(struct net_device *dev);
 void bcmgenet_mii_exit(struct net_device *dev);
 void bcmgenet_phy_power_set(struct net_device *dev, bool enable);
 void bcmgenet_mii_setup(struct net_device *dev);

drivers/net/ethernet/broadcom/genet/bcmmii.c+56−61

 					  bcmgenet_fixed_phy_link_update);
 }
+int bcmgenet_mii_connect(struct net_device *dev)
+{
+	struct bcmgenet_priv *priv = netdev_priv(dev);
+	struct device_node *dn = priv->pdev->dev.of_node;
+	struct phy_device *phydev;
+	u32 phy_flags = 0;
+	int ret;
+	/* Communicate the integrated PHY revision */
+	if (priv->internal_phy)
+		phy_flags = priv->gphy_rev;
+	/* Initialize link state variables that bcmgenet_mii_setup() uses */
+	priv->old_link = -1;
+	priv->old_speed = -1;
+	priv->old_duplex = -1;
+	priv->old_pause = -1;
+	if (dn) {
+		phydev = of_phy_connect(dev, priv->phy_dn, bcmgenet_mii_setup,
+					phy_flags, priv->phy_interface);
+		if (!phydev) {
+			pr_err("could not attach to PHY\n");
+			return -ENODEV;
+		}
+	} else {
+		phydev = dev->phydev;
+		phydev->dev_flags = phy_flags;
+		ret = phy_connect_direct(dev, phydev, bcmgenet_mii_setup,
+					 priv->phy_interface);
+		if (ret) {
+			pr_err("could not attach to PHY\n");
+			return -ENODEV;
+		}
+	}
+	return 0;
+}
 int bcmgenet_mii_config(struct net_device *dev, bool init)
 {
 	struct bcmgenet_priv *priv = netdev_priv(dev);
 	 */
 	if (priv->ext_phy) {
 		reg = bcmgenet_ext_readl(priv, EXT_RGMII_OOB_CTRL);
-		reg |= RGMII_MODE_EN | id_mode_dis;
+		reg |= id_mode_dis;
+		if (GENET_IS_V1(priv) || GENET_IS_V2(priv) || GENET_IS_V3(priv))
+			reg |= RGMII_MODE_EN_V123;
+		else
+			reg |= RGMII_MODE_EN;
 		bcmgenet_ext_writel(priv, reg, EXT_RGMII_OOB_CTRL);
 	}
-	if (init)
+	if (init) {
-		dev_info(kdev, "configuring instance for %s\n", phy_name);
+		linkmode_copy(phydev->advertising, phydev->supported);
-	return 0;
-}
-int bcmgenet_mii_probe(struct net_device *dev)
-{
-	struct bcmgenet_priv *priv = netdev_priv(dev);
-	struct device_node *dn = priv->pdev->dev.of_node;
-	struct phy_device *phydev;
-	u32 phy_flags;
-	int ret;
-	/* Communicate the integrated PHY revision */
-	phy_flags = priv->gphy_rev;
-	/* Initialize link state variables that bcmgenet_mii_setup() uses */
-	priv->old_link = -1;
-	priv->old_speed = -1;
-	priv->old_duplex = -1;
-	priv->old_pause = -1;
-	if (dn) {
-		phydev = of_phy_connect(dev, priv->phy_dn, bcmgenet_mii_setup,
-					phy_flags, priv->phy_interface);
-		if (!phydev) {
-			pr_err("could not attach to PHY\n");
-			return -ENODEV;
-		}
-	} else {
-		phydev = dev->phydev;
-		phydev->dev_flags = phy_flags;
-		ret = phy_connect_direct(dev, phydev, bcmgenet_mii_setup,
+		/* The internal PHY has its link interrupts routed to the
-					 priv->phy_interface);
+		 * Ethernet MAC ISRs. On GENETv5 there is a hardware issue
-		if (ret) {
+		 * that prevents the signaling of link UP interrupts when
-			pr_err("could not attach to PHY\n");
+		 * the link operates at 10Mbps, so fallback to polling for
-			return -ENODEV;
+		 * those versions of GENET.
-		}
+		 */
-	}
+		if (priv->internal_phy && !GENET_IS_V5(priv))
+			phydev->irq = PHY_IGNORE_INTERRUPT;
-	/* Configure port multiplexer based on what the probed PHY device since
+		dev_info(kdev, "configuring instance for %s\n", phy_name);
-	 * reading the 'max-speed' property determines the maximum supported
-	 * PHY speed which is needed for bcmgenet_mii_config() to configure
-	 * things appropriately.
-	 */
-	ret = bcmgenet_mii_config(dev, true);
-	if (ret) {
-		phy_disconnect(dev->phydev);
-		return ret;
 	}
-	linkmode_copy(phydev->advertising, phydev->supported);
-	/* The internal PHY has its link interrupts routed to the
-	 * Ethernet MAC ISRs. On GENETv5 there is a hardware issue
-	 * that prevents the signaling of link UP interrupts when
-	 * the link operates at 10Mbps, so fallback to polling for
-	 * those versions of GENET.
-	 */
-	if (priv->internal_phy && !GENET_IS_V5(priv))
-		dev->phydev->irq = PHY_IGNORE_INTERRUPT;
 	return 0;
 }

drivers/net/ethernet/cadence/macb_main.c+6−6

@@ -3405,17 +3405,17 @@ static int macb_clk_init(struct platform_device pdev, struct clk *pclk, · 3404 unmodified lines
3405	return err;	3405	return err;
3406	}	3406	}
3407		3407
3408	*tx_clk = devm_clk_get(&pdev->dev, "tx_clk");	3408	*tx_clk = devm_clk_get_optional(&pdev->dev, "tx_clk");
3409	if (IS_ERR(*tx_clk))	3409	if (IS_ERR(*tx_clk))
3410	*tx_clk = NULL;	3410	return PTR_ERR(*tx_clk);
3411		3411
3412	*rx_clk = devm_clk_get(&pdev->dev, "rx_clk");	3412	*rx_clk = devm_clk_get_optional(&pdev->dev, "rx_clk");
3413	if (IS_ERR(*rx_clk))	3413	if (IS_ERR(*rx_clk))
3414	*rx_clk = NULL;	3414	return PTR_ERR(*rx_clk);
3415		3415
3416	*tsu_clk = devm_clk_get(&pdev->dev, "tsu_clk");	3416	*tsu_clk = devm_clk_get_optional(&pdev->dev, "tsu_clk");
3417	if (IS_ERR(*tsu_clk))	3417	if (IS_ERR(*tsu_clk))
3418	*tsu_clk = NULL;	3418	return PTR_ERR(*tsu_clk);
3419		3419
3420	err = clk_prepare_enable(*pclk);	3420	err = clk_prepare_enable(*pclk);
3421	if (err) {	3421	if (err) {

drivers/net/ethernet/cavium/common/cavium_ptp.h+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	/* SPDX-License-Identifier: GPL-2.0 */
2	/* cavium_ptp.h - PTP 1588 clock on Cavium hardware	2	/* cavium_ptp.h - PTP 1588 clock on Cavium hardware
3	* Copyright (c) 2003-2015, 2017 Cavium, Inc.	3	* Copyright (c) 2003-2015, 2017 Cavium, Inc.
4	*/	4	*/

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c+49−1

@@ -1235,6 +1235,8 @@ static void dpaa2_eth_set_rx_taildrop(struct dpaa2_eth_priv *priv, bool enable) · 1234 unmodified lines
1235	priv->rx_td_enabled = enable;	1235	priv->rx_td_enabled = enable;
1236	}	1236	}
1237		1237
		1238	static void update_tx_fqids(struct dpaa2_eth_priv *priv);
		1239
1238	static int link_state_update(struct dpaa2_eth_priv *priv)	1240	static int link_state_update(struct dpaa2_eth_priv *priv)
1239	{	1241	{
1240	struct dpni_link_state state = {0};	1242	struct dpni_link_state state = {0};
@@ -1261,6 +1263,7 @@ static int link_state_update(struct dpaa2_eth_priv *priv) · 20 unmodified lines
1261	goto out;	1263	goto out;
1262		1264
1263	if (state.up) {	1265	if (state.up) {
		1266	update_tx_fqids(priv);
1264	netif_carrier_on(priv->net_dev);	1267	netif_carrier_on(priv->net_dev);
1265	netif_tx_start_all_queues(priv->net_dev);	1268	netif_tx_start_all_queues(priv->net_dev);
1266	} else {	1269	} else {
@@ -2533,6 +2536,47 @@ static int set_pause(struct dpaa2_eth_priv *priv) · 1266 unmodified lines
2533	return 0;	2536	return 0;
2534	}	2537	}
2535		2538
		2539	static void update_tx_fqids(struct dpaa2_eth_priv *priv)
		2540	{
		2541	struct dpni_queue_id qid = {0};
		2542	struct dpaa2_eth_fq *fq;
		2543	struct dpni_queue queue;
		2544	int i, j, err;
		2545
		2546	/* We only use Tx FQIDs for FQID-based enqueue, so check
		2547	* if DPNI version supports it before updating FQIDs
		2548	*/
		2549	if (dpaa2_eth_cmp_dpni_ver(priv, DPNI_ENQUEUE_FQID_VER_MAJOR,
		2550	DPNI_ENQUEUE_FQID_VER_MINOR) < 0)
		2551	return;
		2552
		2553	for (i = 0; i < priv->num_fqs; i++) {
		2554	fq = &priv->fq[i];
		2555	if (fq->type != DPAA2_TX_CONF_FQ)
		2556	continue;
		2557	for (j = 0; j < dpaa2_eth_tc_count(priv); j++) {
		2558	err = dpni_get_queue(priv->mc_io, 0, priv->mc_token,
		2559	DPNI_QUEUE_TX, j, fq->flowid,
		2560	&queue, &qid);
		2561	if (err)
		2562	goto out_err;
		2563
		2564	fq->tx_fqid[j] = qid.fqid;
		2565	if (fq->tx_fqid[j] == 0)
		2566	goto out_err;
		2567	}
		2568	}
		2569
		2570	priv->enqueue = dpaa2_eth_enqueue_fq;
		2571
		2572	return;
		2573
		2574	out_err:
		2575	netdev_info(priv->net_dev,
		2576	"Error reading Tx FQID, fallback to QDID-based enqueue\n");
		2577	priv->enqueue = dpaa2_eth_enqueue_qd;
		2578	}
		2579
2536	/* Configure the DPNI object this interface is associated with */	2580	/* Configure the DPNI object this interface is associated with */
2537	static int setup_dpni(struct fsl_mc_device *ls_dev)	2581	static int setup_dpni(struct fsl_mc_device *ls_dev)
2538	{	2582	{
@@ -3306,6 +3350,9 @@ static irqreturn_t dpni_irq0_handler_thread(int irq_num, void *arg) · 767 unmodified lines
3306	if (status & DPNI_IRQ_EVENT_LINK_CHANGED)	3350	if (status & DPNI_IRQ_EVENT_LINK_CHANGED)
3307	link_state_update(netdev_priv(net_dev));	3351	link_state_update(netdev_priv(net_dev));
3308		3352
		3353	if (status & DPNI_IRQ_EVENT_ENDPOINT_CHANGED)
		3354	set_mac_addr(netdev_priv(net_dev));
		3355
3309	return IRQ_HANDLED;	3356	return IRQ_HANDLED;
3310	}	3357	}
3311		3358
@@ -3331,7 +3378,8 @@ static int setup_irqs(struct fsl_mc_device *ls_dev) · 19 unmodified lines
3331	}	3378	}
3332		3379
3333	err = dpni_set_irq_mask(ls_dev->mc_io, 0, ls_dev->mc_handle,	3380	err = dpni_set_irq_mask(ls_dev->mc_io, 0, ls_dev->mc_handle,
3334	DPNI_IRQ_INDEX, DPNI_IRQ_EVENT_LINK_CHANGED);	3381	DPNI_IRQ_INDEX, DPNI_IRQ_EVENT_LINK_CHANGED \|
		3382	DPNI_IRQ_EVENT_ENDPOINT_CHANGED);
3335	if (err < 0) {	3383	if (err < 0) {
3336	dev_err(&ls_dev->dev, "dpni_set_irq_mask(): %d\n", err);	3384	dev_err(&ls_dev->dev, "dpni_set_irq_mask(): %d\n", err);
3337	goto free_irq;	3385	goto free_irq;

drivers/net/ethernet/freescale/dpaa2/dpni.h+4−1

  */
 #define DPNI_IRQ_INDEX				0
 /**
- * IRQ event - indicates a change in link state
+ * IRQ events:
+ *       indicates a change in link state
+ *       indicates a change in endpoint
  */
 #define DPNI_IRQ_EVENT_LINK_CHANGED		0x00000001
+#define DPNI_IRQ_EVENT_ENDPOINT_CHANGED		0x00000002
 int dpni_set_irq_enable(struct fsl_mc_io	*mc_io,
 			u32			cmd_flags,

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

@@ -32,6 +32,8 @@ · 31 unmodified lines
32		32
33	#define HNAE3_MOD_VERSION "1.0"	33	#define HNAE3_MOD_VERSION "1.0"
34		34
		35	#define HNAE3_MIN_VECTOR_NUM 2 /* first one for misc, another for IO */
		36
35	/* Device IDs */	37	/* Device IDs */
36	#define HNAE3_DEV_ID_GE 0xA220	38	#define HNAE3_DEV_ID_GE 0xA220
37	#define HNAE3_DEV_ID_25GE 0xA221	39	#define HNAE3_DEV_ID_25GE 0xA221

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c+20−1

 		hnae3_get_field(__le16_to_cpu(req->pf_intr_vector_number),
 				HCLGE_PF_VEC_NUM_M, HCLGE_PF_VEC_NUM_S);
+		/* nic's msix numbers is always equals to the roce's. */
+		hdev->num_nic_msi = hdev->num_roce_msi;
 		/* PF should have NIC vectors and Roce vectors,
 		 * NIC vectors are queued before Roce vectors.
 		 */
 		hdev->num_msi =
 		hnae3_get_field(__le16_to_cpu(req->pf_intr_vector_number),
 				HCLGE_PF_VEC_NUM_M, HCLGE_PF_VEC_NUM_S);
+		hdev->num_nic_msi = hdev->num_msi;
+	}
+	if (hdev->num_nic_msi < HNAE3_MIN_VECTOR_NUM) {
+		dev_err(&hdev->pdev->dev,
+			"Just %u msi resources, not enough for pf(min:2).\n",
+			hdev->num_nic_msi);
+		return -EINVAL;
 	}
 	return 0;
 	kinfo->rss_size = min_t(u16, hdev->rss_size_max,
 				vport->alloc_tqps / hdev->tm_info.num_tc);
+	/* ensure one to one mapping between irq and queue at default */
+	kinfo->rss_size = min_t(u16, kinfo->rss_size,
+				(hdev->num_nic_msi - 1) / hdev->tm_info.num_tc);
 	return 0;
 }
 	int vectors;
 	int i;
-	vectors = pci_alloc_irq_vectors(pdev, 1, hdev->num_msi,
+	vectors = pci_alloc_irq_vectors(pdev, HNAE3_MIN_VECTOR_NUM,
+					hdev->num_msi,
 					PCI_IRQ_MSI | PCI_IRQ_MSIX);
 	if (vectors < 0) {
 		dev_err(&pdev->dev,
 	hdev->num_msi = vectors;
 	hdev->num_msi_left = vectors;
 	hdev->base_msi_vector = pdev->irq;
 	hdev->roce_base_vector = hdev->base_msi_vector +
 				hdev->roce_base_msix_offset;
 	int alloc = 0;
 	int i, j;
+	vector_num = min_t(u16, hdev->num_nic_msi - 1, vector_num);
 	vector_num = min(hdev->num_msi_left, vector_num);
 	for (j = 0; j < vector_num; j++) {

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

@@ -763,6 +763,7 @@ struct hclge_dev { · 762 unmodified lines
763	u32 base_msi_vector;	763	u32 base_msi_vector;
764	u16 *vector_status;	764	u16 *vector_status;
765	int *vector_irq;	765	int *vector_irq;
		766	u16 num_nic_msi; /* Num of nic vectors for this PF */
766	u16 num_roce_msi; /* Num of roce vectors for this PF */	767	u16 num_roce_msi; /* Num of roce vectors for this PF */
767	int roce_base_vector;	768	int roce_base_vector;
768		769

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c+9−2

 		kinfo->rss_size = kinfo->req_rss_size;
 	} else if (kinfo->rss_size > max_rss_size ||
 		   (!kinfo->req_rss_size && kinfo->rss_size < max_rss_size)) {
+		/* if user not set rss, the rss_size should compare with the
+		 * valid msi numbers to ensure one to one map between tqp and
+		 * irq as default.
+		 */
+		if (!kinfo->req_rss_size)
+			max_rss_size = min_t(u16, max_rss_size,
+					     (hdev->num_nic_msi - 1) /
+					     kinfo->num_tc);
 		/* Set to the maximum specification value (max_rss_size). */
-		dev_info(&hdev->pdev->dev, "rss changes from %d to %d\n",
-			 kinfo->rss_size, max_rss_size);
 		kinfo->rss_size = max_rss_size;
 	}

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c+25−3

 		kinfo->tqp[i] = &hdev->htqp[i].q;
 	}
+	/* after init the max rss_size and tqps, adjust the default tqp numbers
+	 * and rss size with the actual vector numbers
+	 */
+	kinfo->num_tqps = min_t(u16, hdev->num_nic_msix - 1, kinfo->num_tqps);
+	kinfo->rss_size = min_t(u16, kinfo->num_tqps / kinfo->num_tc,
+				kinfo->rss_size);
 	return 0;
 }
 	int alloc = 0;
 	int i, j;
+	vector_num = min_t(u16, hdev->num_nic_msix - 1, vector_num);
 	vector_num = min(hdev->num_msi_left, vector_num);
 	for (j = 0; j < vector_num; j++) {
 	int vectors;
 	int i;
-	if (hnae3_get_bit(hdev->ae_dev->flag, HNAE3_DEV_SUPPORT_ROCE_B))
+	if (hnae3_dev_roce_supported(hdev))
 		vectors = pci_alloc_irq_vectors(pdev,
 						hdev->roce_base_msix_offset + 1,
 						hdev->num_msi,
 						PCI_IRQ_MSIX);
 	else
-		vectors = pci_alloc_irq_vectors(pdev, 1, hdev->num_msi,
+		vectors = pci_alloc_irq_vectors(pdev, HNAE3_MIN_VECTOR_NUM,
+						hdev->num_msi,
 						PCI_IRQ_MSI | PCI_IRQ_MSIX);
 	if (vectors < 0) {
 	hdev->num_msi = vectors;
 	hdev->num_msi_left = vectors;
 	hdev->base_msi_vector = pdev->irq;
 	hdev->roce_base_vector = pdev->irq + hdev->roce_base_msix_offset;
 	req = (struct hclgevf_query_res_cmd *)desc.data;
-	if (hnae3_get_bit(hdev->ae_dev->flag, HNAE3_DEV_SUPPORT_ROCE_B)) {
+	if (hnae3_dev_roce_supported(hdev)) {
 		hdev->roce_base_msix_offset =
 		hnae3_get_field(__le16_to_cpu(req->msixcap_localid_ba_rocee),
 				HCLGEVF_MSIX_OFT_ROCEE_M,
 		hnae3_get_field(__le16_to_cpu(req->vf_intr_vector_number),
 				HCLGEVF_VEC_NUM_M, HCLGEVF_VEC_NUM_S);
+		/* nic's msix numbers is always equals to the roce's. */
+		hdev->num_nic_msix = hdev->num_roce_msix;
 		/* VF should have NIC vectors and Roce vectors, NIC vectors
 		 * are queued before Roce vectors. The offset is fixed to 64.
 		 */
 		hdev->num_msi =
 		hnae3_get_field(__le16_to_cpu(req->vf_intr_vector_number),
 				HCLGEVF_VEC_NUM_M, HCLGEVF_VEC_NUM_S);
+		hdev->num_nic_msix = hdev->num_msi;
+	}
+	if (hdev->num_nic_msix < HNAE3_MIN_VECTOR_NUM) {
+		dev_err(&hdev->pdev->dev,
+			"Just %u msi resources, not enough for vf(min:2).\n",
+			hdev->num_nic_msix);
+		return -EINVAL;
 	}
 	return 0;

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

@@ -270,6 +270,7 @@ struct hclgevf_dev { · 269 unmodified lines
270	u16 num_msi;	270	u16 num_msi;
271	u16 num_msi_left;	271	u16 num_msi_left;
272	u16 num_msi_used;	272	u16 num_msi_used;
		273	u16 num_nic_msix; /* Num of nic vectors for this VF */
273	u16 num_roce_msix; /* Num of roce vectors for this VF */	274	u16 num_roce_msix; /* Num of roce vectors for this VF */
274	u16 roce_base_msix_offset;	275	u16 roce_base_msix_offset;
275	int roce_base_vector;	276	int roce_base_vector;

drivers/net/ethernet/i825xx/lasi_82596.c+3−1

 #define OPT_SWAP_PORT	0x0001	/* Need to wordswp on the MPU port */
+#define LIB82596_DMA_ATTR	DMA_ATTR_NON_CONSISTENT
 #define DMA_WBACK(ndev, addr, len) \
 	do { dma_cache_sync((ndev)->dev.parent, (void *)addr, len, DMA_TO_DEVICE); } while (0)
 	unregister_netdev (dev);
 	dma_free_attrs(&pdev->dev, sizeof(struct i596_private), lp->dma,
-		       lp->dma_addr, DMA_ATTR_NON_CONSISTENT);
+		       lp->dma_addr, LIB82596_DMA_ATTR);
 	free_netdev (dev);
 	return 0;
 }

drivers/net/ethernet/i825xx/lib82596.c+2−2

@@ -1065,7 +1065,7 @@ static int i82596_probe(struct net_device *dev) · 1064 unmodified lines
1065		1065
1066	dma = dma_alloc_attrs(dev->dev.parent, sizeof(struct i596_dma),	1066	dma = dma_alloc_attrs(dev->dev.parent, sizeof(struct i596_dma),
1067	&lp->dma_addr, GFP_KERNEL,	1067	&lp->dma_addr, GFP_KERNEL,
1068	DMA_ATTR_NON_CONSISTENT);	1068	LIB82596_DMA_ATTR);
1069	if (!dma) {	1069	if (!dma) {
1070	printk(KERN_ERR "%s: Couldn't get shared memory\n", __FILE__);	1070	printk(KERN_ERR "%s: Couldn't get shared memory\n", __FILE__);
1071	return -ENOMEM;	1071	return -ENOMEM;
@@ -1087,7 +1087,7 @@ static int i82596_probe(struct net_device *dev) · 15 unmodified lines
1087	i = register_netdev(dev);	1087	i = register_netdev(dev);
1088	if (i) {	1088	if (i) {
1089	dma_free_attrs(dev->dev.parent, sizeof(struct i596_dma),	1089	dma_free_attrs(dev->dev.parent, sizeof(struct i596_dma),
1090	dma, lp->dma_addr, DMA_ATTR_NON_CONSISTENT);	1090	dma, lp->dma_addr, LIB82596_DMA_ATTR);
1091	return i;	1091	return i;
1092	}	1092	}
1093		1093

drivers/net/ethernet/i825xx/sni_82596.c+3−1

 static const char sni_82596_string[] = "snirm_82596";
+#define LIB82596_DMA_ATTR	0
 #define DMA_WBACK(priv, addr, len)     do { } while (0)
 #define DMA_INV(priv, addr, len)       do { } while (0)
 #define DMA_WBACK_INV(priv, addr, len) do { } while (0)
 	unregister_netdev(dev);
 	dma_free_attrs(dev->dev.parent, sizeof(struct i596_private), lp->dma,
-		       lp->dma_addr, DMA_ATTR_NON_CONSISTENT);
+		       lp->dma_addr, LIB82596_DMA_ATTR);
 	iounmap(lp->ca);
 	iounmap(lp->mpu_port);
 	free_netdev (dev);

drivers/net/ethernet/ibm/ibmvnic.c+3−5

 	if (test_bit(0, &adapter->resetting) &&
 	    adapter->reset_reason == VNIC_RESET_MOBILITY) {
-		u64 val = (0xff000000) | scrq->hw_irq;
+		struct irq_desc *desc = irq_to_desc(scrq->irq);
+		struct irq_chip *chip = irq_desc_get_chip(desc);
-		rc = plpar_hcall_norets(H_EOI, val);
+		chip->irq_eoi(&desc->irq_data);
-		if (rc)
-			dev_err(dev, "H_EOI FAILED irq 0x%llx. rc=%ld\n",
-				val, rc);
 	}
 	rc = plpar_hcall_norets(H_VIOCTL, adapter->vdev->unit_address,

drivers/net/ethernet/mediatek/mtk_eth_soc.c+1−0

@@ -261,6 +261,7 @@ static void mtk_mac_config(struct phylink_config *config, unsigned int mode, · 260 unmodified lines
261	ge_mode = 0;	261	ge_mode = 0;
262	switch (state->interface) {	262	switch (state->interface) {
263	case PHY_INTERFACE_MODE_MII:	263	case PHY_INTERFACE_MODE_MII:
		264	case PHY_INTERFACE_MODE_GMII:
264	ge_mode = 1;	265	ge_mode = 1;
265	break;	266	break;
266	case PHY_INTERFACE_MODE_REVMII:	267	case PHY_INTERFACE_MODE_REVMII:

drivers/net/ethernet/mellanox/mlx5/core/mr.c+1−7

 	u32 out[MLX5_ST_SZ_DW(destroy_mkey_out)] = {0};
 	u32 in[MLX5_ST_SZ_DW(destroy_mkey_in)]   = {0};
 	struct xarray *mkeys = &dev->priv.mkey_table;
-	struct mlx5_core_mkey *deleted_mkey;
 	unsigned long flags;
 	xa_lock_irqsave(mkeys, flags);
-	deleted_mkey = __xa_erase(mkeys, mlx5_base_mkey(mkey->key));
+	__xa_erase(mkeys, mlx5_base_mkey(mkey->key));
 	xa_unlock_irqrestore(mkeys, flags);
-	if (!deleted_mkey) {
-		mlx5_core_dbg(dev, "failed xarray delete of mkey 0x%x\n",
-			      mlx5_base_mkey(mkey->key));
-		return -ENOENT;
-	}
 	MLX5_SET(destroy_mkey_in, in, opcode, MLX5_CMD_OP_DESTROY_MKEY);
 	MLX5_SET(destroy_mkey_in, in, mkey_index, mlx5_mkey_to_idx(mkey->key));

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c+4−6

@@ -788,12 +788,10 @@ again: · 787 unmodified lines
788	* it means that all the previous stes are the same,	788	* it means that all the previous stes are the same,
789	* if so, this rule is duplicated.	789	* if so, this rule is duplicated.
790	*/	790	*/
791	if (mlx5dr_ste_is_last_in_rule(nic_matcher,	791	if (!mlx5dr_ste_is_last_in_rule(nic_matcher, ste_location))
792	matched_ste->ste_chain_location)) {	792	return matched_ste;
793	mlx5dr_info(dmn, "Duplicate rule inserted, aborting!!\n");	793
794	return NULL;	794	mlx5dr_dbg(dmn, "Duplicate rule inserted\n");
795	}
796	return matched_ste;
797	}	795	}
798		796
799	if (!skip_rehash && dr_rule_need_enlarge_hash(cur_htbl, dmn, nic_dmn)) {	797	if (!skip_rehash && dr_rule_need_enlarge_hash(cur_htbl, dmn, nic_dmn)) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_trap.c+1−0

@@ -99,6 +99,7 @@ static void mlxsw_sp_rx_drop_listener(struct sk_buff *skb, u8 local_port, · 98 unmodified lines
99	devlink = priv_to_devlink(mlxsw_sp->core);	99	devlink = priv_to_devlink(mlxsw_sp->core);
100	in_devlink_port = mlxsw_core_port_devlink_port_get(mlxsw_sp->core,	100	in_devlink_port = mlxsw_core_port_devlink_port_get(mlxsw_sp->core,
101	local_port);	101	local_port);
		102	skb_push(skb, ETH_HLEN);
102	devlink_trap_report(devlink, skb, trap_ctx, in_devlink_port);	103	devlink_trap_report(devlink, skb, trap_ctx, in_devlink_port);
103	consume_skb(skb);	104	consume_skb(skb);
104	}	105	}

drivers/net/ethernet/nxp/lpc_eth.c+0−3

@@ -1356,9 +1356,6 @@ static int lpc_eth_drv_probe(struct platform_device *pdev) · 1355 unmodified lines
1356	if (!is_valid_ether_addr(ndev->dev_addr))	1356	if (!is_valid_ether_addr(ndev->dev_addr))
1357	eth_hw_addr_random(ndev);	1357	eth_hw_addr_random(ndev);
1358		1358
1359	/* Reset the ethernet controller */
1360	__lpc_eth_reset(pldat);
1361
1362	/* then shut everything down to save power */	1359	/* then shut everything down to save power */
1363	__lpc_eth_shutdown(pldat);	1360	__lpc_eth_shutdown(pldat);
1364		1361

drivers/net/ethernet/pensando/ionic/ionic_lif.h+2−0

@@ -182,6 +182,8 @@ struct ionic_lif { · 181 unmodified lines
182		182
183	#define lif_to_txqcq(lif, i) ((lif)->txqcqs[i].qcq)	183	#define lif_to_txqcq(lif, i) ((lif)->txqcqs[i].qcq)
184	#define lif_to_rxqcq(lif, i) ((lif)->rxqcqs[i].qcq)	184	#define lif_to_rxqcq(lif, i) ((lif)->rxqcqs[i].qcq)
		185	#define lif_to_txstats(lif, i) ((lif)->txqcqs[i].stats->tx)
		186	#define lif_to_rxstats(lif, i) ((lif)->rxqcqs[i].stats->rx)
185	#define lif_to_txq(lif, i) (&lif_to_txqcq((lif), i)->q)	187	#define lif_to_txq(lif, i) (&lif_to_txqcq((lif), i)->q)
186	#define lif_to_rxq(lif, i) (&lif_to_txqcq((lif), i)->q)	188	#define lif_to_rxq(lif, i) (&lif_to_txqcq((lif), i)->q)
187		189

drivers/net/ethernet/pensando/ionic/ionic_stats.c+19−10

 	/* rx stats */
 	total += MAX_Q(lif) * IONIC_NUM_RX_STATS;
-	if (test_bit(IONIC_LIF_SW_DEBUG_STATS, lif->state)) {
+	if (test_bit(IONIC_LIF_UP, lif->state) &&
+	    test_bit(IONIC_LIF_SW_DEBUG_STATS, lif->state)) {
 		/* tx debug stats */
 		total += MAX_Q(lif) * (IONIC_NUM_DBG_CQ_STATS +
 				      IONIC_NUM_TX_Q_STATS +
 			*buf += ETH_GSTRING_LEN;
 		}
-		if (test_bit(IONIC_LIF_SW_DEBUG_STATS, lif->state)) {
+		if (test_bit(IONIC_LIF_UP, lif->state) &&
+		    test_bit(IONIC_LIF_SW_DEBUG_STATS, lif->state)) {
 			for (i = 0; i < IONIC_NUM_TX_Q_STATS; i++) {
 				snprintf(*buf, ETH_GSTRING_LEN,
 					 "txq_%d_%s",
 			*buf += ETH_GSTRING_LEN;
 		}
-		if (test_bit(IONIC_LIF_SW_DEBUG_STATS, lif->state)) {
+		if (test_bit(IONIC_LIF_UP, lif->state) &&
+		    test_bit(IONIC_LIF_SW_DEBUG_STATS, lif->state)) {
 			for (i = 0; i < IONIC_NUM_DBG_CQ_STATS; i++) {
 				snprintf(*buf, ETH_GSTRING_LEN,
 					 "rxq_%d_cq_%s",
 {
 	struct ionic_lif_sw_stats lif_stats;
 	struct ionic_qcq *txqcq, *rxqcq;
+	struct ionic_tx_stats *txstats;
+	struct ionic_rx_stats *rxstats;
 	int i, q_num;
 	ionic_get_lif_stats(lif, &lif_stats);
 	}
 	for (q_num = 0; q_num < MAX_Q(lif); q_num++) {
-		txqcq = lif_to_txqcq(lif, q_num);
+		txstats = &lif_to_txstats(lif, q_num);
 		for (i = 0; i < IONIC_NUM_TX_STATS; i++) {
-			**buf = IONIC_READ_STAT64(&txqcq->stats->tx,
+			**buf = IONIC_READ_STAT64(txstats,
 						  &ionic_tx_stats_desc[i]);
 			(*buf)++;
 		}
-		if (test_bit(IONIC_LIF_SW_DEBUG_STATS, lif->state)) {
+		if (test_bit(IONIC_LIF_UP, lif->state) &&
+		    test_bit(IONIC_LIF_SW_DEBUG_STATS, lif->state)) {
+			txqcq = lif_to_txqcq(lif, q_num);
 			for (i = 0; i < IONIC_NUM_TX_Q_STATS; i++) {
 				**buf = IONIC_READ_STAT64(&txqcq->q,
 						      &ionic_txq_stats_desc[i]);
 				(*buf)++;
 			}
 			for (i = 0; i < IONIC_MAX_NUM_SG_CNTR; i++) {
-				**buf = txqcq->stats->tx.sg_cntr[i];
+				**buf = txstats->sg_cntr[i];
 				(*buf)++;
 			}
 		}
 	}
 	for (q_num = 0; q_num < MAX_Q(lif); q_num++) {
-		rxqcq = lif_to_rxqcq(lif, q_num);
+		rxstats = &lif_to_rxstats(lif, q_num);
 		for (i = 0; i < IONIC_NUM_RX_STATS; i++) {
-			**buf = IONIC_READ_STAT64(&rxqcq->stats->rx,
+			**buf = IONIC_READ_STAT64(rxstats,
 						  &ionic_rx_stats_desc[i]);
 			(*buf)++;
 		}
-		if (test_bit(IONIC_LIF_SW_DEBUG_STATS, lif->state)) {
+		if (test_bit(IONIC_LIF_UP, lif->state) &&
+		    test_bit(IONIC_LIF_SW_DEBUG_STATS, lif->state)) {
+			rxqcq = lif_to_rxqcq(lif, q_num);
 			for (i = 0; i < IONIC_NUM_DBG_CQ_STATS; i++) {
 				**buf = IONIC_READ_STAT64(&rxqcq->cq,
 						   &ionic_dbg_cq_stats_desc[i]);

drivers/net/ethernet/realtek/r8169_main.c+11−24

 	rtl_lock_config_regs(tp);
 }
+static void rtl_jumbo_config(struct rtl8169_private *tp, int mtu)
+{
+	if (mtu > ETH_DATA_LEN)
+		rtl_hw_jumbo_enable(tp);
+	else
+		rtl_hw_jumbo_disable(tp);
+}
 DECLARE_RTL_COND(rtl_chipcmd_cond)
 {
 	return RTL_R8(tp, ChipCmd) & CmdReset;
 static void rtl_hw_start_8168bb(struct rtl8169_private *tp)
 {
 	RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en);
-	if (tp->dev->mtu <= ETH_DATA_LEN) {
-		rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B |
-					 PCI_EXP_DEVCTL_NOSNOOP_EN);
-	}
 }
 static void rtl_hw_start_8168bef(struct rtl8169_private *tp)
 	RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en);
-	if (tp->dev->mtu <= ETH_DATA_LEN)
-		rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B);
 	rtl_disable_clock_request(tp);
 }
 	rtl_set_def_aspm_entry_latency(tp);
 	RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en);
-	if (tp->dev->mtu <= ETH_DATA_LEN)
-		rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B);
 }
 static void rtl_hw_start_8168cp_3(struct rtl8169_private *tp)
 	/* Magic. */
 	RTL_W8(tp, DBG_REG, 0x20);
-	if (tp->dev->mtu <= ETH_DATA_LEN)
-		rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B);
 }
 static void rtl_hw_start_8168c_1(struct rtl8169_private *tp)
 	rtl_ephy_init(tp, e_info_8168e_1);
-	if (tp->dev->mtu <= ETH_DATA_LEN)
-		rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B);
 	rtl_disable_clock_request(tp);
 	/* Reset tx FIFO pointer */
 	rtl_ephy_init(tp, e_info_8168e_2);
-	if (tp->dev->mtu <= ETH_DATA_LEN)
-		rtl_tx_performance_tweak(tp, PCI_EXP_DEVCTL_READRQ_4096B);
 	rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000);
 	rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000);
 	rtl_set_fifo_size(tp, 0x10, 0x10, 0x02, 0x06);
 	rtl_set_rx_tx_desc_registers(tp);
 	rtl_lock_config_regs(tp);
+	rtl_jumbo_config(tp, tp->dev->mtu);
 	/* Initially a 10 us delay. Turned it into a PCI commit. - FR */
 	RTL_R16(tp, CPlusCmd);
 	RTL_W8(tp, ChipCmd, CmdTxEnb | CmdRxEnb);
 {
 	struct rtl8169_private *tp = netdev_priv(dev);
-	if (new_mtu > ETH_DATA_LEN)
+	rtl_jumbo_config(tp, new_mtu);
-		rtl_hw_jumbo_enable(tp);
-	else
-		rtl_hw_jumbo_disable(tp);
 	dev->mtu = new_mtu;
 	netdev_update_features(dev);

drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c+2−1

@@ -651,7 +651,8 @@ static void sun8i_dwmac_set_filter(struct mac_device_info *hw, · 650 unmodified lines
651	}	651	}
652	}	652	}
653	} else {	653	} else {
654	netdev_info(dev, "Too many address, switching to promiscuous\n");	654	if (!(readl(ioaddr + EMAC_RX_FRM_FLT) & EMAC_FRM_FLT_RXALL))
		655	netdev_info(dev, "Too many address, switching to promiscuous\n");
655	v = EMAC_FRM_FLT_RXALL;	656	v = EMAC_FRM_FLT_RXALL;
656	}	657	}
657		658

drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c+1−1

@@ -448,7 +448,7 @@ static void dwmac4_set_filter(struct mac_device_info *hw, · 447 unmodified lines
448	value \|= GMAC_PACKET_FILTER_HPF;	448	value \|= GMAC_PACKET_FILTER_HPF;
449		449
450	/* Handle multiple unicast addresses */	450	/* Handle multiple unicast addresses */
451	if (netdev_uc_count(dev) > GMAC_MAX_PERFECT_ADDRESSES) {	451	if (netdev_uc_count(dev) > hw->unicast_filter_entries) {
452	/* Switch to promiscuous mode if more than 128 addrs	452	/* Switch to promiscuous mode if more than 128 addrs
453	* are required	453	* are required
454	*/	454	*/

drivers/net/ethernet/stmicro/stmmac/dwmac5.c+1−0

@@ -515,6 +515,7 @@ int dwmac5_flex_pps_config(void __iomem *ioaddr, int index, · 514 unmodified lines
515		515
516	if (!enable) {	516	if (!enable) {
517	val \|= PPSCMDx(index, 0x5);	517	val \|= PPSCMDx(index, 0x5);
		518	val \|= PPSEN0;
518	writel(val, ioaddr + MAC_PPS_CONTROL);	519	writel(val, ioaddr + MAC_PPS_CONTROL);
519	return 0;	520	return 0;
520	}	521	}

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+9−5

 	}
 	if (priv->hw->pcs)
-		stmmac_pcs_ctrl_ane(priv, priv->hw, 1, priv->hw->ps, 0);
+		stmmac_pcs_ctrl_ane(priv, priv->ioaddr, 1, priv->hw->ps, 0);
 	/* set TX and RX rings length */
 	stmmac_set_rings_length(priv);
 		stmmac_mac_set(priv, priv->ioaddr, false);
 		pinctrl_pm_select_sleep_state(priv->device);
 		/* Disable clock in case of PWM is off */
-		clk_disable(priv->plat->pclk);
+		if (priv->plat->clk_ptp_ref)
-		clk_disable(priv->plat->stmmac_clk);
+			clk_disable_unprepare(priv->plat->clk_ptp_ref);
+		clk_disable_unprepare(priv->plat->pclk);
+		clk_disable_unprepare(priv->plat->stmmac_clk);
 	}
 	mutex_unlock(&priv->lock);
 	} else {
 		pinctrl_pm_select_default_state(priv->device);
 		/* enable the clk previously disabled */
-		clk_enable(priv->plat->stmmac_clk);
+		clk_prepare_enable(priv->plat->stmmac_clk);
-		clk_enable(priv->plat->pclk);
+		clk_prepare_enable(priv->plat->pclk);
+		if (priv->plat->clk_ptp_ref)
+			clk_prepare_enable(priv->plat->clk_ptp_ref);
 		/* reset the phy so that it's ready */
 		if (priv->mii)
 			stmmac_mdio_reset(priv->mii);

drivers/net/ethernet/stmicro/stmmac/stmmac_ptp.c+1−1

@@ -164,7 +164,7 @@ static int stmmac_enable(struct ptp_clock_info *ptp, · 163 unmodified lines
164	/* structure describing a PTP hardware clock */	164	/* structure describing a PTP hardware clock */
165	static struct ptp_clock_info stmmac_ptp_clock_ops = {	165	static struct ptp_clock_info stmmac_ptp_clock_ops = {
166	.owner = THIS_MODULE,	166	.owner = THIS_MODULE,
167	.name = "stmmac_ptp_clock",	167	.name = "stmmac ptp",
168	.max_adj = 62500000,	168	.max_adj = 62500000,
169	.n_alarm = 0,	169	.n_alarm = 0,
170	.n_ext_ts = 0,	170	.n_ext_ts = 0,

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c+9−2

 static int stmmac_test_hfilt(struct stmmac_priv *priv)
 {
-	unsigned char gd_addr[ETH_ALEN] = {0x01, 0x00, 0xcc, 0xcc, 0xdd, 0xdd};
+	unsigned char gd_addr[ETH_ALEN] = {0x01, 0xee, 0xdd, 0xcc, 0xbb, 0xaa};
-	unsigned char bd_addr[ETH_ALEN] = {0x09, 0x00, 0xaa, 0xaa, 0xbb, 0xbb};
+	unsigned char bd_addr[ETH_ALEN] = {0x01, 0x01, 0x02, 0x03, 0x04, 0x05};
 	struct stmmac_packet_attrs attr = { };
 	int ret;
 	if (ret)
 		return ret;
+	if (netdev_mc_count(priv->dev) >= priv->hw->multicast_filter_bins)
+		return -EOPNOTSUPP;
 	ret = dev_mc_add(priv->dev, gd_addr);
 	if (ret)
 		return ret;
 	if (stmmac_filter_check(priv))
 		return -EOPNOTSUPP;
+	if (!priv->hw->multicast_filter_bins)
+		return -EOPNOTSUPP;
 	/* Remove all MC addresses */
 	__dev_mc_unsync(priv->dev, NULL);
 	if (stmmac_filter_check(priv))
 		return -EOPNOTSUPP;
+	if (!priv->hw->multicast_filter_bins)
+		return -EOPNOTSUPP;
 	/* Remove all UC addresses */
 	__dev_uc_unsync(priv->dev, NULL);

drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c+1−1

@@ -510,7 +510,7 @@ static struct stmmac_flow_entry tc_find_flow(struct stmmac_priv priv, · 509 unmodified lines
510	return NULL;	510	return NULL;
511	}	511	}
512		512
513	struct {	513	static struct {
514	int (fn)(struct stmmac_priv priv, struct flow_cls_offload *cls,	514	int (fn)(struct stmmac_priv priv, struct flow_cls_offload *cls,
515	struct stmmac_flow_entry *entry);	515	struct stmmac_flow_entry *entry);
516	} tc_flow_parsers[] = {	516	} tc_flow_parsers[] = {

drivers/net/ethernet/ti/davinci_cpdma.c+1−1

@@ -722,7 +722,7 @@ static void cpdma_chan_set_descs(struct cpdma_ctlr *ctlr, · 721 unmodified lines
722	* cpdma_chan_split_pool - Splits ctrl pool between all channels.	722	* cpdma_chan_split_pool - Splits ctrl pool between all channels.
723	* Has to be called under ctlr lock	723	* Has to be called under ctlr lock
724	*/	724	*/
725	int cpdma_chan_split_pool(struct cpdma_ctlr *ctlr)	725	static int cpdma_chan_split_pool(struct cpdma_ctlr *ctlr)
726	{	726	{
727	int tx_per_ch_desc = 0, rx_per_ch_desc = 0;	727	int tx_per_ch_desc = 0, rx_per_ch_desc = 0;
728	int free_rx_num = 0, free_tx_num = 0;	728	int free_rx_num = 0, free_tx_num = 0;

drivers/net/netdevsim/fib.c+2−1

 void nsim_fib_exit(void)
 {
-	unregister_pernet_subsys(&nsim_fib_net_ops);
 	unregister_fib_notifier(&nsim_fib_nb);
+	unregister_pernet_subsys(&nsim_fib_net_ops);
 }
 int nsim_fib_init(void)
 	err = register_fib_notifier(&nsim_fib_nb, nsim_fib_dump_inconsistent);
 	if (err < 0) {
 		pr_err("Failed to register fib notifier\n");
+		unregister_pernet_subsys(&nsim_fib_net_ops);
 		goto err_out;
 	}

drivers/net/phy/bcm7xxx.c+1−0

@@ -572,6 +572,7 @@ static int bcm7xxx_28nm_probe(struct phy_device *phydev) · 571 unmodified lines
572	.name = _name, \	572	.name = _name, \
573	/* PHY_BASIC_FEATURES */ \	573	/* PHY_BASIC_FEATURES */ \
574	.flags = PHY_IS_INTERNAL, \	574	.flags = PHY_IS_INTERNAL, \
		575	.soft_reset = genphy_soft_reset, \
575	.config_init = bcm7xxx_config_init, \	576	.config_init = bcm7xxx_config_init, \
576	.suspend = bcm7xxx_suspend, \	577	.suspend = bcm7xxx_suspend, \
577	.resume = bcm7xxx_config_init, \	578	.resume = bcm7xxx_config_init, \

drivers/net/phy/micrel.c+37−5

 	return genphy_config_aneg(phydev);
 }
+static int ksz8051_ksz8795_match_phy_device(struct phy_device *phydev,
+					    const u32 ksz_phy_id)
+{
+	int ret;
+	if ((phydev->phy_id & MICREL_PHY_ID_MASK) != ksz_phy_id)
+		return 0;
+	ret = phy_read(phydev, MII_BMSR);
+	if (ret < 0)
+		return ret;
+	/* KSZ8051 PHY and KSZ8794/KSZ8795/KSZ8765 switch share the same
+	 * exact PHY ID. However, they can be told apart by the extended
+	 * capability registers presence. The KSZ8051 PHY has them while
+	 * the switch does not.
+	 */
+	ret &= BMSR_ERCAP;
+	if (ksz_phy_id == PHY_ID_KSZ8051)
+		return ret;
+	else
+		return !ret;
+}
+static int ksz8051_match_phy_device(struct phy_device *phydev)
+{
+	return ksz8051_ksz8795_match_phy_device(phydev, PHY_ID_KSZ8051);
+}
 static int ksz8081_config_init(struct phy_device *phydev)
 {
 	/* KSZPHY_OMSO_FACTORY_TEST is set at de-assertion of the reset line
 	return kszphy_config_init(phydev);
 }
+static int ksz8795_match_phy_device(struct phy_device *phydev)
+{
+	return ksz8051_ksz8795_match_phy_device(phydev, PHY_ID_KSZ87XX);
+}
 static int ksz9021_load_values_from_of(struct phy_device *phydev,
 				       const struct device_node *of_node,
 				       u16 reg,
 	.suspend	= genphy_suspend,
 	.resume		= genphy_resume,
 }, {
-	.phy_id		= PHY_ID_KSZ8051,
-	.phy_id_mask	= MICREL_PHY_ID_MASK,
 	.name		= "Micrel KSZ8051",
 	/* PHY_BASIC_FEATURES */
 	.driver_data	= &ksz8051_type,
 	.get_sset_count = kszphy_get_sset_count,
 	.get_strings	= kszphy_get_strings,
 	.get_stats	= kszphy_get_stats,
+	.match_phy_device = ksz8051_match_phy_device,
 	.suspend	= genphy_suspend,
 	.resume		= genphy_resume,
 }, {
 	.suspend	= genphy_suspend,
 	.resume		= genphy_resume,
 }, {
-	.phy_id		= PHY_ID_KSZ8795,
+	.name		= "Micrel KSZ87XX Switch",
-	.phy_id_mask	= MICREL_PHY_ID_MASK,
-	.name		= "Micrel KSZ8795",
 	/* PHY_BASIC_FEATURES */
 	.config_init	= kszphy_config_init,
 	.config_aneg	= ksz8873mll_config_aneg,
 	.read_status	= ksz8873mll_read_status,
+	.match_phy_device = ksz8795_match_phy_device,
 	.suspend	= genphy_suspend,
 	.resume		= genphy_resume,
 }, {

drivers/net/phy/phy-c45.c+2−0

@@ -323,6 +323,8 @@ int genphy_c45_read_pma(struct phy_device *phydev) · 322 unmodified lines
323	{	323	{
324	int val;	324	int val;
325		325
		326	linkmode_zero(phydev->lp_advertising);
		327
326	val = phy_read_mmd(phydev, MDIO_MMD_PMAPMD, MDIO_CTRL1);	328	val = phy_read_mmd(phydev, MDIO_MMD_PMAPMD, MDIO_CTRL1);
327	if (val < 0)	329	if (val < 0)
328	return val;	330	return val;

drivers/net/phy/phy.c+0−3

@@ -572,9 +572,6 @@ int phy_start_aneg(struct phy_device *phydev) · 571 unmodified lines
572	if (AUTONEG_DISABLE == phydev->autoneg)	572	if (AUTONEG_DISABLE == phydev->autoneg)
573	phy_sanitize_settings(phydev);	573	phy_sanitize_settings(phydev);
574		574
575	/* Invalidate LP advertising flags */
576	linkmode_zero(phydev->lp_advertising);
577
578	err = phy_config_aneg(phydev);	575	err = phy_config_aneg(phydev);
579	if (err < 0)	576	if (err < 0)
580	goto out_unlock;	577	goto out_unlock;

drivers/net/phy/phy_device.c+10−1

 {
 	int lpa, lpagb;
-	if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
+	if (phydev->autoneg == AUTONEG_ENABLE) {
+		if (!phydev->autoneg_complete) {
+			mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
+							0);
+			mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
+			return 0;
+		}
 		if (phydev->is_gigabit_capable) {
 			lpagb = phy_read(phydev, MII_STAT1000);
 			if (lpagb < 0)
 			return lpa;
 		mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
+	} else {
+		linkmode_zero(phydev->lp_advertising);
 	}
 	return 0;

drivers/net/phy/phylink.c+1−1

@@ -576,7 +576,7 @@ static int phylink_register_sfp(struct phylink *pl, · 575 unmodified lines
576		576
577	/**	577	/**
578	* phylink_create() - create a phylink instance	578	* phylink_create() - create a phylink instance
579	* @ndev: a pointer to the &struct net_device	579	* @config: a pointer to the target &struct phylink_config
580	* @fwnode: a pointer to a &struct fwnode_handle describing the network	580	* @fwnode: a pointer to a &struct fwnode_handle describing the network
581	* interface	581	* interface
582	* @iface: the desired link mode defined by &typedef phy_interface_t	582	* @iface: the desired link mode defined by &typedef phy_interface_t

drivers/net/tun.c+2−2

@@ -526,8 +526,8 @@ static void tun_flow_update(struct tun_struct *tun, u32 rxhash, · 525 unmodified lines
526	e = tun_flow_find(head, rxhash);	526	e = tun_flow_find(head, rxhash);
527	if (likely(e)) {	527	if (likely(e)) {
528	/* TODO: keep queueing to old queue until it's empty? */	528	/* TODO: keep queueing to old queue until it's empty? */
529	if (e->queue_index != queue_index)	529	if (READ_ONCE(e->queue_index) != queue_index)
530	e->queue_index = queue_index;	530	WRITE_ONCE(e->queue_index, queue_index);
531	if (e->updated != jiffies)	531	if (e->updated != jiffies)
532	e->updated = jiffies;	532	e->updated = jiffies;
533	sock_rps_record_flow_hash(e->rps_rxhash);	533	sock_rps_record_flow_hash(e->rps_rxhash);

drivers/net/usb/hso.c+9−4

 	int    intr_completed;
 	struct usb_endpoint_descriptor *endp;
 	struct urb *urb;
-	struct hso_serial_state_notification serial_state_notification;
+	struct hso_serial_state_notification *serial_state_notification;
 	u16    prev_UART_state_bitmap;
 	struct uart_icount icount;
 };
 			 usb_rcvintpipe(usb,
 					tiocmget->endp->
 					bEndpointAddress & 0x7F),
-			 &tiocmget->serial_state_notification,
+			 tiocmget->serial_state_notification,
 			 sizeof(struct hso_serial_state_notification),
 			 tiocmget_intr_callback, serial,
 			 tiocmget->endp->bInterval);
 	/* wIndex should be the USB interface number of the port to which the
 	 * notification applies, which should always be the Modem port.
 	 */
-	serial_state_notification = &tiocmget->serial_state_notification;
+	serial_state_notification = tiocmget->serial_state_notification;
 	if (serial_state_notification->bmRequestType != BM_REQUEST_TYPE ||
 	    serial_state_notification->bNotification != B_NOTIFICATION ||
 	    le16_to_cpu(serial_state_notification->wValue) != W_VALUE ||
 		usb_free_urb(tiocmget->urb);
 		tiocmget->urb = NULL;
 		serial->tiocmget = NULL;
+		kfree(tiocmget->serial_state_notification);
+		tiocmget->serial_state_notification = NULL;
 		kfree(tiocmget);
 	}
 }
 		num_urbs = 2;
 		serial->tiocmget = kzalloc(sizeof(struct hso_tiocmget),
 					   GFP_KERNEL);
+		serial->tiocmget->serial_state_notification
+			= kzalloc(sizeof(struct hso_serial_state_notification),
+					   GFP_KERNEL);
 		/* it isn't going to break our heart if serial->tiocmget
 		 *  allocation fails don't bother checking this.
 		 */
-		if (serial->tiocmget) {
+		if (serial->tiocmget && serial->tiocmget->serial_state_notification) {
 			tiocmget = serial->tiocmget;
 			tiocmget->endp = hso_get_ep(interface,
 						    USB_ENDPOINT_XFER_INT,

drivers/net/usb/lan78xx.c+6−6

 	/* driver requires remote-wakeup capability during autosuspend. */
 	intf->needs_remote_wakeup = 1;
+	ret = lan78xx_phy_init(dev);
+	if (ret < 0)
+		goto out4;
 	ret = register_netdev(netdev);
 	if (ret != 0) {
 		netif_err(dev, probe, netdev, "couldn't register the device\n");
-		goto out4;
+		goto out5;
 	}
 	usb_set_intfdata(intf, dev);
 	pm_runtime_set_autosuspend_delay(&udev->dev,
 					 DEFAULT_AUTOSUSPEND_DELAY);
-	ret = lan78xx_phy_init(dev);
-	if (ret < 0)
-		goto out5;
 	return 0;
 out5:
-	unregister_netdev(netdev);
+	phy_disconnect(netdev->phydev);
 out4:
 	usb_free_urb(dev->urb_intr);
 out3:

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

@@ -1327,6 +1327,7 @@ static const struct usb_device_id products[] = { · 1326 unmodified lines
1327	{QMI_FIXED_INTF(0x2357, 0x0201, 4)}, /* TP-LINK HSUPA Modem MA180 */	1327	{QMI_FIXED_INTF(0x2357, 0x0201, 4)}, /* TP-LINK HSUPA Modem MA180 */
1328	{QMI_FIXED_INTF(0x2357, 0x9000, 4)}, /* TP-LINK MA260 */	1328	{QMI_FIXED_INTF(0x2357, 0x9000, 4)}, /* TP-LINK MA260 */
1329	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1040, 2)}, /* Telit LE922A */	1329	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1040, 2)}, /* Telit LE922A */
		1330	{QMI_QUIRK_SET_DTR(0x1bc7, 0x1050, 2)}, /* Telit FN980 */
1330	{QMI_FIXED_INTF(0x1bc7, 0x1100, 3)}, /* Telit ME910 */	1331	{QMI_FIXED_INTF(0x1bc7, 0x1100, 3)}, /* Telit ME910 */
1331	{QMI_FIXED_INTF(0x1bc7, 0x1101, 3)}, /* Telit ME910 dual modem */	1332	{QMI_FIXED_INTF(0x1bc7, 0x1101, 3)}, /* Telit ME910 dual modem */
1332	{QMI_FIXED_INTF(0x1bc7, 0x1200, 5)}, /* Telit LE920 */	1333	{QMI_FIXED_INTF(0x1bc7, 0x1200, 5)}, /* Telit LE920 */

drivers/net/usb/sr9800.c+1−1

@@ -335,7 +335,7 @@ static void sr_set_multicast(struct net_device *net) · 334 unmodified lines
335	static int sr_mdio_read(struct net_device *net, int phy_id, int loc)	335	static int sr_mdio_read(struct net_device *net, int phy_id, int loc)
336	{	336	{
337	struct usbnet *dev = netdev_priv(net);	337	struct usbnet *dev = netdev_priv(net);
338	__le16 res;	338	__le16 res = 0;
339		339
340	mutex_lock(&dev->phy_mutex);	340	mutex_lock(&dev->phy_mutex);
341	sr_set_sw_mii(dev);	341	sr_set_sw_mii(dev);

drivers/net/wireless/ath/ath10k/core.c+9−6

@@ -2118,12 +2118,15 @@ static int ath10k_init_uart(struct ath10k *ar) · 2117 unmodified lines
2118	return ret;	2118	return ret;
2119	}	2119	}
2120		2120
2121	if (!uart_print && ar->hw_params.uart_pin_workaround) {	2121	if (!uart_print) {
2122	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin,	2122	if (ar->hw_params.uart_pin_workaround) {
2123	ar->hw_params.uart_pin);	2123	ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin,
2124	if (ret) {	2124	ar->hw_params.uart_pin);
2125	ath10k_warn(ar, "failed to set UART TX pin: %d", ret);	2125	if (ret) {
2126	return ret;	2126	ath10k_warn(ar, "failed to set UART TX pin: %d",
		2127	ret);
		2128	return ret;
		2129	}
2127	}	2130	}
2128		2131
2129	return 0;	2132	return 0;

drivers/net/wireless/intel/iwlwifi/fw/acpi.c+6−4

 	wifi_pkg = iwl_acpi_get_wifi_pkg(dev, data, ACPI_WRDD_WIFI_DATA_SIZE,
 					 &tbl_rev);
-	if (IS_ERR(wifi_pkg) || tbl_rev != 0) {
+	if (IS_ERR(wifi_pkg)) {
 		ret = PTR_ERR(wifi_pkg);
 		goto out_free;
 	}
-	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
+	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER ||
+	    tbl_rev != 0) {
 		ret = -EINVAL;
 		goto out_free;
 	}
 	wifi_pkg = iwl_acpi_get_wifi_pkg(dev, data, ACPI_ECKV_WIFI_DATA_SIZE,
 					 &tbl_rev);
-	if (IS_ERR(wifi_pkg) || tbl_rev != 0) {
+	if (IS_ERR(wifi_pkg)) {
 		ret = PTR_ERR(wifi_pkg);
 		goto out_free;
 	}
-	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
+	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER ||
+	    tbl_rev != 0) {
 		ret = -EINVAL;
 		goto out_free;
 	}

drivers/net/wireless/intel/iwlwifi/fw/dbg.c+1−0

@@ -646,6 +646,7 @@ static struct scatterlist *alloc_sgtable(int size) · 645 unmodified lines
646	if (new_page)	646	if (new_page)
647	__free_page(new_page);	647	__free_page(new_page);
648	}	648	}
		649	kfree(table);
649	return NULL;	650	return NULL;
650	}	651	}
651	alloc_size = min_t(int, size, PAGE_SIZE);	652	alloc_size = min_t(int, size, PAGE_SIZE);

drivers/net/wireless/intel/iwlwifi/iwl-io.h+6−6

@@ -112,38 +112,38 @@ int iwl_dump_fh(struct iwl_trans trans, char *buf); · 111 unmodified lines
112	*/	112	*/
113	static inline u32 iwl_umac_prph(struct iwl_trans *trans, u32 ofs)	113	static inline u32 iwl_umac_prph(struct iwl_trans *trans, u32 ofs)
114	{	114	{
115	return ofs + trans->cfg->trans.umac_prph_offset;	115	return ofs + trans->trans_cfg->umac_prph_offset;
116	}	116	}
117		117
118	static inline u32 iwl_read_umac_prph_no_grab(struct iwl_trans *trans, u32 ofs)	118	static inline u32 iwl_read_umac_prph_no_grab(struct iwl_trans *trans, u32 ofs)
119	{	119	{
120	return iwl_read_prph_no_grab(trans, ofs +	120	return iwl_read_prph_no_grab(trans, ofs +
121	trans->cfg->trans.umac_prph_offset);	121	trans->trans_cfg->umac_prph_offset);
122	}	122	}
123		123
124	static inline u32 iwl_read_umac_prph(struct iwl_trans *trans, u32 ofs)	124	static inline u32 iwl_read_umac_prph(struct iwl_trans *trans, u32 ofs)
125	{	125	{
126	return iwl_read_prph(trans, ofs + trans->cfg->trans.umac_prph_offset);	126	return iwl_read_prph(trans, ofs + trans->trans_cfg->umac_prph_offset);
127	}	127	}
128		128
129	static inline void iwl_write_umac_prph_no_grab(struct iwl_trans *trans, u32 ofs,	129	static inline void iwl_write_umac_prph_no_grab(struct iwl_trans *trans, u32 ofs,
130	u32 val)	130	u32 val)
131	{	131	{
132	iwl_write_prph_no_grab(trans, ofs + trans->cfg->trans.umac_prph_offset,	132	iwl_write_prph_no_grab(trans, ofs + trans->trans_cfg->umac_prph_offset,
133	val);	133	val);
134	}	134	}
135		135
136	static inline void iwl_write_umac_prph(struct iwl_trans *trans, u32 ofs,	136	static inline void iwl_write_umac_prph(struct iwl_trans *trans, u32 ofs,
137	u32 val)	137	u32 val)
138	{	138	{
139	iwl_write_prph(trans, ofs + trans->cfg->trans.umac_prph_offset, val);	139	iwl_write_prph(trans, ofs + trans->trans_cfg->umac_prph_offset, val);
140	}	140	}
141		141
142	static inline int iwl_poll_umac_prph_bit(struct iwl_trans *trans, u32 addr,	142	static inline int iwl_poll_umac_prph_bit(struct iwl_trans *trans, u32 addr,
143	u32 bits, u32 mask, int timeout)	143	u32 bits, u32 mask, int timeout)
144	{	144	{
145	return iwl_poll_prph_bit(trans, addr +	145	return iwl_poll_prph_bit(trans, addr +
146	trans->cfg->trans.umac_prph_offset,	146	trans->trans_cfg->umac_prph_offset,
147	bits, mask, timeout);	147	bits, mask, timeout);
148	}	148	}
149		149

drivers/net/wireless/intel/iwlwifi/mvm/fw.c+30−13

 	};
 	int ret;
+	if (mvm->trans->cfg->tx_with_siso_diversity)
+		init_cfg.init_flags |= cpu_to_le32(BIT(IWL_INIT_PHY));
 	lockdep_assert_held(&mvm->mutex);
 	mvm->rfkill_safe_init_done = false;
 	wifi_pkg = iwl_acpi_get_wifi_pkg(mvm->dev, data,
 					 ACPI_WRDS_WIFI_DATA_SIZE, &tbl_rev);
-	if (IS_ERR(wifi_pkg) || tbl_rev != 0) {
+	if (IS_ERR(wifi_pkg)) {
 		ret = PTR_ERR(wifi_pkg);
 		goto out_free;
 	}
-	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
+	if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER ||
+	    tbl_rev != 0) {
 		ret = -EINVAL;
 		goto out_free;
 	}
 	wifi_pkg = iwl_acpi_get_wifi_pkg(mvm->dev, data,
 					 ACPI_EWRD_WIFI_DATA_SIZE, &tbl_rev);
-	if (IS_ERR(wifi_pkg) || tbl_rev != 0) {
+	if (IS_ERR(wifi_pkg)) {
 		ret = PTR_ERR(wifi_pkg);
 		goto out_free;
 	}
 	if ((wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) ||
-	    (wifi_pkg->package.elements[2].type != ACPI_TYPE_INTEGER)) {
+	    (wifi_pkg->package.elements[2].type != ACPI_TYPE_INTEGER) ||
+	    tbl_rev != 0) {
 		ret = -EINVAL;
 		goto out_free;
 	}
 	wifi_pkg = iwl_acpi_get_wifi_pkg(mvm->dev, data,
 					 ACPI_WGDS_WIFI_DATA_SIZE, &tbl_rev);
-	if (IS_ERR(wifi_pkg) || tbl_rev > 1) {
+	if (IS_ERR(wifi_pkg)) {
 		ret = PTR_ERR(wifi_pkg);
 		goto out_free;
 	}
+	if (tbl_rev != 0) {
+		ret = -EINVAL;
+		goto out_free;
+	}
 	mvm->geo_rev = tbl_rev;
 	for (i = 0; i < ACPI_NUM_GEO_PROFILES; i++) {
 		for (j = 0; j < ACPI_GEO_TABLE_SIZE; j++) {
 	 * firmware versions.  Unfortunately, we don't have a TLV API
 	 * flag to rely on, so rely on the major version which is in
 	 * the first byte of ucode_ver.  This was implemented
-	 * initially on version 38 and then backported to29 and 17.
+	 * initially on version 38 and then backported to 17.  It was
-	 * The intention was to have it in 36 as well, but not all
+	 * also backported to 29, but only for 7265D devices.  The
-	 * 8000 family got this feature enabled.  The 8000 family is
+	 * intention was to have it in 36 as well, but not all 8000
-	 * the only one using version 36, so skip this version
+	 * family got this feature enabled.  The 8000 family is the
-	 * entirely.
+	 * only one using version 36, so skip this version entirely.
 	 */
 	return IWL_UCODE_SERIAL(mvm->fw->ucode_ver) >= 38 ||
-	       IWL_UCODE_SERIAL(mvm->fw->ucode_ver) == 29 ||
+	       IWL_UCODE_SERIAL(mvm->fw->ucode_ver) == 17 ||
-	       IWL_UCODE_SERIAL(mvm->fw->ucode_ver) == 17;
+	       (IWL_UCODE_SERIAL(mvm->fw->ucode_ver) == 29 &&
+		((mvm->trans->hw_rev & CSR_HW_REV_TYPE_MSK) ==
+		 CSR_HW_REV_TYPE_7265D));
 }
 int iwl_mvm_get_sar_geo_profile(struct iwl_mvm *mvm)
 	wifi_pkg = iwl_acpi_get_wifi_pkg(mvm->dev, data,
 					 ACPI_PPAG_WIFI_DATA_SIZE, &tbl_rev);
-	if (IS_ERR(wifi_pkg) || tbl_rev != 0) {
+	if (IS_ERR(wifi_pkg)) {
 		ret = PTR_ERR(wifi_pkg);
 		goto out_free;
 	}
+	if (tbl_rev != 0) {
+		ret = -EINVAL;
+		goto out_free;
+	}
 	enabled = &wifi_pkg->package.elements[1];
 	if (enabled->type != ACPI_TYPE_INTEGER ||
 	    (enabled->integer.value != 0 && enabled->integer.value != 1)) {

drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c+5−4

@@ -4881,11 +4881,11 @@ void iwl_mvm_sync_rx_queues_internal(struct iwl_mvm *mvm, · 4880 unmodified lines
4881	if (!iwl_mvm_has_new_rx_api(mvm))	4881	if (!iwl_mvm_has_new_rx_api(mvm))
4882	return;	4882	return;
4883		4883
4884	notif->cookie = mvm->queue_sync_cookie;	4884	if (notif->sync) {
4885		4885	notif->cookie = mvm->queue_sync_cookie;
4886	if (notif->sync)
4887	atomic_set(&mvm->queue_sync_counter,	4886	atomic_set(&mvm->queue_sync_counter,
4888	mvm->trans->num_rx_queues);	4887	mvm->trans->num_rx_queues);
		4888	}
4889		4889
4890	ret = iwl_mvm_notify_rx_queue(mvm, qmask, (u8 *)notif,	4890	ret = iwl_mvm_notify_rx_queue(mvm, qmask, (u8 *)notif,
4891	size, !notif->sync);	4891	size, !notif->sync);
@@ -4905,7 +4905,8 @@ void iwl_mvm_sync_rx_queues_internal(struct iwl_mvm *mvm, · 13 unmodified lines
4905		4905
4906	out:	4906	out:
4907	atomic_set(&mvm->queue_sync_counter, 0);	4907	atomic_set(&mvm->queue_sync_counter, 0);
4908	mvm->queue_sync_cookie++;	4908	if (notif->sync)
		4909	mvm->queue_sync_cookie++;
4909	}	4910	}
4910		4911
4911	static void iwl_mvm_sync_rx_queues(struct ieee80211_hw *hw)	4912	static void iwl_mvm_sync_rx_queues(struct ieee80211_hw *hw)

drivers/net/wireless/intel/iwlwifi/pcie/ctxt-info-gen3.c+25−11

@@ -107,13 +107,9 @@ int iwl_pcie_ctxt_info_gen3_init(struct iwl_trans *trans, · 106 unmodified lines
107		107
108	/* allocate ucode sections in dram and set addresses */	108	/* allocate ucode sections in dram and set addresses */
109	ret = iwl_pcie_init_fw_sec(trans, fw, &prph_scratch->dram);	109	ret = iwl_pcie_init_fw_sec(trans, fw, &prph_scratch->dram);
110	if (ret) {	110	if (ret)
111	dma_free_coherent(trans->dev,	111	goto err_free_prph_scratch;
112	sizeof(*prph_scratch),	112
113	prph_scratch,
114	trans_pcie->prph_scratch_dma_addr);
115	return ret;
116	}
117		113
118	/* Allocate prph information	114	/* Allocate prph information
119	* currently we don't assign to the prph info anything, but it would get	115	* currently we don't assign to the prph info anything, but it would get
@@ -121,16 +117,20 @@ int iwl_pcie_ctxt_info_gen3_init(struct iwl_trans *trans, · 1 unmodified line
121	prph_info = dma_alloc_coherent(trans->dev, sizeof(*prph_info),	117	prph_info = dma_alloc_coherent(trans->dev, sizeof(*prph_info),
122	&trans_pcie->prph_info_dma_addr,	118	&trans_pcie->prph_info_dma_addr,
123	GFP_KERNEL);	119	GFP_KERNEL);
124	if (!prph_info)	120	if (!prph_info) {
125	return -ENOMEM;	121	ret = -ENOMEM;
		122	goto err_free_prph_scratch;
		123	}
126		124
127	/* Allocate context info */	125	/* Allocate context info */
128	ctxt_info_gen3 = dma_alloc_coherent(trans->dev,	126	ctxt_info_gen3 = dma_alloc_coherent(trans->dev,
129	sizeof(*ctxt_info_gen3),	127	sizeof(*ctxt_info_gen3),
130	&trans_pcie->ctxt_info_dma_addr,	128	&trans_pcie->ctxt_info_dma_addr,
131	GFP_KERNEL);	129	GFP_KERNEL);
132	if (!ctxt_info_gen3)	130	if (!ctxt_info_gen3) {
133	return -ENOMEM;	131	ret = -ENOMEM;
		132	goto err_free_prph_info;
		133	}
134		134
135	ctxt_info_gen3->prph_info_base_addr =	135	ctxt_info_gen3->prph_info_base_addr =
136	cpu_to_le64(trans_pcie->prph_info_dma_addr);	136	cpu_to_le64(trans_pcie->prph_info_dma_addr);
@@ -186,6 +186,20 @@ int iwl_pcie_ctxt_info_gen3_init(struct iwl_trans *trans, · 49 unmodified lines
186	iwl_set_bit(trans, CSR_GP_CNTRL, CSR_AUTO_FUNC_INIT);	186	iwl_set_bit(trans, CSR_GP_CNTRL, CSR_AUTO_FUNC_INIT);
187		187
188	return 0;	188	return 0;
		189
		190	err_free_prph_info:
		191	dma_free_coherent(trans->dev,
		192	sizeof(*prph_info),
		193	prph_info,
		194	trans_pcie->prph_info_dma_addr);
		195
		196	err_free_prph_scratch:
		197	dma_free_coherent(trans->dev,
		198	sizeof(*prph_scratch),
		199	prph_scratch,
		200	trans_pcie->prph_scratch_dma_addr);
		201	return ret;
		202
189	}	203	}
190		204
191	void iwl_pcie_ctxt_info_gen3_free(struct iwl_trans *trans)	205	void iwl_pcie_ctxt_info_gen3_free(struct iwl_trans *trans)

drivers/net/wireless/intel/iwlwifi/pcie/drv.c+137−137

@@ -513,31 +513,33 @@ static const struct pci_device_id iwl_hw_card_ids[] = { · 512 unmodified lines
513	{IWL_PCI_DEVICE(0x24FD, 0x9074, iwl8265_2ac_cfg)},	513	{IWL_PCI_DEVICE(0x24FD, 0x9074, iwl8265_2ac_cfg)},
514		514
515	/* 9000 Series */	515	/* 9000 Series */
516	{IWL_PCI_DEVICE(0x02F0, 0x0030, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},	516	{IWL_PCI_DEVICE(0x02F0, 0x0030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
517	{IWL_PCI_DEVICE(0x02F0, 0x0034, iwl9560_2ac_cfg_quz_a0_jf_b0_soc)},	517	{IWL_PCI_DEVICE(0x02F0, 0x0034, iwl9560_2ac_cfg_qu_b0_jf_b0)},
518	{IWL_PCI_DEVICE(0x02F0, 0x0038, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},	518	{IWL_PCI_DEVICE(0x02F0, 0x0038, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
519	{IWL_PCI_DEVICE(0x02F0, 0x003C, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},	519	{IWL_PCI_DEVICE(0x02F0, 0x003C, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
520	{IWL_PCI_DEVICE(0x02F0, 0x0060, iwl9461_2ac_cfg_quz_a0_jf_b0_soc)},	520	{IWL_PCI_DEVICE(0x02F0, 0x0060, iwl9461_2ac_cfg_qu_b0_jf_b0)},
521	{IWL_PCI_DEVICE(0x02F0, 0x0064, iwl9461_2ac_cfg_quz_a0_jf_b0_soc)},	521	{IWL_PCI_DEVICE(0x02F0, 0x0064, iwl9461_2ac_cfg_qu_b0_jf_b0)},
522	{IWL_PCI_DEVICE(0x02F0, 0x00A0, iwl9462_2ac_cfg_quz_a0_jf_b0_soc)},	522	{IWL_PCI_DEVICE(0x02F0, 0x00A0, iwl9462_2ac_cfg_qu_b0_jf_b0)},
523	{IWL_PCI_DEVICE(0x02F0, 0x00A4, iwl9462_2ac_cfg_quz_a0_jf_b0_soc)},	523	{IWL_PCI_DEVICE(0x02F0, 0x00A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
524	{IWL_PCI_DEVICE(0x02F0, 0x0230, iwl9560_2ac_cfg_quz_a0_jf_b0_soc)},	524	{IWL_PCI_DEVICE(0x02F0, 0x0230, iwl9560_2ac_cfg_qu_b0_jf_b0)},
525	{IWL_PCI_DEVICE(0x02F0, 0x0234, iwl9560_2ac_cfg_quz_a0_jf_b0_soc)},	525	{IWL_PCI_DEVICE(0x02F0, 0x0234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
526	{IWL_PCI_DEVICE(0x02F0, 0x0238, iwl9560_2ac_cfg_quz_a0_jf_b0_soc)},	526	{IWL_PCI_DEVICE(0x02F0, 0x0238, iwl9560_2ac_cfg_qu_b0_jf_b0)},
527	{IWL_PCI_DEVICE(0x02F0, 0x023C, iwl9560_2ac_cfg_quz_a0_jf_b0_soc)},	527	{IWL_PCI_DEVICE(0x02F0, 0x023C, iwl9560_2ac_cfg_qu_b0_jf_b0)},
528	{IWL_PCI_DEVICE(0x02F0, 0x0260, iwl9461_2ac_cfg_quz_a0_jf_b0_soc)},	528	{IWL_PCI_DEVICE(0x02F0, 0x0260, iwl9461_2ac_cfg_qu_b0_jf_b0)},
529	{IWL_PCI_DEVICE(0x02F0, 0x0264, iwl9461_2ac_cfg_quz_a0_jf_b0_soc)},	529	{IWL_PCI_DEVICE(0x02F0, 0x0264, iwl9461_2ac_cfg_qu_b0_jf_b0)},
530	{IWL_PCI_DEVICE(0x02F0, 0x02A0, iwl9462_2ac_cfg_quz_a0_jf_b0_soc)},	530	{IWL_PCI_DEVICE(0x02F0, 0x02A0, iwl9462_2ac_cfg_qu_b0_jf_b0)},
531	{IWL_PCI_DEVICE(0x02F0, 0x02A4, iwl9462_2ac_cfg_quz_a0_jf_b0_soc)},	531	{IWL_PCI_DEVICE(0x02F0, 0x02A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
532	{IWL_PCI_DEVICE(0x02F0, 0x1551, iwl9560_killer_s_2ac_cfg_quz_a0_jf_b0_soc)},	532	{IWL_PCI_DEVICE(0x02F0, 0x1030, iwl9560_2ac_cfg_qu_b0_jf_b0)},
533	{IWL_PCI_DEVICE(0x02F0, 0x1552, iwl9560_killer_i_2ac_cfg_quz_a0_jf_b0_soc)},	533	{IWL_PCI_DEVICE(0x02F0, 0x1551, killer1550s_2ac_cfg_qu_b0_jf_b0)},
534	{IWL_PCI_DEVICE(0x02F0, 0x2030, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},	534	{IWL_PCI_DEVICE(0x02F0, 0x1552, killer1550i_2ac_cfg_qu_b0_jf_b0)},
535	{IWL_PCI_DEVICE(0x02F0, 0x2034, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},	535	{IWL_PCI_DEVICE(0x02F0, 0x2030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
536	{IWL_PCI_DEVICE(0x02F0, 0x4030, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},	536	{IWL_PCI_DEVICE(0x02F0, 0x2034, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
537	{IWL_PCI_DEVICE(0x02F0, 0x4034, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},	537	{IWL_PCI_DEVICE(0x02F0, 0x4030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
538	{IWL_PCI_DEVICE(0x02F0, 0x40A4, iwl9462_2ac_cfg_quz_a0_jf_b0_soc)},	538	{IWL_PCI_DEVICE(0x02F0, 0x4034, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
539	{IWL_PCI_DEVICE(0x02F0, 0x4234, iwl9560_2ac_cfg_quz_a0_jf_b0_soc)},	539	{IWL_PCI_DEVICE(0x02F0, 0x40A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
540	{IWL_PCI_DEVICE(0x02F0, 0x42A4, iwl9462_2ac_cfg_quz_a0_jf_b0_soc)},	540	{IWL_PCI_DEVICE(0x02F0, 0x4234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
		541	{IWL_PCI_DEVICE(0x02F0, 0x42A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
		542
541	{IWL_PCI_DEVICE(0x06F0, 0x0030, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},	543	{IWL_PCI_DEVICE(0x06F0, 0x0030, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},
542	{IWL_PCI_DEVICE(0x06F0, 0x0034, iwl9560_2ac_cfg_quz_a0_jf_b0_soc)},	544	{IWL_PCI_DEVICE(0x06F0, 0x0034, iwl9560_2ac_cfg_quz_a0_jf_b0_soc)},
543	{IWL_PCI_DEVICE(0x06F0, 0x0038, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},	545	{IWL_PCI_DEVICE(0x06F0, 0x0038, iwl9560_2ac_160_cfg_quz_a0_jf_b0_soc)},
@@ -643,34 +645,34 @@ static const struct pci_device_id iwl_hw_card_ids[] = { · 99 unmodified lines
643	{IWL_PCI_DEVICE(0x2720, 0x40A4, iwl9462_2ac_cfg_soc)},	645	{IWL_PCI_DEVICE(0x2720, 0x40A4, iwl9462_2ac_cfg_soc)},
644	{IWL_PCI_DEVICE(0x2720, 0x4234, iwl9560_2ac_cfg_soc)},	646	{IWL_PCI_DEVICE(0x2720, 0x4234, iwl9560_2ac_cfg_soc)},
645	{IWL_PCI_DEVICE(0x2720, 0x42A4, iwl9462_2ac_cfg_soc)},	647	{IWL_PCI_DEVICE(0x2720, 0x42A4, iwl9462_2ac_cfg_soc)},
646	{IWL_PCI_DEVICE(0x30DC, 0x0030, iwl9560_2ac_160_cfg_soc)},	648
647	{IWL_PCI_DEVICE(0x30DC, 0x0034, iwl9560_2ac_cfg_soc)},	649	{IWL_PCI_DEVICE(0x30DC, 0x0030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
648	{IWL_PCI_DEVICE(0x30DC, 0x0038, iwl9560_2ac_160_cfg_soc)},	650	{IWL_PCI_DEVICE(0x30DC, 0x0034, iwl9560_2ac_cfg_qu_b0_jf_b0)},
649	{IWL_PCI_DEVICE(0x30DC, 0x003C, iwl9560_2ac_160_cfg_soc)},	651	{IWL_PCI_DEVICE(0x30DC, 0x0038, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
650	{IWL_PCI_DEVICE(0x30DC, 0x0060, iwl9460_2ac_cfg_soc)},	652	{IWL_PCI_DEVICE(0x30DC, 0x003C, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
651	{IWL_PCI_DEVICE(0x30DC, 0x0064, iwl9461_2ac_cfg_soc)},	653	{IWL_PCI_DEVICE(0x30DC, 0x0060, iwl9461_2ac_cfg_qu_b0_jf_b0)},
652	{IWL_PCI_DEVICE(0x30DC, 0x00A0, iwl9462_2ac_cfg_soc)},	654	{IWL_PCI_DEVICE(0x30DC, 0x0064, iwl9461_2ac_cfg_qu_b0_jf_b0)},
653	{IWL_PCI_DEVICE(0x30DC, 0x00A4, iwl9462_2ac_cfg_soc)},	655	{IWL_PCI_DEVICE(0x30DC, 0x00A0, iwl9462_2ac_cfg_qu_b0_jf_b0)},
654	{IWL_PCI_DEVICE(0x30DC, 0x0230, iwl9560_2ac_cfg_soc)},	656	{IWL_PCI_DEVICE(0x30DC, 0x00A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
655	{IWL_PCI_DEVICE(0x30DC, 0x0234, iwl9560_2ac_cfg_soc)},	657	{IWL_PCI_DEVICE(0x30DC, 0x0230, iwl9560_2ac_cfg_qu_b0_jf_b0)},
656	{IWL_PCI_DEVICE(0x30DC, 0x0238, iwl9560_2ac_cfg_soc)},	658	{IWL_PCI_DEVICE(0x30DC, 0x0234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
657	{IWL_PCI_DEVICE(0x30DC, 0x023C, iwl9560_2ac_cfg_soc)},	659	{IWL_PCI_DEVICE(0x30DC, 0x0238, iwl9560_2ac_cfg_qu_b0_jf_b0)},
658	{IWL_PCI_DEVICE(0x30DC, 0x0260, iwl9461_2ac_cfg_soc)},	660	{IWL_PCI_DEVICE(0x30DC, 0x023C, iwl9560_2ac_cfg_qu_b0_jf_b0)},
659	{IWL_PCI_DEVICE(0x30DC, 0x0264, iwl9461_2ac_cfg_soc)},	661	{IWL_PCI_DEVICE(0x30DC, 0x0260, iwl9461_2ac_cfg_qu_b0_jf_b0)},
660	{IWL_PCI_DEVICE(0x30DC, 0x02A0, iwl9462_2ac_cfg_soc)},	662	{IWL_PCI_DEVICE(0x30DC, 0x0264, iwl9461_2ac_cfg_qu_b0_jf_b0)},
661	{IWL_PCI_DEVICE(0x30DC, 0x02A4, iwl9462_2ac_cfg_soc)},	663	{IWL_PCI_DEVICE(0x30DC, 0x02A0, iwl9462_2ac_cfg_qu_b0_jf_b0)},
662	{IWL_PCI_DEVICE(0x30DC, 0x1010, iwl9260_2ac_cfg)},	664	{IWL_PCI_DEVICE(0x30DC, 0x02A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
663	{IWL_PCI_DEVICE(0x30DC, 0x1030, iwl9560_2ac_cfg_soc)},	665	{IWL_PCI_DEVICE(0x30DC, 0x1030, iwl9560_2ac_cfg_qu_b0_jf_b0)},
664	{IWL_PCI_DEVICE(0x30DC, 0x1210, iwl9260_2ac_cfg)},	666	{IWL_PCI_DEVICE(0x30DC, 0x1551, killer1550s_2ac_cfg_qu_b0_jf_b0)},
665	{IWL_PCI_DEVICE(0x30DC, 0x1551, iwl9560_killer_s_2ac_cfg_soc)},	667	{IWL_PCI_DEVICE(0x30DC, 0x1552, killer1550i_2ac_cfg_qu_b0_jf_b0)},
666	{IWL_PCI_DEVICE(0x30DC, 0x1552, iwl9560_killer_2ac_cfg_soc)},	668	{IWL_PCI_DEVICE(0x30DC, 0x2030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
667	{IWL_PCI_DEVICE(0x30DC, 0x2030, iwl9560_2ac_160_cfg_soc)},	669	{IWL_PCI_DEVICE(0x30DC, 0x2034, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
668	{IWL_PCI_DEVICE(0x30DC, 0x2034, iwl9560_2ac_160_cfg_soc)},	670	{IWL_PCI_DEVICE(0x30DC, 0x4030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
669	{IWL_PCI_DEVICE(0x30DC, 0x4030, iwl9560_2ac_160_cfg_soc)},	671	{IWL_PCI_DEVICE(0x30DC, 0x4034, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
670	{IWL_PCI_DEVICE(0x30DC, 0x4034, iwl9560_2ac_160_cfg_soc)},	672	{IWL_PCI_DEVICE(0x30DC, 0x40A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
671	{IWL_PCI_DEVICE(0x30DC, 0x40A4, iwl9462_2ac_cfg_soc)},	673	{IWL_PCI_DEVICE(0x30DC, 0x4234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
672	{IWL_PCI_DEVICE(0x30DC, 0x4234, iwl9560_2ac_cfg_soc)},	674	{IWL_PCI_DEVICE(0x30DC, 0x42A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
673	{IWL_PCI_DEVICE(0x30DC, 0x42A4, iwl9462_2ac_cfg_soc)},	675
674	{IWL_PCI_DEVICE(0x31DC, 0x0030, iwl9560_2ac_160_cfg_shared_clk)},	676	{IWL_PCI_DEVICE(0x31DC, 0x0030, iwl9560_2ac_160_cfg_shared_clk)},
675	{IWL_PCI_DEVICE(0x31DC, 0x0034, iwl9560_2ac_cfg_shared_clk)},	677	{IWL_PCI_DEVICE(0x31DC, 0x0034, iwl9560_2ac_cfg_shared_clk)},
676	{IWL_PCI_DEVICE(0x31DC, 0x0038, iwl9560_2ac_160_cfg_shared_clk)},	678	{IWL_PCI_DEVICE(0x31DC, 0x0038, iwl9560_2ac_160_cfg_shared_clk)},
@@ -726,62 +728,60 @@ static const struct pci_device_id iwl_hw_card_ids[] = { · 49 unmodified lines
726	{IWL_PCI_DEVICE(0x34F0, 0x4234, iwl9560_2ac_cfg_qu_b0_jf_b0)},	728	{IWL_PCI_DEVICE(0x34F0, 0x4234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
727	{IWL_PCI_DEVICE(0x34F0, 0x42A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},	729	{IWL_PCI_DEVICE(0x34F0, 0x42A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
728		730
729	{IWL_PCI_DEVICE(0x3DF0, 0x0030, iwl9560_2ac_160_cfg_soc)},	731	{IWL_PCI_DEVICE(0x3DF0, 0x0030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
730	{IWL_PCI_DEVICE(0x3DF0, 0x0034, iwl9560_2ac_cfg_soc)},	732	{IWL_PCI_DEVICE(0x3DF0, 0x0034, iwl9560_2ac_cfg_qu_b0_jf_b0)},
731	{IWL_PCI_DEVICE(0x3DF0, 0x0038, iwl9560_2ac_160_cfg_soc)},	733	{IWL_PCI_DEVICE(0x3DF0, 0x0038, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
732	{IWL_PCI_DEVICE(0x3DF0, 0x003C, iwl9560_2ac_160_cfg_soc)},	734	{IWL_PCI_DEVICE(0x3DF0, 0x003C, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
733	{IWL_PCI_DEVICE(0x3DF0, 0x0060, iwl9461_2ac_cfg_soc)},	735	{IWL_PCI_DEVICE(0x3DF0, 0x0060, iwl9461_2ac_cfg_qu_b0_jf_b0)},
734	{IWL_PCI_DEVICE(0x3DF0, 0x0064, iwl9461_2ac_cfg_soc)},	736	{IWL_PCI_DEVICE(0x3DF0, 0x0064, iwl9461_2ac_cfg_qu_b0_jf_b0)},
735	{IWL_PCI_DEVICE(0x3DF0, 0x00A0, iwl9462_2ac_cfg_soc)},	737	{IWL_PCI_DEVICE(0x3DF0, 0x00A0, iwl9462_2ac_cfg_qu_b0_jf_b0)},
736	{IWL_PCI_DEVICE(0x3DF0, 0x00A4, iwl9462_2ac_cfg_soc)},	738	{IWL_PCI_DEVICE(0x3DF0, 0x00A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
737	{IWL_PCI_DEVICE(0x3DF0, 0x0230, iwl9560_2ac_cfg_soc)},	739	{IWL_PCI_DEVICE(0x3DF0, 0x0230, iwl9560_2ac_cfg_qu_b0_jf_b0)},
738	{IWL_PCI_DEVICE(0x3DF0, 0x0234, iwl9560_2ac_cfg_soc)},	740	{IWL_PCI_DEVICE(0x3DF0, 0x0234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
739	{IWL_PCI_DEVICE(0x3DF0, 0x0238, iwl9560_2ac_cfg_soc)},	741	{IWL_PCI_DEVICE(0x3DF0, 0x0238, iwl9560_2ac_cfg_qu_b0_jf_b0)},
740	{IWL_PCI_DEVICE(0x3DF0, 0x023C, iwl9560_2ac_cfg_soc)},	742	{IWL_PCI_DEVICE(0x3DF0, 0x023C, iwl9560_2ac_cfg_qu_b0_jf_b0)},
741	{IWL_PCI_DEVICE(0x3DF0, 0x0260, iwl9461_2ac_cfg_soc)},	743	{IWL_PCI_DEVICE(0x3DF0, 0x0260, iwl9461_2ac_cfg_qu_b0_jf_b0)},
742	{IWL_PCI_DEVICE(0x3DF0, 0x0264, iwl9461_2ac_cfg_soc)},	744	{IWL_PCI_DEVICE(0x3DF0, 0x0264, iwl9461_2ac_cfg_qu_b0_jf_b0)},
743	{IWL_PCI_DEVICE(0x3DF0, 0x02A0, iwl9462_2ac_cfg_soc)},	745	{IWL_PCI_DEVICE(0x3DF0, 0x02A0, iwl9462_2ac_cfg_qu_b0_jf_b0)},
744	{IWL_PCI_DEVICE(0x3DF0, 0x02A4, iwl9462_2ac_cfg_soc)},	746	{IWL_PCI_DEVICE(0x3DF0, 0x02A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
745	{IWL_PCI_DEVICE(0x3DF0, 0x1010, iwl9260_2ac_cfg)},	747	{IWL_PCI_DEVICE(0x3DF0, 0x1030, iwl9560_2ac_cfg_qu_b0_jf_b0)},
746	{IWL_PCI_DEVICE(0x3DF0, 0x1030, iwl9560_2ac_cfg_soc)},	748	{IWL_PCI_DEVICE(0x3DF0, 0x1551, killer1550s_2ac_cfg_qu_b0_jf_b0)},
747	{IWL_PCI_DEVICE(0x3DF0, 0x1210, iwl9260_2ac_cfg)},	749	{IWL_PCI_DEVICE(0x3DF0, 0x1552, killer1550i_2ac_cfg_qu_b0_jf_b0)},
748	{IWL_PCI_DEVICE(0x3DF0, 0x1551, iwl9560_killer_s_2ac_cfg_soc)},	750	{IWL_PCI_DEVICE(0x3DF0, 0x2030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
749	{IWL_PCI_DEVICE(0x3DF0, 0x1552, iwl9560_killer_2ac_cfg_soc)},	751	{IWL_PCI_DEVICE(0x3DF0, 0x2034, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
750	{IWL_PCI_DEVICE(0x3DF0, 0x2030, iwl9560_2ac_160_cfg_soc)},	752	{IWL_PCI_DEVICE(0x3DF0, 0x4030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
751	{IWL_PCI_DEVICE(0x3DF0, 0x2034, iwl9560_2ac_160_cfg_soc)},	753	{IWL_PCI_DEVICE(0x3DF0, 0x4034, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
752	{IWL_PCI_DEVICE(0x3DF0, 0x4030, iwl9560_2ac_160_cfg_soc)},	754	{IWL_PCI_DEVICE(0x3DF0, 0x40A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
753	{IWL_PCI_DEVICE(0x3DF0, 0x4034, iwl9560_2ac_160_cfg_soc)},	755	{IWL_PCI_DEVICE(0x3DF0, 0x4234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
754	{IWL_PCI_DEVICE(0x3DF0, 0x40A4, iwl9462_2ac_cfg_soc)},	756	{IWL_PCI_DEVICE(0x3DF0, 0x42A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
755	{IWL_PCI_DEVICE(0x3DF0, 0x4234, iwl9560_2ac_cfg_soc)},	757
756	{IWL_PCI_DEVICE(0x3DF0, 0x42A4, iwl9462_2ac_cfg_soc)},	758	{IWL_PCI_DEVICE(0x43F0, 0x0030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
757	{IWL_PCI_DEVICE(0x43F0, 0x0030, iwl9560_2ac_160_cfg_soc)},	759	{IWL_PCI_DEVICE(0x43F0, 0x0034, iwl9560_2ac_cfg_qu_b0_jf_b0)},
758	{IWL_PCI_DEVICE(0x43F0, 0x0034, iwl9560_2ac_cfg_soc)},	760	{IWL_PCI_DEVICE(0x43F0, 0x0038, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
759	{IWL_PCI_DEVICE(0x43F0, 0x0038, iwl9560_2ac_160_cfg_soc)},	761	{IWL_PCI_DEVICE(0x43F0, 0x003C, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
760	{IWL_PCI_DEVICE(0x43F0, 0x003C, iwl9560_2ac_160_cfg_soc)},	762	{IWL_PCI_DEVICE(0x43F0, 0x0060, iwl9461_2ac_cfg_qu_b0_jf_b0)},
761	{IWL_PCI_DEVICE(0x43F0, 0x0060, iwl9461_2ac_cfg_soc)},	763	{IWL_PCI_DEVICE(0x43F0, 0x0064, iwl9461_2ac_cfg_qu_b0_jf_b0)},
762	{IWL_PCI_DEVICE(0x43F0, 0x0064, iwl9461_2ac_cfg_soc)},	764	{IWL_PCI_DEVICE(0x43F0, 0x00A0, iwl9462_2ac_cfg_qu_b0_jf_b0)},
763	{IWL_PCI_DEVICE(0x43F0, 0x00A0, iwl9462_2ac_cfg_soc)},	765	{IWL_PCI_DEVICE(0x43F0, 0x00A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
764	{IWL_PCI_DEVICE(0x43F0, 0x00A4, iwl9462_2ac_cfg_soc)},	766	{IWL_PCI_DEVICE(0x43F0, 0x0230, iwl9560_2ac_cfg_qu_b0_jf_b0)},
765	{IWL_PCI_DEVICE(0x43F0, 0x0230, iwl9560_2ac_cfg_soc)},	767	{IWL_PCI_DEVICE(0x43F0, 0x0234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
766	{IWL_PCI_DEVICE(0x43F0, 0x0234, iwl9560_2ac_cfg_soc)},	768	{IWL_PCI_DEVICE(0x43F0, 0x0238, iwl9560_2ac_cfg_qu_b0_jf_b0)},
767	{IWL_PCI_DEVICE(0x43F0, 0x0238, iwl9560_2ac_cfg_soc)},	769	{IWL_PCI_DEVICE(0x43F0, 0x023C, iwl9560_2ac_cfg_qu_b0_jf_b0)},
768	{IWL_PCI_DEVICE(0x43F0, 0x023C, iwl9560_2ac_cfg_soc)},	770	{IWL_PCI_DEVICE(0x43F0, 0x0260, iwl9461_2ac_cfg_qu_b0_jf_b0)},
769	{IWL_PCI_DEVICE(0x43F0, 0x0260, iwl9461_2ac_cfg_soc)},	771	{IWL_PCI_DEVICE(0x43F0, 0x0264, iwl9461_2ac_cfg_qu_b0_jf_b0)},
770	{IWL_PCI_DEVICE(0x43F0, 0x0264, iwl9461_2ac_cfg_soc)},	772	{IWL_PCI_DEVICE(0x43F0, 0x02A0, iwl9462_2ac_cfg_qu_b0_jf_b0)},
771	{IWL_PCI_DEVICE(0x43F0, 0x02A0, iwl9462_2ac_cfg_soc)},	773	{IWL_PCI_DEVICE(0x43F0, 0x02A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
772	{IWL_PCI_DEVICE(0x43F0, 0x02A4, iwl9462_2ac_cfg_soc)},	774	{IWL_PCI_DEVICE(0x43F0, 0x1030, iwl9560_2ac_cfg_qu_b0_jf_b0)},
773	{IWL_PCI_DEVICE(0x43F0, 0x1010, iwl9260_2ac_cfg)},	775	{IWL_PCI_DEVICE(0x43F0, 0x1551, killer1550s_2ac_cfg_qu_b0_jf_b0)},
774	{IWL_PCI_DEVICE(0x43F0, 0x1030, iwl9560_2ac_cfg_soc)},	776	{IWL_PCI_DEVICE(0x43F0, 0x1552, killer1550i_2ac_cfg_qu_b0_jf_b0)},
775	{IWL_PCI_DEVICE(0x43F0, 0x1210, iwl9260_2ac_cfg)},	777	{IWL_PCI_DEVICE(0x43F0, 0x2030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
776	{IWL_PCI_DEVICE(0x43F0, 0x1551, iwl9560_killer_s_2ac_cfg_soc)},	778	{IWL_PCI_DEVICE(0x43F0, 0x2034, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
777	{IWL_PCI_DEVICE(0x43F0, 0x1552, iwl9560_killer_2ac_cfg_soc)},	779	{IWL_PCI_DEVICE(0x43F0, 0x4030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
778	{IWL_PCI_DEVICE(0x43F0, 0x2030, iwl9560_2ac_160_cfg_soc)},	780	{IWL_PCI_DEVICE(0x43F0, 0x4034, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
779	{IWL_PCI_DEVICE(0x43F0, 0x2034, iwl9560_2ac_160_cfg_soc)},	781	{IWL_PCI_DEVICE(0x43F0, 0x40A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
780	{IWL_PCI_DEVICE(0x43F0, 0x4030, iwl9560_2ac_160_cfg_soc)},	782	{IWL_PCI_DEVICE(0x43F0, 0x4234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
781	{IWL_PCI_DEVICE(0x43F0, 0x4034, iwl9560_2ac_160_cfg_soc)},	783	{IWL_PCI_DEVICE(0x43F0, 0x42A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
782	{IWL_PCI_DEVICE(0x43F0, 0x40A4, iwl9462_2ac_cfg_soc)},	784
783	{IWL_PCI_DEVICE(0x43F0, 0x4234, iwl9560_2ac_cfg_soc)},
784	{IWL_PCI_DEVICE(0x43F0, 0x42A4, iwl9462_2ac_cfg_soc)},
785	{IWL_PCI_DEVICE(0x9DF0, 0x0000, iwl9460_2ac_cfg_soc)},	785	{IWL_PCI_DEVICE(0x9DF0, 0x0000, iwl9460_2ac_cfg_soc)},
786	{IWL_PCI_DEVICE(0x9DF0, 0x0010, iwl9460_2ac_cfg_soc)},	786	{IWL_PCI_DEVICE(0x9DF0, 0x0010, iwl9460_2ac_cfg_soc)},
787	{IWL_PCI_DEVICE(0x9DF0, 0x0030, iwl9560_2ac_160_cfg_soc)},	787	{IWL_PCI_DEVICE(0x9DF0, 0x0030, iwl9560_2ac_160_cfg_soc)},
@@ -821,34 +821,34 @@ static const struct pci_device_id iwl_hw_card_ids[] = { · 33 unmodified lines
821	{IWL_PCI_DEVICE(0x9DF0, 0x40A4, iwl9462_2ac_cfg_soc)},	821	{IWL_PCI_DEVICE(0x9DF0, 0x40A4, iwl9462_2ac_cfg_soc)},
822	{IWL_PCI_DEVICE(0x9DF0, 0x4234, iwl9560_2ac_cfg_soc)},	822	{IWL_PCI_DEVICE(0x9DF0, 0x4234, iwl9560_2ac_cfg_soc)},
823	{IWL_PCI_DEVICE(0x9DF0, 0x42A4, iwl9462_2ac_cfg_soc)},	823	{IWL_PCI_DEVICE(0x9DF0, 0x42A4, iwl9462_2ac_cfg_soc)},
824	{IWL_PCI_DEVICE(0xA0F0, 0x0030, iwl9560_2ac_160_cfg_soc)},	824
825	{IWL_PCI_DEVICE(0xA0F0, 0x0034, iwl9560_2ac_cfg_soc)},	825	{IWL_PCI_DEVICE(0xA0F0, 0x0030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
826	{IWL_PCI_DEVICE(0xA0F0, 0x0038, iwl9560_2ac_160_cfg_soc)},	826	{IWL_PCI_DEVICE(0xA0F0, 0x0034, iwl9560_2ac_cfg_qu_b0_jf_b0)},
827	{IWL_PCI_DEVICE(0xA0F0, 0x003C, iwl9560_2ac_160_cfg_soc)},	827	{IWL_PCI_DEVICE(0xA0F0, 0x0038, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
828	{IWL_PCI_DEVICE(0xA0F0, 0x0060, iwl9461_2ac_cfg_soc)},	828	{IWL_PCI_DEVICE(0xA0F0, 0x003C, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
829	{IWL_PCI_DEVICE(0xA0F0, 0x0064, iwl9461_2ac_cfg_soc)},	829	{IWL_PCI_DEVICE(0xA0F0, 0x0060, iwl9461_2ac_cfg_qu_b0_jf_b0)},
830	{IWL_PCI_DEVICE(0xA0F0, 0x00A0, iwl9462_2ac_cfg_soc)},	830	{IWL_PCI_DEVICE(0xA0F0, 0x0064, iwl9461_2ac_cfg_qu_b0_jf_b0)},
831	{IWL_PCI_DEVICE(0xA0F0, 0x00A4, iwl9462_2ac_cfg_soc)},	831	{IWL_PCI_DEVICE(0xA0F0, 0x00A0, iwl9462_2ac_cfg_qu_b0_jf_b0)},
832	{IWL_PCI_DEVICE(0xA0F0, 0x0230, iwl9560_2ac_cfg_soc)},	832	{IWL_PCI_DEVICE(0xA0F0, 0x00A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
833	{IWL_PCI_DEVICE(0xA0F0, 0x0234, iwl9560_2ac_cfg_soc)},	833	{IWL_PCI_DEVICE(0xA0F0, 0x0230, iwl9560_2ac_cfg_qu_b0_jf_b0)},
834	{IWL_PCI_DEVICE(0xA0F0, 0x0238, iwl9560_2ac_cfg_soc)},	834	{IWL_PCI_DEVICE(0xA0F0, 0x0234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
835	{IWL_PCI_DEVICE(0xA0F0, 0x023C, iwl9560_2ac_cfg_soc)},	835	{IWL_PCI_DEVICE(0xA0F0, 0x0238, iwl9560_2ac_cfg_qu_b0_jf_b0)},
836	{IWL_PCI_DEVICE(0xA0F0, 0x0260, iwl9461_2ac_cfg_soc)},	836	{IWL_PCI_DEVICE(0xA0F0, 0x023C, iwl9560_2ac_cfg_qu_b0_jf_b0)},
837	{IWL_PCI_DEVICE(0xA0F0, 0x0264, iwl9461_2ac_cfg_soc)},	837	{IWL_PCI_DEVICE(0xA0F0, 0x0260, iwl9461_2ac_cfg_qu_b0_jf_b0)},
838	{IWL_PCI_DEVICE(0xA0F0, 0x02A0, iwl9462_2ac_cfg_soc)},	838	{IWL_PCI_DEVICE(0xA0F0, 0x0264, iwl9461_2ac_cfg_qu_b0_jf_b0)},
839	{IWL_PCI_DEVICE(0xA0F0, 0x02A4, iwl9462_2ac_cfg_soc)},	839	{IWL_PCI_DEVICE(0xA0F0, 0x02A0, iwl9462_2ac_cfg_qu_b0_jf_b0)},
840	{IWL_PCI_DEVICE(0xA0F0, 0x1010, iwl9260_2ac_cfg)},	840	{IWL_PCI_DEVICE(0xA0F0, 0x02A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
841	{IWL_PCI_DEVICE(0xA0F0, 0x1030, iwl9560_2ac_cfg_soc)},	841	{IWL_PCI_DEVICE(0xA0F0, 0x1030, iwl9560_2ac_cfg_qu_b0_jf_b0)},
842	{IWL_PCI_DEVICE(0xA0F0, 0x1210, iwl9260_2ac_cfg)},	842	{IWL_PCI_DEVICE(0xA0F0, 0x1551, killer1550s_2ac_cfg_qu_b0_jf_b0)},
843	{IWL_PCI_DEVICE(0xA0F0, 0x1551, iwl9560_killer_s_2ac_cfg_soc)},	843	{IWL_PCI_DEVICE(0xA0F0, 0x1552, killer1550i_2ac_cfg_qu_b0_jf_b0)},
844	{IWL_PCI_DEVICE(0xA0F0, 0x1552, iwl9560_killer_2ac_cfg_soc)},	844	{IWL_PCI_DEVICE(0xA0F0, 0x2030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
845	{IWL_PCI_DEVICE(0xA0F0, 0x2030, iwl9560_2ac_160_cfg_soc)},	845	{IWL_PCI_DEVICE(0xA0F0, 0x2034, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
846	{IWL_PCI_DEVICE(0xA0F0, 0x2034, iwl9560_2ac_160_cfg_soc)},	846	{IWL_PCI_DEVICE(0xA0F0, 0x4030, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
847	{IWL_PCI_DEVICE(0xA0F0, 0x4030, iwl9560_2ac_160_cfg_soc)},	847	{IWL_PCI_DEVICE(0xA0F0, 0x4034, iwl9560_2ac_160_cfg_qu_b0_jf_b0)},
848	{IWL_PCI_DEVICE(0xA0F0, 0x4034, iwl9560_2ac_160_cfg_soc)},	848	{IWL_PCI_DEVICE(0xA0F0, 0x40A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
849	{IWL_PCI_DEVICE(0xA0F0, 0x40A4, iwl9462_2ac_cfg_soc)},	849	{IWL_PCI_DEVICE(0xA0F0, 0x4234, iwl9560_2ac_cfg_qu_b0_jf_b0)},
850	{IWL_PCI_DEVICE(0xA0F0, 0x4234, iwl9560_2ac_cfg_soc)},	850	{IWL_PCI_DEVICE(0xA0F0, 0x42A4, iwl9462_2ac_cfg_qu_b0_jf_b0)},
851	{IWL_PCI_DEVICE(0xA0F0, 0x42A4, iwl9462_2ac_cfg_soc)},	851
852	{IWL_PCI_DEVICE(0xA370, 0x0030, iwl9560_2ac_160_cfg_soc)},	852	{IWL_PCI_DEVICE(0xA370, 0x0030, iwl9560_2ac_160_cfg_soc)},
853	{IWL_PCI_DEVICE(0xA370, 0x0034, iwl9560_2ac_cfg_soc)},	853	{IWL_PCI_DEVICE(0xA370, 0x0034, iwl9560_2ac_cfg_soc)},
854	{IWL_PCI_DEVICE(0xA370, 0x0038, iwl9560_2ac_160_cfg_soc)},	854	{IWL_PCI_DEVICE(0xA370, 0x0038, iwl9560_2ac_160_cfg_soc)},

drivers/net/wireless/intel/iwlwifi/pcie/trans.c+19−6

 		ptr = cmdq->write_ptr;
 		for (i = 0; i < cmdq->n_window; i++) {
 			u8 idx = iwl_pcie_get_cmd_index(cmdq, ptr);
+			u8 tfdidx;
 			u32 caplen, cmdlen;
+			if (trans->trans_cfg->use_tfh)
+				tfdidx = idx;
+			else
+				tfdidx = ptr;
 			cmdlen = iwl_trans_pcie_get_cmdlen(trans,
-							   cmdq->tfds +
+							   (u8 *)cmdq->tfds +
-							   tfd_size * ptr);
+							   tfd_size * tfdidx);
 			caplen = min_t(u32, TFD_MAX_PAYLOAD_SIZE, cmdlen);
 			if (cmdlen) {
 	spin_lock_init(&trans_pcie->reg_lock);
 	mutex_init(&trans_pcie->mutex);
 	init_waitqueue_head(&trans_pcie->ucode_write_waitq);
+	trans_pcie->rba.alloc_wq = alloc_workqueue("rb_allocator",
+						   WQ_HIGHPRI | WQ_UNBOUND, 1);
+	if (!trans_pcie->rba.alloc_wq) {
+		ret = -ENOMEM;
+		goto out_free_trans;
+	}
+	INIT_WORK(&trans_pcie->rba.rx_alloc, iwl_pcie_rx_allocator_work);
 	trans_pcie->tso_hdr_page = alloc_percpu(struct iwl_tso_hdr_page);
 	if (!trans_pcie->tso_hdr_page) {
 		ret = -ENOMEM;
 		trans_pcie->inta_mask = CSR_INI_SET_MASK;
 	 }
-	trans_pcie->rba.alloc_wq = alloc_workqueue("rb_allocator",
-						   WQ_HIGHPRI | WQ_UNBOUND, 1);
-	INIT_WORK(&trans_pcie->rba.rx_alloc, iwl_pcie_rx_allocator_work);
 #ifdef CONFIG_IWLWIFI_DEBUGFS
 	trans_pcie->fw_mon_data.state = IWL_FW_MON_DBGFS_STATE_CLOSED;
 	mutex_init(&trans_pcie->fw_mon_data.mutex);
 	iwl_pcie_free_ict(trans);
 out_no_pci:
 	free_percpu(trans_pcie->tso_hdr_page);
+	destroy_workqueue(trans_pcie->rba.alloc_wq);
+out_free_trans:
 	iwl_trans_free(trans);
 	return ERR_PTR(ret);
 }

drivers/net/wireless/mac80211_hwsim.c+1−1

@@ -4026,7 +4026,7 @@ static int __init init_mac80211_hwsim(void) · 4025 unmodified lines
4026	err = dev_alloc_name(hwsim_mon, hwsim_mon->name);	4026	err = dev_alloc_name(hwsim_mon, hwsim_mon->name);
4027	if (err < 0) {	4027	if (err < 0) {
4028	rtnl_unlock();	4028	rtnl_unlock();
4029	goto out_free_radios;	4029	goto out_free_mon;
4030	}	4030	}
4031		4031
4032	err = register_netdevice(hwsim_mon);	4032	err = register_netdevice(hwsim_mon);

drivers/net/wireless/ralink/rt2x00/rt2x00.h+0−1

@@ -23,7 +23,6 @@ · 22 unmodified lines
23	#include <linux/leds.h>	23	#include <linux/leds.h>
24	#include <linux/mutex.h>	24	#include <linux/mutex.h>
25	#include <linux/etherdevice.h>	25	#include <linux/etherdevice.h>
26	#include <linux/input-polldev.h>
27	#include <linux/kfifo.h>	26	#include <linux/kfifo.h>
28	#include <linux/hrtimer.h>	27	#include <linux/hrtimer.h>
29	#include <linux/average.h>	28	#include <linux/average.h>

drivers/net/wireless/ralink/rt2x00/rt2x00debug.c+1−1

@@ -555,7 +555,7 @@ static ssize_t rt2x00debug_write_restart_hw(struct file *file, · 554 unmodified lines
555	{	555	{
556	struct rt2x00debug_intf *intf = file->private_data;	556	struct rt2x00debug_intf *intf = file->private_data;
557	struct rt2x00_dev *rt2x00dev = intf->rt2x00dev;	557	struct rt2x00_dev *rt2x00dev = intf->rt2x00dev;
558	static unsigned long last_reset;	558	static unsigned long last_reset = INITIAL_JIFFIES;
559		559
560	if (!rt2x00_has_cap_restart_hw(rt2x00dev))	560	if (!rt2x00_has_cap_restart_hw(rt2x00dev))
561	return -EOPNOTSUPP;	561	return -EOPNOTSUPP;

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

@@ -719,7 +719,6 @@ err_unmap: · 718 unmodified lines
719	xenvif_unmap_frontend_data_rings(queue);	719	xenvif_unmap_frontend_data_rings(queue);
720	netif_napi_del(&queue->napi);	720	netif_napi_del(&queue->napi);
721	err:	721	err:
722	module_put(THIS_MODULE);
723	return err;	722	return err;
724	}	723	}
725		724

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

 	rc = pn533_finalize_setup(priv);
 	if (rc)
-		goto error;
+		goto err_deregister;
 	usb_set_intfdata(interface, phy);
 	return 0;
+err_deregister:
+	pn533_unregister_device(phy->priv);
 error:
+	usb_kill_urb(phy->in_urb);
+	usb_kill_urb(phy->out_urb);
+	usb_kill_urb(phy->ack_urb);
 	usb_free_urb(phy->in_urb);
 	usb_free_urb(phy->out_urb);
 	usb_free_urb(phy->ack_urb);
 	usb_put_dev(phy->udev);
 	kfree(in_buf);
+	kfree(phy->ack_buffer);
 	return rc;
 }

drivers/nvme/host/core.c+68−26

 	/*
 	 * Only new queue scan work when admin and IO queues are both alive
 	 */
-	if (ctrl->state == NVME_CTRL_LIVE)
+	if (ctrl->state == NVME_CTRL_LIVE && ctrl->tagset)
 		queue_work(nvme_wq, &ctrl->scan_work);
 }
+/*
+ * Use this function to proceed with scheduling reset_work for a controller
+ * that had previously been set to the resetting state. This is intended for
+ * code paths that can't be interrupted by other reset attempts. A hot removal
+ * may prevent this from succeeding.
+ */
+int nvme_try_sched_reset(struct nvme_ctrl *ctrl)
+{
+	if (ctrl->state != NVME_CTRL_RESETTING)
+		return -EBUSY;
+	if (!queue_work(nvme_reset_wq, &ctrl->reset_work))
+		return -EBUSY;
+	return 0;
+}
+EXPORT_SYMBOL_GPL(nvme_try_sched_reset);
 int nvme_reset_ctrl(struct nvme_ctrl *ctrl)
 {
 	if (!nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING))
 	ret = nvme_reset_ctrl(ctrl);
 	if (!ret) {
 		flush_work(&ctrl->reset_work);
-		if (ctrl->state != NVME_CTRL_LIVE &&
+		if (ctrl->state != NVME_CTRL_LIVE)
-		    ctrl->state != NVME_CTRL_ADMIN_ONLY)
 			ret = -ENETRESET;
 	}
 	old_state = ctrl->state;
 	switch (new_state) {
-	case NVME_CTRL_ADMIN_ONLY:
-		switch (old_state) {
-		case NVME_CTRL_CONNECTING:
-			changed = true;
-			/* FALLTHRU */
-		default:
-			break;
-		}
-		break;
 	case NVME_CTRL_LIVE:
 		switch (old_state) {
 		case NVME_CTRL_NEW:
 		switch (old_state) {
 		case NVME_CTRL_NEW:
 		case NVME_CTRL_LIVE:
-		case NVME_CTRL_ADMIN_ONLY:
 			changed = true;
 			/* FALLTHRU */
 		default:
 	case NVME_CTRL_DELETING:
 		switch (old_state) {
 		case NVME_CTRL_LIVE:
-		case NVME_CTRL_ADMIN_ONLY:
 		case NVME_CTRL_RESETTING:
 		case NVME_CTRL_CONNECTING:
 			changed = true;
 		break;
 	}
-	if (changed)
+	if (changed) {
 		ctrl->state = new_state;
+		wake_up_all(&ctrl->state_wq);
+	}
 	spin_unlock_irqrestore(&ctrl->lock, flags);
 	if (changed && ctrl->state == NVME_CTRL_LIVE)
 }
 EXPORT_SYMBOL_GPL(nvme_change_ctrl_state);
+/*
+ * Returns true for sink states that can't ever transition back to live.
+ */
+static bool nvme_state_terminal(struct nvme_ctrl *ctrl)
+{
+	switch (ctrl->state) {
+	case NVME_CTRL_NEW:
+	case NVME_CTRL_LIVE:
+	case NVME_CTRL_RESETTING:
+	case NVME_CTRL_CONNECTING:
+		return false;
+	case NVME_CTRL_DELETING:
+	case NVME_CTRL_DEAD:
+		return true;
+	default:
+		WARN_ONCE(1, "Unhandled ctrl state:%d", ctrl->state);
+		return true;
+	}
+}
+/*
+ * Waits for the controller state to be resetting, or returns false if it is
+ * not possible to ever transition to that state.
+ */
+bool nvme_wait_reset(struct nvme_ctrl *ctrl)
+{
+	wait_event(ctrl->state_wq,
+		   nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING) ||
+		   nvme_state_terminal(ctrl));
+	return ctrl->state == NVME_CTRL_RESETTING;
+}
+EXPORT_SYMBOL_GPL(nvme_wait_reset);
 static void nvme_free_ns_head(struct kref *ref)
 {
 	struct nvme_ns_head *head =
 		if (ns->disk && nvme_revalidate_disk(ns->disk))
 			nvme_set_queue_dying(ns);
 	up_read(&ctrl->namespaces_rwsem);
-	nvme_remove_invalid_namespaces(ctrl, NVME_NSID_ALL);
 }
 static void nvme_passthru_end(struct nvme_ctrl *ctrl, u32 effects)
 		nvme_unfreeze(ctrl);
 		nvme_mpath_unfreeze(ctrl->subsys);
 		mutex_unlock(&ctrl->subsys->lock);
+		nvme_remove_invalid_namespaces(ctrl, NVME_NSID_ALL);
 		mutex_unlock(&ctrl->scan_lock);
 	}
 	if (effects & NVME_CMD_EFFECTS_CCC)
 	switch (ctrl->state) {
 	case NVME_CTRL_LIVE:
-	case NVME_CTRL_ADMIN_ONLY:
 		break;
 	default:
 		return -EWOULDBLOCK;
 	static const char *const state_name[] = {
 		[NVME_CTRL_NEW]		= "new",
 		[NVME_CTRL_LIVE]	= "live",
-		[NVME_CTRL_ADMIN_ONLY]	= "only-admin",
 		[NVME_CTRL_RESETTING]	= "resetting",
 		[NVME_CTRL_CONNECTING]	= "connecting",
 		[NVME_CTRL_DELETING]	= "deleting",
 	struct nvme_id_ctrl *id;
 	unsigned nn;
-	if (ctrl->state != NVME_CTRL_LIVE)
+	/* No tagset on a live ctrl means IO queues could not created */
+	if (ctrl->state != NVME_CTRL_LIVE || !ctrl->tagset)
 		return;
-	WARN_ON_ONCE(!ctrl->tagset);
 	if (test_and_clear_bit(NVME_AER_NOTICE_NS_CHANGED, &ctrl->events)) {
 		dev_info(ctrl->device, "rescanning namespaces.\n");
 		nvme_clear_changed_ns_log(ctrl);
 		if (time_after(jiffies, fw_act_timeout)) {
 			dev_warn(ctrl->device,
 				"Fw activation timeout, reset controller\n");
-			nvme_reset_ctrl(ctrl);
+			nvme_try_sched_reset(ctrl);
-			break;
+			return;
 		}
 		msleep(100);
 	}
-	if (ctrl->state != NVME_CTRL_LIVE)
+	if (!nvme_change_ctrl_state(ctrl, NVME_CTRL_LIVE))
 		return;
 	nvme_start_queues(ctrl);
 		nvme_queue_scan(ctrl);
 		break;
 	case NVME_AER_NOTICE_FW_ACT_STARTING:
-		queue_work(nvme_wq, &ctrl->fw_act_work);
+		/*
+		 * We are (ab)using the RESETTING state to prevent subsequent
+		 * recovery actions from interfering with the controller's
+		 * firmware activation.
+		 */
+		if (nvme_change_ctrl_state(ctrl, NVME_CTRL_RESETTING))
+			queue_work(nvme_wq, &ctrl->fw_act_work);
 		break;
 #ifdef CONFIG_NVME_MULTIPATH
 	case NVME_AER_NOTICE_ANA:
 	INIT_WORK(&ctrl->async_event_work, nvme_async_event_work);
 	INIT_WORK(&ctrl->fw_act_work, nvme_fw_act_work);
 	INIT_WORK(&ctrl->delete_work, nvme_delete_ctrl_work);
+	init_waitqueue_head(&ctrl->state_wq);
 	INIT_DELAYED_WORK(&ctrl->ka_work, nvme_keep_alive_work);
 	memset(&ctrl->ka_cmd, 0, sizeof(ctrl->ka_cmd));

drivers/nvme/host/fabrics.h+1−2

 static inline bool nvmf_check_ready(struct nvme_ctrl *ctrl, struct request *rq,
 		bool queue_live)
 {
-	if (likely(ctrl->state == NVME_CTRL_LIVE ||
+	if (likely(ctrl->state == NVME_CTRL_LIVE))
-		   ctrl->state == NVME_CTRL_ADMIN_ONLY))
 		return true;
 	return __nvmf_check_ready(ctrl, rq, queue_live);
 }

drivers/nvme/host/nvme.h+4−1

 #include <linux/sed-opal.h>
 #include <linux/fault-inject.h>
 #include <linux/rcupdate.h>
+#include <linux/wait.h>
 #include <trace/events/block.h>
 enum nvme_ctrl_state {
 	NVME_CTRL_NEW,
 	NVME_CTRL_LIVE,
-	NVME_CTRL_ADMIN_ONLY,    /* Only admin queue live */
 	NVME_CTRL_RESETTING,
 	NVME_CTRL_CONNECTING,
 	NVME_CTRL_DELETING,
 	struct cdev cdev;
 	struct work_struct reset_work;
 	struct work_struct delete_work;
+	wait_queue_head_t state_wq;
 	struct nvme_subsystem *subsys;
 	struct list_head subsys_entry;
 bool nvme_cancel_request(struct request *req, void *data, bool reserved);
 bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,
 		enum nvme_ctrl_state new_state);
+bool nvme_wait_reset(struct nvme_ctrl *ctrl);
 int nvme_disable_ctrl(struct nvme_ctrl *ctrl);
 int nvme_enable_ctrl(struct nvme_ctrl *ctrl);
 int nvme_shutdown_ctrl(struct nvme_ctrl *ctrl);
 void nvme_stop_keep_alive(struct nvme_ctrl *ctrl);
 int nvme_reset_ctrl(struct nvme_ctrl *ctrl);
 int nvme_reset_ctrl_sync(struct nvme_ctrl *ctrl);
+int nvme_try_sched_reset(struct nvme_ctrl *ctrl);
 int nvme_delete_ctrl(struct nvme_ctrl *ctrl);
 int nvme_get_log(struct nvme_ctrl *ctrl, u32 nsid, u8 log_page, u8 lsp,

drivers/nvme/host/pci.c+49−34

@@ -773,7 +773,8 @@ static blk_status_t nvme_setup_prp_simple(struct nvme_dev *dev, · 772 unmodified lines
773	struct bio_vec *bv)	773	struct bio_vec *bv)
774	{	774	{
775	struct nvme_iod *iod = blk_mq_rq_to_pdu(req);	775	struct nvme_iod *iod = blk_mq_rq_to_pdu(req);
776	unsigned int first_prp_len = dev->ctrl.page_size - bv->bv_offset;	776	unsigned int offset = bv->bv_offset & (dev->ctrl.page_size - 1);
		777	unsigned int first_prp_len = dev->ctrl.page_size - offset;
777		778
778	iod->first_dma = dma_map_bvec(dev->dev, bv, rq_dma_dir(req), 0);	779	iod->first_dma = dma_map_bvec(dev->dev, bv, rq_dma_dir(req), 0);
779	if (dma_mapping_error(dev->dev, iod->first_dma))	780	if (dma_mapping_error(dev->dev, iod->first_dma))
@@ -2263,10 +2264,7 @@ static bool __nvme_disable_io_queues(struct nvme_dev *dev, u8 opcode) · 1483 unmodified lines
2263	return true;	2264	return true;
2264	}	2265	}
2265		2266
2266	/*	2267	static void nvme_dev_add(struct nvme_dev *dev)
2267	* return error value only when tagset allocation failed
2268	*/
2269	static int nvme_dev_add(struct nvme_dev *dev)
2270	{	2268	{
2271	int ret;	2269	int ret;
2272		2270
@@ -2296,7 +2294,7 @@ static int nvme_dev_add(struct nvme_dev *dev) · 23 unmodified lines
2296	if (ret) {	2294	if (ret) {
2297	dev_warn(dev->ctrl.device,	2295	dev_warn(dev->ctrl.device,
2298	"IO queues tagset allocation failed %d\n", ret);	2296	"IO queues tagset allocation failed %d\n", ret);
2299	return ret;	2297	return;
2300	}	2298	}
2301	dev->ctrl.tagset = &dev->tagset;	2299	dev->ctrl.tagset = &dev->tagset;
2302	} else {	2300	} else {
@@ -2307,7 +2305,6 @@ static int nvme_dev_add(struct nvme_dev *dev) · 4 unmodified lines
2307	}	2305	}
2308		2306
2309	nvme_dbbuf_set(dev);	2307	nvme_dbbuf_set(dev);
2310	return 0;
2311	}	2308	}
2312		2309
2313	static int nvme_pci_enable(struct nvme_dev *dev)	2310	static int nvme_pci_enable(struct nvme_dev *dev)
@@ -2467,6 +2464,14 @@ static void nvme_dev_disable(struct nvme_dev *dev, bool shutdown) · 153 unmodified lines
2467	mutex_unlock(&dev->shutdown_lock);	2464	mutex_unlock(&dev->shutdown_lock);
2468	}	2465	}
2469		2466
		2467	static int nvme_disable_prepare_reset(struct nvme_dev *dev, bool shutdown)
		2468	{
		2469	if (!nvme_wait_reset(&dev->ctrl))
		2470	return -EBUSY;
		2471	nvme_dev_disable(dev, shutdown);
		2472	return 0;
		2473	}
		2474
2470	static int nvme_setup_prp_pools(struct nvme_dev *dev)	2475	static int nvme_setup_prp_pools(struct nvme_dev *dev)
2471	{	2476	{
2472	dev->prp_page_pool = dma_pool_create("prp list page", dev->dev,	2477	dev->prp_page_pool = dma_pool_create("prp list page", dev->dev,
@@ -2490,14 +2495,20 @@ static void nvme_release_prp_pools(struct nvme_dev *dev) · 17 unmodified lines
2490	dma_pool_destroy(dev->prp_small_pool);	2495	dma_pool_destroy(dev->prp_small_pool);
2491	}	2496	}
2492		2497
		2498	static void nvme_free_tagset(struct nvme_dev *dev)
		2499	{
		2500	if (dev->tagset.tags)
		2501	blk_mq_free_tag_set(&dev->tagset);
		2502	dev->ctrl.tagset = NULL;
		2503	}
		2504
2493	static void nvme_pci_free_ctrl(struct nvme_ctrl *ctrl)	2505	static void nvme_pci_free_ctrl(struct nvme_ctrl *ctrl)
2494	{	2506	{
2495	struct nvme_dev *dev = to_nvme_dev(ctrl);	2507	struct nvme_dev *dev = to_nvme_dev(ctrl);
2496		2508
2497	nvme_dbbuf_dma_free(dev);	2509	nvme_dbbuf_dma_free(dev);
2498	put_device(dev->dev);	2510	put_device(dev->dev);
2499	if (dev->tagset.tags)	2511	nvme_free_tagset(dev);
2500	blk_mq_free_tag_set(&dev->tagset);
2501	if (dev->ctrl.admin_q)	2512	if (dev->ctrl.admin_q)
2502	blk_put_queue(dev->ctrl.admin_q);	2513	blk_put_queue(dev->ctrl.admin_q);
2503	kfree(dev->queues);	2514	kfree(dev->queues);
@@ -2508,6 +2519,11 @@ static void nvme_pci_free_ctrl(struct nvme_ctrl *ctrl) · 4 unmodified lines
2508		2519
2509	static void nvme_remove_dead_ctrl(struct nvme_dev *dev)	2520	static void nvme_remove_dead_ctrl(struct nvme_dev *dev)
2510	{	2521	{
		2522	/*
		2523	* Set state to deleting now to avoid blocking nvme_wait_reset(), which
		2524	* may be holding this pci_dev's device lock.
		2525	*/
		2526	nvme_change_ctrl_state(&dev->ctrl, NVME_CTRL_DELETING);
2511	nvme_get_ctrl(&dev->ctrl);	2527	nvme_get_ctrl(&dev->ctrl);
2512	nvme_dev_disable(dev, false);	2528	nvme_dev_disable(dev, false);
2513	nvme_kill_queues(&dev->ctrl);	2529	nvme_kill_queues(&dev->ctrl);
@@ -2521,7 +2537,6 @@ static void nvme_reset_work(struct work_struct *work) · 7 unmodified lines
2521	container_of(work, struct nvme_dev, ctrl.reset_work);	2537	container_of(work, struct nvme_dev, ctrl.reset_work);
2522	bool was_suspend = !!(dev->ctrl.ctrl_config & NVME_CC_SHN_NORMAL);	2538	bool was_suspend = !!(dev->ctrl.ctrl_config & NVME_CC_SHN_NORMAL);
2523	int result;	2539	int result;
2524	enum nvme_ctrl_state new_state = NVME_CTRL_LIVE;
2525		2540
2526	if (WARN_ON(dev->ctrl.state != NVME_CTRL_RESETTING)) {	2541	if (WARN_ON(dev->ctrl.state != NVME_CTRL_RESETTING)) {
2527	result = -ENODEV;	2542	result = -ENODEV;
@@ -2615,13 +2630,11 @@ static void nvme_reset_work(struct work_struct *work) · 87 unmodified lines
2615	dev_warn(dev->ctrl.device, "IO queues not created\n");	2630	dev_warn(dev->ctrl.device, "IO queues not created\n");
2616	nvme_kill_queues(&dev->ctrl);	2631	nvme_kill_queues(&dev->ctrl);
2617	nvme_remove_namespaces(&dev->ctrl);	2632	nvme_remove_namespaces(&dev->ctrl);
2618	new_state = NVME_CTRL_ADMIN_ONLY;	2633	nvme_free_tagset(dev);
2619	} else {	2634	} else {
2620	nvme_start_queues(&dev->ctrl);	2635	nvme_start_queues(&dev->ctrl);
2621	nvme_wait_freeze(&dev->ctrl);	2636	nvme_wait_freeze(&dev->ctrl);
2622	/* hit this only when allocate tagset fails */	2637	nvme_dev_add(dev);
2623	if (nvme_dev_add(dev))
2624	new_state = NVME_CTRL_ADMIN_ONLY;
2625	nvme_unfreeze(&dev->ctrl);	2638	nvme_unfreeze(&dev->ctrl);
2626	}	2639	}
2627		2640
@@ -2629,9 +2642,9 @@ static void nvme_reset_work(struct work_struct *work) · 1 unmodified line
2629	* If only admin queue live, keep it to do further investigation or	2642	* If only admin queue live, keep it to do further investigation or
2630	* recovery.	2643	* recovery.
2631	*/	2644	*/
2632	if (!nvme_change_ctrl_state(&dev->ctrl, new_state)) {	2645	if (!nvme_change_ctrl_state(&dev->ctrl, NVME_CTRL_LIVE)) {
2633	dev_warn(dev->ctrl.device,	2646	dev_warn(dev->ctrl.device,
2634	"failed to mark controller state %d\n", new_state);	2647	"failed to mark controller live state\n");
2635	result = -ENODEV;	2648	result = -ENODEV;
2636	goto out;	2649	goto out;
2637	}	2650	}
@@ -2672,7 +2685,7 @@ static int nvme_pci_reg_write32(struct nvme_ctrl *ctrl, u32 off, u32 val) · 34 unmodified lines
2672		2685
2673	static int nvme_pci_reg_read64(struct nvme_ctrl ctrl, u32 off, u64 val)	2686	static int nvme_pci_reg_read64(struct nvme_ctrl ctrl, u32 off, u64 val)
2674	{	2687	{
2675	*val = readq(to_nvme_dev(ctrl)->bar + off);	2688	*val = lo_hi_readq(to_nvme_dev(ctrl)->bar + off);
2676	return 0;	2689	return 0;
2677	}	2690	}
2678		2691
@@ -2836,19 +2849,28 @@ static int nvme_probe(struct pci_dev pdev, const struct pci_device_id id) · 157 unmodified lines
2836	static void nvme_reset_prepare(struct pci_dev *pdev)	2849	static void nvme_reset_prepare(struct pci_dev *pdev)
2837	{	2850	{
2838	struct nvme_dev *dev = pci_get_drvdata(pdev);	2851	struct nvme_dev *dev = pci_get_drvdata(pdev);
2839	nvme_dev_disable(dev, false);	2852
		2853	/*
		2854	* We don't need to check the return value from waiting for the reset
		2855	* state as pci_dev device lock is held, making it impossible to race
		2856	* with ->remove().
		2857	*/
		2858	nvme_disable_prepare_reset(dev, false);
		2859	nvme_sync_queues(&dev->ctrl);
2840	}	2860	}
2841		2861
2842	static void nvme_reset_done(struct pci_dev *pdev)	2862	static void nvme_reset_done(struct pci_dev *pdev)
2843	{	2863	{
2844	struct nvme_dev *dev = pci_get_drvdata(pdev);	2864	struct nvme_dev *dev = pci_get_drvdata(pdev);
2845	nvme_reset_ctrl_sync(&dev->ctrl);	2865
		2866	if (!nvme_try_sched_reset(&dev->ctrl))
		2867	flush_work(&dev->ctrl.reset_work);
2846	}	2868	}
2847		2869
2848	static void nvme_shutdown(struct pci_dev *pdev)	2870	static void nvme_shutdown(struct pci_dev *pdev)
2849	{	2871	{
2850	struct nvme_dev *dev = pci_get_drvdata(pdev);	2872	struct nvme_dev *dev = pci_get_drvdata(pdev);
2851	nvme_dev_disable(dev, true);	2873	nvme_disable_prepare_reset(dev, true);
2852	}	2874	}
2853		2875
2854	/*	2876	/*
@@ -2901,7 +2923,7 @@ static int nvme_resume(struct device *dev) · 46 unmodified lines
2901		2923
2902	if (ndev->last_ps == U32_MAX \|\|	2924	if (ndev->last_ps == U32_MAX \|\|
2903	nvme_set_power_state(ctrl, ndev->last_ps) != 0)	2925	nvme_set_power_state(ctrl, ndev->last_ps) != 0)
2904	nvme_reset_ctrl(ctrl);	2926	return nvme_try_sched_reset(&ndev->ctrl);
2905	return 0;	2927	return 0;
2906	}	2928	}
2907		2929
@@ -2929,17 +2951,14 @@ static int nvme_suspend(struct device *dev) · 21 unmodified lines
2929	*/	2951	*/
2930	if (pm_suspend_via_firmware() \|\| !ctrl->npss \|\|	2952	if (pm_suspend_via_firmware() \|\| !ctrl->npss \|\|
2931	!pcie_aspm_enabled(pdev) \|\|	2953	!pcie_aspm_enabled(pdev) \|\|
2932	(ndev->ctrl.quirks & NVME_QUIRK_SIMPLE_SUSPEND)) {	2954	(ndev->ctrl.quirks & NVME_QUIRK_SIMPLE_SUSPEND))
2933	nvme_dev_disable(ndev, true);	2955	return nvme_disable_prepare_reset(ndev, true);
2934	return 0;
2935	}
2936		2956
2937	nvme_start_freeze(ctrl);	2957	nvme_start_freeze(ctrl);
2938	nvme_wait_freeze(ctrl);	2958	nvme_wait_freeze(ctrl);
2939	nvme_sync_queues(ctrl);	2959	nvme_sync_queues(ctrl);
2940		2960
2941	if (ctrl->state != NVME_CTRL_LIVE &&	2961	if (ctrl->state != NVME_CTRL_LIVE)
2942	ctrl->state != NVME_CTRL_ADMIN_ONLY)
2943	goto unfreeze;	2962	goto unfreeze;
2944		2963
2945	ret = nvme_get_power_state(ctrl, &ndev->last_ps);	2964	ret = nvme_get_power_state(ctrl, &ndev->last_ps);
@@ -2965,9 +2984,8 @@ static int nvme_suspend(struct device *dev) · 19 unmodified lines
2965	* Clearing npss forces a controller reset on resume. The	2984	* Clearing npss forces a controller reset on resume. The
2966	* correct value will be resdicovered then.	2985	* correct value will be resdicovered then.
2967	*/	2986	*/
2968	nvme_dev_disable(ndev, true);	2987	ret = nvme_disable_prepare_reset(ndev, true);
2969	ctrl->npss = 0;	2988	ctrl->npss = 0;
2970	ret = 0;
2971	}	2989	}
2972	unfreeze:	2990	unfreeze:
2973	nvme_unfreeze(ctrl);	2991	nvme_unfreeze(ctrl);
@@ -2977,9 +2995,7 @@ unfreeze: · 3 unmodified lines
2977	static int nvme_simple_suspend(struct device *dev)	2995	static int nvme_simple_suspend(struct device *dev)
2978	{	2996	{
2979	struct nvme_dev *ndev = pci_get_drvdata(to_pci_dev(dev));	2997	struct nvme_dev *ndev = pci_get_drvdata(to_pci_dev(dev));
2980		2998	return nvme_disable_prepare_reset(ndev, true);
2981	nvme_dev_disable(ndev, true);
2982	return 0;
2983	}	2999	}
2984		3000
2985	static int nvme_simple_resume(struct device *dev)	3001	static int nvme_simple_resume(struct device *dev)
@@ -2987,8 +3003,7 @@ static int nvme_simple_resume(struct device *dev) · 1 unmodified line
2987	struct pci_dev *pdev = to_pci_dev(dev);	3003	struct pci_dev *pdev = to_pci_dev(dev);
2988	struct nvme_dev *ndev = pci_get_drvdata(pdev);	3004	struct nvme_dev *ndev = pci_get_drvdata(pdev);
2989		3005
2990	nvme_reset_ctrl(&ndev->ctrl);	3006	return nvme_try_sched_reset(&ndev->ctrl);
2991	return 0;
2992	}	3007	}
2993		3008
2994	static const struct dev_pm_ops nvme_dev_pm_ops = {	3009	static const struct dev_pm_ops nvme_dev_pm_ops = {

drivers/nvme/host/rdma.c+8−0

@@ -1701,6 +1701,14 @@ nvme_rdma_timeout(struct request *rq, bool reserved) · 1700 unmodified lines
1701	dev_warn(ctrl->ctrl.device, "I/O %d QID %d timeout\n",	1701	dev_warn(ctrl->ctrl.device, "I/O %d QID %d timeout\n",
1702	rq->tag, nvme_rdma_queue_idx(queue));	1702	rq->tag, nvme_rdma_queue_idx(queue));
1703		1703
		1704	/*
		1705	* Restart the timer if a controller reset is already scheduled. Any
		1706	* timed out commands would be handled before entering the connecting
		1707	* state.
		1708	*/
		1709	if (ctrl->ctrl.state == NVME_CTRL_RESETTING)
		1710	return BLK_EH_RESET_TIMER;
		1711
1704	if (ctrl->ctrl.state != NVME_CTRL_LIVE) {	1712	if (ctrl->ctrl.state != NVME_CTRL_LIVE) {
1705	/*	1713	/*
1706	* Teardown immediately if controller times out while starting	1714	* Teardown immediately if controller times out while starting

drivers/nvme/host/tcp.c+11−0

 	queue->sock->sk->sk_data_ready = nvme_tcp_data_ready;
 	queue->sock->sk->sk_state_change = nvme_tcp_state_change;
 	queue->sock->sk->sk_write_space = nvme_tcp_write_space;
+#ifdef CONFIG_NET_RX_BUSY_POLL
 	queue->sock->sk->sk_ll_usec = 1;
+#endif
 	write_unlock_bh(&queue->sock->sk->sk_callback_lock);
 	return 0;
 	struct nvme_tcp_ctrl *ctrl = req->queue->ctrl;
 	struct nvme_tcp_cmd_pdu *pdu = req->pdu;
+	/*
+	 * Restart the timer if a controller reset is already scheduled. Any
+	 * timed out commands would be handled before entering the connecting
+	 * state.
+	 */
+	if (ctrl->ctrl.state == NVME_CTRL_RESETTING)
+		return BLK_EH_RESET_TIMER;
 	dev_warn(ctrl->ctrl.device,
 		"queue %d: timeout request %#x type %d\n",
 		nvme_tcp_queue_id(req->queue), rq->tag, pdu->hdr.type);
 	ret = nvme_tcp_map_data(queue, rq);
 	if (unlikely(ret)) {
+		nvme_cleanup_cmd(rq);
 		dev_err(queue->ctrl->ctrl.device,
 			"Failed to map data (%d)\n", ret);
 		return ret;

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

 		iod->sg_table.sgl = iod->first_sgl;
 		if (sg_alloc_table_chained(&iod->sg_table,
 				blk_rq_nr_phys_segments(req),
-				iod->sg_table.sgl, SG_CHUNK_SIZE))
+				iod->sg_table.sgl, SG_CHUNK_SIZE)) {
+			nvme_cleanup_cmd(req);
 			return BLK_STS_RESOURCE;
+		}
 		iod->req.sg = iod->sg_table.sgl;
 		iod->req.sg_cnt = blk_rq_map_sg(req->q, req, iod->sg_table.sgl);

drivers/parisc/sba_iommu.c+0−8

@@ -678,14 +678,6 @@ static int sba_dma_supported( struct device *dev, u64 mask) · 677 unmodified lines
678	return(0);	678	return(0);
679	}	679	}
680		680
681	/* Documentation/DMA-API-HOWTO.txt tells drivers to try 64-bit
682	* first, then fall back to 32-bit if that fails.
683	* We are just "encouraging" 32-bit DMA masks here since we can
684	* never allow IOMMU bypass unless we add special support for ZX1.
685	*/
686	if (mask > ~0U)
687	return 0;
688
689	ioc = GET_IOC(dev);	681	ioc = GET_IOC(dev);
690	if (!ioc)	682	if (!ioc)
691	return 0;	683	return 0;

drivers/pci/pci.c+11−13

 	pci_update_current_state(dev, dev->current_state);
 }
-/**
- * pci_power_up - Put the given device into D0 forcibly
- * @dev: PCI device to power up
- */
-void pci_power_up(struct pci_dev *dev)
-{
-	if (platform_pci_power_manageable(dev))
-		platform_pci_set_power_state(dev, PCI_D0);
-	pci_raw_set_power_state(dev, PCI_D0);
-	pci_update_current_state(dev, PCI_D0);
-}
 /**
  * pci_platform_power_transition - Use platform to change device power state
  * @dev: PCI device to handle.
 }
 EXPORT_SYMBOL(pci_set_power_state);
+/**
+ * pci_power_up - Put the given device into D0 forcibly
+ * @dev: PCI device to power up
+ */
+void pci_power_up(struct pci_dev *dev)
+{
+	__pci_start_power_transition(dev, PCI_D0);
+	pci_raw_set_power_state(dev, PCI_D0);
+	pci_update_current_state(dev, PCI_D0);
+}
 /**
  * pci_choose_state - Choose the power state of a PCI device
  * @dev: PCI device to be suspended

drivers/platform/x86/classmate-laptop.c+0−12

 static int cmpc_accel_remove_v4(struct acpi_device *acpi)
 {
-	struct input_dev *inputdev;
-	struct cmpc_accel *accel;
-	inputdev = dev_get_drvdata(&acpi->dev);
-	accel = dev_get_drvdata(&inputdev->dev);
 	device_remove_file(&acpi->dev, &cmpc_accel_sensitivity_attr_v4);
 	device_remove_file(&acpi->dev, &cmpc_accel_g_select_attr_v4);
 	return cmpc_remove_acpi_notify_device(acpi);
 static int cmpc_accel_remove(struct acpi_device *acpi)
 {
-	struct input_dev *inputdev;
-	struct cmpc_accel *accel;
-	inputdev = dev_get_drvdata(&acpi->dev);
-	accel = dev_get_drvdata(&inputdev->dev);
 	device_remove_file(&acpi->dev, &cmpc_accel_sensitivity_attr);
 	return cmpc_remove_acpi_notify_device(acpi);
 }

drivers/platform/x86/i2c-multi-instantiate.c+1−0

@@ -108,6 +108,7 @@ static int i2c_multi_inst_probe(struct platform_device *pdev) · 107 unmodified lines
108	if (ret < 0) {	108	if (ret < 0) {
109	dev_dbg(dev, "Error requesting irq at index %d: %d\n",	109	dev_dbg(dev, "Error requesting irq at index %d: %d\n",
110	inst_data[i].irq_idx, ret);	110	inst_data[i].irq_idx, ret);
		111	goto error;
111	}	112	}
112	board_info.irq = ret;	113	board_info.irq = ret;
113	break;	114	break;

drivers/platform/x86/intel_punit_ipc.c+1−2

@@ -293,9 +293,8 @@ static int intel_punit_ipc_probe(struct platform_device *pdev) · 292 unmodified lines
293		293
294	platform_set_drvdata(pdev, punit_ipcdev);	294	platform_set_drvdata(pdev, punit_ipcdev);
295		295
296	irq = platform_get_irq(pdev, 0);	296	irq = platform_get_irq_optional(pdev, 0);
297	if (irq < 0) {	297	if (irq < 0) {
298	punit_ipcdev->irq = 0;
299	dev_warn(&pdev->dev, "Invalid IRQ, using polling mode\n");	298	dev_warn(&pdev->dev, "Invalid IRQ, using polling mode\n");
300	} else {	299	} else {
301	ret = devm_request_irq(&pdev->dev, irq, intel_punit_ioc,	300	ret = devm_request_irq(&pdev->dev, irq, intel_punit_ioc,

drivers/ptp/Kconfig+2−2

@@ -97,8 +97,8 @@ config PTP_1588_CLOCK_PCH · 96 unmodified lines
97	help	97	help
98	This driver adds support for using the PCH EG20T as a PTP	98	This driver adds support for using the PCH EG20T as a PTP
99	clock. The hardware supports time stamping of PTP packets	99	clock. The hardware supports time stamping of PTP packets
100	when using the end-to-end delay (E2E) mechansim. The peer	100	when using the end-to-end delay (E2E) mechanism. The peer
101	delay mechansim (P2P) is not supported.	101	delay mechanism (P2P) is not supported.
102		102
103	This clock is only useful if your PTP programs are getting	103	This clock is only useful if your PTP programs are getting
104	hardware time stamps on the PTP Ethernet packets using the	104	hardware time stamps on the PTP Ethernet packets using the

drivers/s390/cio/cio.h+1−0

@@ -113,6 +113,7 @@ struct subchannel { · 112 unmodified lines
113	enum sch_todo todo;	113	enum sch_todo todo;
114	struct work_struct todo_work;	114	struct work_struct todo_work;
115	struct schib_config config;	115	struct schib_config config;
		116	u64 dma_mask;
116	char driver_override; / Driver name to force a match */	117	char driver_override; / Driver name to force a match */
117	} __attribute__ ((aligned(8)));	118	} __attribute__ ((aligned(8)));
118		119

drivers/s390/cio/css.c+6−1

 	 * belong to a subchannel need to fit 31 bit width (e.g. ccw).
 	 */
 	sch->dev.coherent_dma_mask = DMA_BIT_MASK(31);
-	sch->dev.dma_mask = &sch->dev.coherent_dma_mask;
+	/*
+	 * But we don't have such restrictions imposed on the stuff that
+	 * is handled by the streaming API.
+	 */
+	sch->dma_mask = DMA_BIT_MASK(64);
+	sch->dev.dma_mask = &sch->dma_mask;
 	return sch;
 err:

drivers/s390/cio/device.c+1−1

@@ -710,7 +710,7 @@ static struct ccw_device * io_subchannel_allocate_dev(struct subchannel *sch) · 709 unmodified lines
710	if (!cdev->private)	710	if (!cdev->private)
711	goto err_priv;	711	goto err_priv;
712	cdev->dev.coherent_dma_mask = sch->dev.coherent_dma_mask;	712	cdev->dev.coherent_dma_mask = sch->dev.coherent_dma_mask;
713	cdev->dev.dma_mask = &cdev->dev.coherent_dma_mask;	713	cdev->dev.dma_mask = sch->dev.dma_mask;
714	dma_pool = cio_gp_dma_create(&cdev->dev, 1);	714	dma_pool = cio_gp_dma_create(&cdev->dev, 1);
715	if (!dma_pool)	715	if (!dma_pool)
716	goto err_dma_pool;	716	goto err_dma_pool;

drivers/s390/net/qeth_l2_main.c+15−8

 static void qeth_l2_vnicc_init(struct qeth_card *card)
 {
 	u32 *timeout = &card->options.vnicc.learning_timeout;
+	bool enable, error = false;
 	unsigned int chars_len, i;
 	unsigned long chars_tmp;
 	u32 sup_cmds, vnicc;
-	bool enable, error;
 	QETH_CARD_TEXT(card, 2, "vniccini");
 	/* reset rx_bcast */
 	chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;
 	for_each_set_bit(i, &chars_tmp, chars_len) {
 		vnicc = BIT(i);
-		qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds);
+		if (qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds)) {
-		if (!(sup_cmds & IPA_VNICC_SET_TIMEOUT) ||
+			sup_cmds = 0;
-		    !(sup_cmds & IPA_VNICC_GET_TIMEOUT))
+			error = true;
+		}
+		if ((sup_cmds & IPA_VNICC_SET_TIMEOUT) &&
+		    (sup_cmds & IPA_VNICC_GET_TIMEOUT))
+			card->options.vnicc.getset_timeout_sup |= vnicc;
+		else
 			card->options.vnicc.getset_timeout_sup &= ~vnicc;
-		if (!(sup_cmds & IPA_VNICC_ENABLE) ||
+		if ((sup_cmds & IPA_VNICC_ENABLE) &&
-		    !(sup_cmds & IPA_VNICC_DISABLE))
+		    (sup_cmds & IPA_VNICC_DISABLE))
+			card->options.vnicc.set_char_sup |= vnicc;
+		else
 			card->options.vnicc.set_char_sup &= ~vnicc;
 	}
 	/* enforce assumed default values and recover settings, if changed  */
-	error = qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
+	error |= qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
-					      timeout);
+					       timeout);
 	chars_tmp = card->options.vnicc.wanted_chars ^ QETH_VNICC_DEFAULT;
 	chars_tmp |= QETH_VNICC_BRIDGE_INVISIBLE;
 	chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;

drivers/s390/scsi/zfcp_fsf.c+13−3

 struct kmem_cache *zfcp_fsf_qtcb_cache;
+static bool ber_stop = true;
+module_param(ber_stop, bool, 0600);
+MODULE_PARM_DESC(ber_stop,
+		 "Shuts down FCP devices for FCP channels that report a bit-error count in excess of its threshold (default on)");
 static void zfcp_fsf_request_timeout_handler(struct timer_list *t)
 {
 	struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);
 	case FSF_STATUS_READ_SENSE_DATA_AVAIL:
 		break;
 	case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
-		dev_warn(&adapter->ccw_device->dev,
-			 "The error threshold for checksum statistics "
-			 "has been exceeded\n");
 		zfcp_dbf_hba_bit_err("fssrh_3", req);
+		if (ber_stop) {
+			dev_warn(&adapter->ccw_device->dev,
+				 "All paths over this FCP device are disused because of excessive bit errors\n");
+			zfcp_erp_adapter_shutdown(adapter, 0, "fssrh_b");
+		} else {
+			dev_warn(&adapter->ccw_device->dev,
+				 "The error threshold for checksum statistics has been exceeded\n");
+		}
 		break;
 	case FSF_STATUS_READ_LINK_DOWN:
 		zfcp_fsf_status_read_link_down(req);

drivers/scsi/qla2xxx/qla_isr.c+0−2

@@ -2837,8 +2837,6 @@ qla2x00_status_cont_entry(struct rsp_que rsp, sts_cont_entry_t pkt) · 2836 unmodified lines
2837	if (sense_len == 0) {	2837	if (sense_len == 0) {
2838	rsp->status_srb = NULL;	2838	rsp->status_srb = NULL;
2839	sp->done(sp, cp->result);	2839	sp->done(sp, cp->result);
2840	} else {
2841	WARN_ON_ONCE(true);
2842	}	2840	}
2843	}	2841	}
2844		2842

drivers/scsi/scsi_error.c+3−0

 	ses->data_direction = scmd->sc_data_direction;
 	ses->sdb = scmd->sdb;
 	ses->result = scmd->result;
+	ses->resid_len = scmd->req.resid_len;
 	ses->underflow = scmd->underflow;
 	ses->prot_op = scmd->prot_op;
 	ses->eh_eflags = scmd->eh_eflags;
 	memset(scmd->cmnd, 0, BLK_MAX_CDB);
 	memset(&scmd->sdb, 0, sizeof(scmd->sdb));
 	scmd->result = 0;
+	scmd->req.resid_len = 0;
 	if (sense_bytes) {
 		scmd->sdb.length = min_t(unsigned, SCSI_SENSE_BUFFERSIZE,
 	scmd->sc_data_direction = ses->data_direction;
 	scmd->sdb = ses->sdb;
 	scmd->result = ses->result;
+	scmd->req.resid_len = ses->resid_len;
 	scmd->underflow = ses->underflow;
 	scmd->prot_op = ses->prot_op;
 	scmd->eh_eflags = ses->eh_eflags;

drivers/scsi/scsi_lib.c+3−1

 	.init_request	= scsi_mq_init_request,
 	.exit_request	= scsi_mq_exit_request,
 	.initialize_rq_fn = scsi_initialize_rq,
+	.cleanup_rq	= scsi_cleanup_rq,
 	.busy		= scsi_mq_lld_busy,
 	.map_queues	= scsi_map_queues,
 };
 {
 	struct scsi_device *sdev = NULL;
-	if (q->mq_ops == &scsi_mq_ops)
+	if (q->mq_ops == &scsi_mq_ops_no_commit ||
+	    q->mq_ops == &scsi_mq_ops)
 		sdev = q->queuedata;
 	if (!sdev || !get_device(&sdev->sdev_gendev))
 		sdev = NULL;

drivers/scsi/sd.c+2−1

@@ -1654,7 +1654,8 @@ static int sd_sync_cache(struct scsi_disk sdkp, struct scsi_sense_hdr sshdr) · 1653 unmodified lines
1654	/* we need to evaluate the error return */	1654	/* we need to evaluate the error return */
1655	if (scsi_sense_valid(sshdr) &&	1655	if (scsi_sense_valid(sshdr) &&
1656	(sshdr->asc == 0x3a \|\| /* medium not present */	1656	(sshdr->asc == 0x3a \|\| /* medium not present */
1657	sshdr->asc == 0x20)) /* invalid command */	1657	sshdr->asc == 0x20 \|\| /* invalid command */
		1658	(sshdr->asc == 0x74 && sshdr->ascq == 0x71))) /* drive is password locked */
1658	/* this is no error here */	1659	/* this is no error here */
1659	return 0;	1660	return 0;
1660		1661

drivers/staging/exfat/Kconfig+2−1

+# SPDX-License-Identifier: GPL-2.0
 config EXFAT_FS
 	tristate "exFAT fs support"
 	depends on BLOCK
 	  This adds support for the exFAT file system.
 config EXFAT_DONT_MOUNT_VFAT
-	bool "Prohibit mounting of fat/vfat filesysems by exFAT"
+	bool "Prohibit mounting of fat/vfat filesystems by exFAT"
 	depends on EXFAT_FS
 	default y
 	help

drivers/staging/exfat/Makefile+1−1

@@ -1,4 +1,4 @@
1	# SPDX-License-Identifier: GPL-2.0	1	# SPDX-License-Identifier: GPL-2.0-or-later
2		2
3	obj-$(CONFIG_EXFAT_FS) += exfat.o	3	obj-$(CONFIG_EXFAT_FS) += exfat.o
4		4

drivers/staging/exfat/exfat.h+1−1

@@ -1,4 +1,4 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
2	/*	2	/*
3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.	3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
4	*/	4	*/

drivers/staging/exfat/exfat_blkdev.c+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*	2	/*
3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.	3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
4	*/	4	*/

drivers/staging/exfat/exfat_cache.c+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*	2	/*
3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.	3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
4	*/	4	*/

drivers/staging/exfat/exfat_core.c+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*	2	/*
3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.	3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
4	*/	4	*/

drivers/staging/exfat/exfat_nls.c+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*	2	/*
3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.	3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
4	*/	4	*/

drivers/staging/exfat/exfat_super.c+4−3

-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
  */
 #include <linux/init.h>
 #include <linux/time.h>
 #include <linux/slab.h>
+#include <linux/mm.h>
 #include <linux/seq_file.h>
 #include <linux/pagemap.h>
 #include <linux/mpage.h>
 		kfree(sbi->options.iocharset);
 	/* mutex_init is in exfat_fill_super function. only for 3.7+ */
 	mutex_destroy(&sbi->s_lock);
-	kfree(sbi);
+	kvfree(sbi);
 }
 static void exfat_put_super(struct super_block *sb)
 	 * the filesystem, since we're only just about to mount
 	 * it and have no inodes etc active!
 	 */
-	sbi = kzalloc(sizeof(struct exfat_sb_info), GFP_KERNEL);
+	sbi = kvzalloc(sizeof(*sbi), GFP_KERNEL);
 	if (!sbi)
 		return -ENOMEM;
 	mutex_init(&sbi->s_lock);

drivers/staging/exfat/exfat_upcase.c+1−1

@@ -1,4 +1,4 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*	2	/*
3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.	3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
4	*/	4	*/

drivers/staging/fbtft/Kconfig+1−11

 # SPDX-License-Identifier: GPL-2.0
 menuconfig FB_TFT
 	tristate "Support for small TFT LCD display modules"
-	depends on FB && SPI
+	depends on FB && SPI && OF
 	depends on GPIOLIB || COMPILE_TEST
 	select FB_SYS_FILLRECT
 	select FB_SYS_COPYAREA
 	depends on FB_TFT
 	help
 	  Generic Framebuffer support for WATTEROTT
-config FB_FLEX
-	tristate "Generic FB driver for TFT LCD displays"
-	depends on FB_TFT
-	help
-	  Generic Framebuffer support for TFT LCD displays.
-config FB_TFT_FBTFT_DEVICE
-	tristate "Module to for adding FBTFT devices"
-	depends on FB_TFT

drivers/staging/fbtft/Makefile+0−4

@@ -36,7 +36,3 @@ obj-$(CONFIG_FB_TFT_UC1611) += fb_uc1611.o · 35 unmodified lines
36	obj-$(CONFIG_FB_TFT_UC1701) += fb_uc1701.o	36	obj-$(CONFIG_FB_TFT_UC1701) += fb_uc1701.o
37	obj-$(CONFIG_FB_TFT_UPD161704) += fb_upd161704.o	37	obj-$(CONFIG_FB_TFT_UPD161704) += fb_upd161704.o
38	obj-$(CONFIG_FB_TFT_WATTEROTT) += fb_watterott.o	38	obj-$(CONFIG_FB_TFT_WATTEROTT) += fb_watterott.o
39	obj-$(CONFIG_FB_FLEX) += flexfb.o
40
41	# Device modules
42	obj-$(CONFIG_FB_TFT_FBTFT_DEVICE) += fbtft_device.o

drivers/staging/fbtft/fbtft-core.c+5−2

 	if (par->gamma.curves && gamma) {
 		if (fbtft_gamma_parse_str(par, par->gamma.curves, gamma,
 					  strlen(gamma)))
-			goto alloc_fail;
+			goto release_framebuf;
 	}
 	/* Transmit buffer */
 	if (txbuflen > 0) {
 		txbuf = devm_kzalloc(par->info->device, txbuflen, GFP_KERNEL);
 		if (!txbuf)
-			goto alloc_fail;
+			goto release_framebuf;
 		par->txbuf.buf = txbuf;
 		par->txbuf.len = txbuflen;
 	}
 	return info;
+release_framebuf:
+	framebuffer_release(info);
 alloc_fail:
 	vfree(vmem);

drivers/staging/fbtft/fbtft_device.c+0−1261

@@ -1,1261 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0+
2	/*
3	*
4	* Copyright (C) 2013, Noralf Tronnes
5	*/
6
7	#define pr_fmt(fmt) "fbtft_device: " fmt
8	#include <linux/module.h>
9	#include <linux/kernel.h>
10	#include <linux/init.h>
11	#include <linux/gpio/consumer.h>
12	#include <linux/spi/spi.h>
13	#include <video/mipi_display.h>
14
15	#include "fbtft.h"
16
17	#define MAX_GPIOS 32
18
19	static struct spi_device *spi_device;
20	static struct platform_device *p_device;
21
22	static char *name;
23	module_param(name, charp, 0000);
24	MODULE_PARM_DESC(name,
25	"Devicename (required). name=list => list all supported devices.");
26
27	static unsigned int rotate;
28	module_param(rotate, uint, 0000);
29	MODULE_PARM_DESC(rotate,
30	"Angle to rotate display counter clockwise: 0, 90, 180, 270");
31
32	static unsigned int busnum;
33	module_param(busnum, uint, 0000);
34	MODULE_PARM_DESC(busnum, "SPI bus number (default=0)");
35
36	static unsigned int cs;
37	module_param(cs, uint, 0000);
38	MODULE_PARM_DESC(cs, "SPI chip select (default=0)");
39
40	static unsigned int speed;
41	module_param(speed, uint, 0000);
42	MODULE_PARM_DESC(speed, "SPI speed (override device default)");
43
44	static int mode = -1;
45	module_param(mode, int, 0000);
46	MODULE_PARM_DESC(mode, "SPI mode (override device default)");
47
48	static unsigned int fps;
49	module_param(fps, uint, 0000);
50	MODULE_PARM_DESC(fps, "Frames per second (override driver default)");
51
52	static char *gamma;
53	module_param(gamma, charp, 0000);
54	MODULE_PARM_DESC(gamma,
55	"String representation of Gamma Curve(s). Driver specific.");
56
57	static int txbuflen;
58	module_param(txbuflen, int, 0000);
59	MODULE_PARM_DESC(txbuflen, "txbuflen (override driver default)");
60
61	static int bgr = -1;
62	module_param(bgr, int, 0000);
63	MODULE_PARM_DESC(bgr,
64	"BGR bit (supported by some drivers).");
65
66	static unsigned int startbyte;
67	module_param(startbyte, uint, 0000);
68	MODULE_PARM_DESC(startbyte, "Sets the Start byte used by some SPI displays.");
69
70	static bool custom;
71	module_param(custom, bool, 0000);
72	MODULE_PARM_DESC(custom, "Add a custom display device. Use speed= argument to make it a SPI device, else platform_device");
73
74	static unsigned int width;
75	module_param(width, uint, 0000);
76	MODULE_PARM_DESC(width, "Display width, used with the custom argument");
77
78	static unsigned int height;
79	module_param(height, uint, 0000);
80	MODULE_PARM_DESC(height, "Display height, used with the custom argument");
81
82	static unsigned int buswidth = 8;
83	module_param(buswidth, uint, 0000);
84	MODULE_PARM_DESC(buswidth, "Display bus width, used with the custom argument");
85
86	static s16 init[FBTFT_MAX_INIT_SEQUENCE];
87	static int init_num;
88	module_param_array(init, short, &init_num, 0000);
89	MODULE_PARM_DESC(init, "Init sequence, used with the custom argument");
90
91	static unsigned long debug;
92	module_param(debug, ulong, 0000);
93	MODULE_PARM_DESC(debug,
94	"level: 0-7 (the remaining 29 bits is for advanced usage)");
95
96	static unsigned int verbose = 3;
97	module_param(verbose, uint, 0000);
98	MODULE_PARM_DESC(verbose,
99	"0 silent, >1 show devices, >2 show devices before (default=3)");
100
101	struct fbtft_device_display {
102	char *name;
103	struct spi_board_info *spi;
104	struct platform_device *pdev;
105	};
106
107	static void fbtft_device_pdev_release(struct device *dev);
108
109	static int write_gpio16_wr_slow(struct fbtft_par par, void buf, size_t len);
110	static void adafruit18_green_tab_set_addr_win(struct fbtft_par *par,
111	int xs, int ys, int xe, int ye);
112
113	#define ADAFRUIT18_GAMMA \
114	"02 1c 07 12 37 32 29 2d 29 25 2B 39 00 01 03 10\n" \
115	"03 1d 07 06 2E 2C 29 2D 2E 2E 37 3F 00 00 02 10"
116
117	#define CBERRY28_GAMMA \
118	"D0 00 14 15 13 2C 42 43 4E 09 16 14 18 21\n" \
119	"D0 00 14 15 13 0B 43 55 53 0C 17 14 23 20"
120
121	static const s16 cberry28_init_sequence[] = {
122	/* turn off sleep mode */
123	-1, MIPI_DCS_EXIT_SLEEP_MODE,
124	-2, 120,
125
126	/* set pixel format to RGB-565 */
127	-1, MIPI_DCS_SET_PIXEL_FORMAT, MIPI_DCS_PIXEL_FMT_16BIT,
128
129	-1, 0xB2, 0x0C, 0x0C, 0x00, 0x33, 0x33,
130
131	/*
132	* VGH = 13.26V
133	* VGL = -10.43V
134	*/
135	-1, 0xB7, 0x35,
136
137	/*
138	* VDV and VRH register values come from command write
139	* (instead of NVM)
140	*/
141	-1, 0xC2, 0x01, 0xFF,
142
143	/*
144	* VAP = 4.7V + (VCOM + VCOM offset + 0.5 * VDV)
145	* VAN = -4.7V + (VCOM + VCOM offset + 0.5 * VDV)
146	*/
147	-1, 0xC3, 0x17,
148
149	/* VDV = 0V */
150	-1, 0xC4, 0x20,
151
152	/* VCOM = 0.675V */
153	-1, 0xBB, 0x17,
154
155	/* VCOM offset = 0V */
156	-1, 0xC5, 0x20,
157
158	/*
159	* AVDD = 6.8V
160	* AVCL = -4.8V
161	* VDS = 2.3V
162	*/
163	-1, 0xD0, 0xA4, 0xA1,
164
165	-1, MIPI_DCS_SET_DISPLAY_ON,
166
167	-3,
168	};
169
170	static const s16 hy28b_init_sequence[] = {
171	-1, 0x00e7, 0x0010, -1, 0x0000, 0x0001,
172	-1, 0x0001, 0x0100, -1, 0x0002, 0x0700,
173	-1, 0x0003, 0x1030, -1, 0x0004, 0x0000,
174	-1, 0x0008, 0x0207, -1, 0x0009, 0x0000,
175	-1, 0x000a, 0x0000, -1, 0x000c, 0x0001,
176	-1, 0x000d, 0x0000, -1, 0x000f, 0x0000,
177	-1, 0x0010, 0x0000, -1, 0x0011, 0x0007,
178	-1, 0x0012, 0x0000, -1, 0x0013, 0x0000,
179	-2, 50, -1, 0x0010, 0x1590, -1, 0x0011,
180	0x0227, -2, 50, -1, 0x0012, 0x009c, -2, 50,
181	-1, 0x0013, 0x1900, -1, 0x0029, 0x0023,
182	-1, 0x002b, 0x000e, -2, 50,
183	-1, 0x0020, 0x0000, -1, 0x0021, 0x0000,
184	-2, 50, -1, 0x0050, 0x0000,
185	-1, 0x0051, 0x00ef, -1, 0x0052, 0x0000,
186	-1, 0x0053, 0x013f, -1, 0x0060, 0xa700,
187	-1, 0x0061, 0x0001, -1, 0x006a, 0x0000,
188	-1, 0x0080, 0x0000, -1, 0x0081, 0x0000,
189	-1, 0x0082, 0x0000, -1, 0x0083, 0x0000,
190	-1, 0x0084, 0x0000, -1, 0x0085, 0x0000,
191	-1, 0x0090, 0x0010, -1, 0x0092, 0x0000,
192	-1, 0x0093, 0x0003, -1, 0x0095, 0x0110,
193	-1, 0x0097, 0x0000, -1, 0x0098, 0x0000,
194	-1, 0x0007, 0x0133, -1, 0x0020, 0x0000,
195	-1, 0x0021, 0x0000, -2, 100, -3 };
196
197	#define HY28B_GAMMA \
198	"04 1F 4 7 7 0 7 7 6 0\n" \
199	"0F 00 1 7 4 0 0 0 6 7"
200
201	static const s16 pitft_init_sequence[] = {
202	-1, MIPI_DCS_SOFT_RESET,
203	-2, 5,
204	-1, MIPI_DCS_SET_DISPLAY_OFF,
205	-1, 0xEF, 0x03, 0x80, 0x02,
206	-1, 0xCF, 0x00, 0xC1, 0x30,
207	-1, 0xED, 0x64, 0x03, 0x12, 0x81,
208	-1, 0xE8, 0x85, 0x00, 0x78,
209	-1, 0xCB, 0x39, 0x2C, 0x00, 0x34, 0x02,
210	-1, 0xF7, 0x20,
211	-1, 0xEA, 0x00, 0x00,
212	-1, 0xC0, 0x23,
213	-1, 0xC1, 0x10,
214	-1, 0xC5, 0x3E, 0x28,
215	-1, 0xC7, 0x86,
216	-1, MIPI_DCS_SET_PIXEL_FORMAT, 0x55,
217	-1, 0xB1, 0x00, 0x18,
218	-1, 0xB6, 0x08, 0x82, 0x27,
219	-1, 0xF2, 0x00,
220	-1, MIPI_DCS_SET_GAMMA_CURVE, 0x01,
221	-1, 0xE0, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, 0x4E,
222	0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00,
223	-1, 0xE1, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, 0x31,
224	0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F,
225	-1, MIPI_DCS_EXIT_SLEEP_MODE,
226	-2, 100,
227	-1, MIPI_DCS_SET_DISPLAY_ON,
228	-2, 20,
229	-3
230	};
231
232	static const s16 waveshare32b_init_sequence[] = {
233	-1, 0xCB, 0x39, 0x2C, 0x00, 0x34, 0x02,
234	-1, 0xCF, 0x00, 0xC1, 0x30,
235	-1, 0xE8, 0x85, 0x00, 0x78,
236	-1, 0xEA, 0x00, 0x00,
237	-1, 0xED, 0x64, 0x03, 0x12, 0x81,
238	-1, 0xF7, 0x20,
239	-1, 0xC0, 0x23,
240	-1, 0xC1, 0x10,
241	-1, 0xC5, 0x3E, 0x28,
242	-1, 0xC7, 0x86,
243	-1, MIPI_DCS_SET_ADDRESS_MODE, 0x28,
244	-1, MIPI_DCS_SET_PIXEL_FORMAT, 0x55,
245	-1, 0xB1, 0x00, 0x18,
246	-1, 0xB6, 0x08, 0x82, 0x27,
247	-1, 0xF2, 0x00,
248	-1, MIPI_DCS_SET_GAMMA_CURVE, 0x01,
249	-1, 0xE0, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, 0x4E,
250	0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00,
251	-1, 0xE1, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, 0x31,
252	0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F,
253	-1, MIPI_DCS_EXIT_SLEEP_MODE,
254	-2, 120,
255	-1, MIPI_DCS_SET_DISPLAY_ON,
256	-1, MIPI_DCS_WRITE_MEMORY_START,
257	-3
258	};
259
260	#define PIOLED_GAMMA "0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 " \
261	"2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 " \
262	"3 3 3 4 4 4 4 4 4 4 4 4 4 4 4"
263
264	/* Supported displays in alphabetical order */
265	static struct fbtft_device_display displays[] = {
266	{
267	.name = "adafruit18",
268	.spi = &(struct spi_board_info) {
269	.modalias = "fb_st7735r",
270	.max_speed_hz = 32000000,
271	.mode = SPI_MODE_0,
272	.platform_data = &(struct fbtft_platform_data) {
273	.display = {
274	.buswidth = 8,
275	.backlight = 1,
276	},
277	.gamma = ADAFRUIT18_GAMMA,
278	}
279	}
280	}, {
281	.name = "adafruit18_green",
282	.spi = &(struct spi_board_info) {
283	.modalias = "fb_st7735r",
284	.max_speed_hz = 4000000,
285	.mode = SPI_MODE_0,
286	.platform_data = &(struct fbtft_platform_data) {
287	.display = {
288	.buswidth = 8,
289	.backlight = 1,
290	.fbtftops.set_addr_win =
291	adafruit18_green_tab_set_addr_win,
292	},
293	.bgr = true,
294	.gamma = ADAFRUIT18_GAMMA,
295	}
296	}
297	}, {
298	.name = "adafruit22",
299	.spi = &(struct spi_board_info) {
300	.modalias = "fb_hx8340bn",
301	.max_speed_hz = 32000000,
302	.mode = SPI_MODE_0,
303	.platform_data = &(struct fbtft_platform_data) {
304	.display = {
305	.buswidth = 9,
306	.backlight = 1,
307	},
308	.bgr = true,
309	}
310	}
311	}, {
312	.name = "adafruit22a",
313	.spi = &(struct spi_board_info) {
314	.modalias = "fb_ili9340",
315	.max_speed_hz = 32000000,
316	.mode = SPI_MODE_0,
317	.platform_data = &(struct fbtft_platform_data) {
318	.display = {
319	.buswidth = 8,
320	.backlight = 1,
321	},
322	.bgr = true,
323	}
324	}
325	}, {
326	.name = "adafruit28",
327	.spi = &(struct spi_board_info) {
328	.modalias = "fb_ili9341",
329	.max_speed_hz = 32000000,
330	.mode = SPI_MODE_0,
331	.platform_data = &(struct fbtft_platform_data) {
332	.display = {
333	.buswidth = 8,
334	.backlight = 1,
335	},
336	.bgr = true,
337	}
338	}
339	}, {
340	.name = "adafruit13m",
341	.spi = &(struct spi_board_info) {
342	.modalias = "fb_ssd1306",
343	.max_speed_hz = 16000000,
344	.mode = SPI_MODE_0,
345	.platform_data = &(struct fbtft_platform_data) {
346	.display = {
347	.buswidth = 8,
348	},
349	}
350	}
351	}, {
352	.name = "admatec_c-berry28",
353	.spi = &(struct spi_board_info) {
354	.modalias = "fb_st7789v",
355	.max_speed_hz = 48000000,
356	.mode = SPI_MODE_0,
357	.platform_data = &(struct fbtft_platform_data) {
358	.display = {
359	.buswidth = 8,
360	.backlight = 1,
361	.init_sequence = cberry28_init_sequence,
362	},
363	.gamma = CBERRY28_GAMMA,
364	}
365	}
366	}, {
367	.name = "agm1264k-fl",
368	.pdev = &(struct platform_device) {
369	.name = "fb_agm1264k-fl",
370	.id = 0,
371	.dev = {
372	.release = fbtft_device_pdev_release,
373	.platform_data = &(struct fbtft_platform_data) {
374	.display = {
375	.buswidth = 8,
376	.backlight = FBTFT_ONBOARD_BACKLIGHT,
377	},
378	},
379	}
380	}
381	}, {
382	.name = "dogs102",
383	.spi = &(struct spi_board_info) {
384	.modalias = "fb_uc1701",
385	.max_speed_hz = 8000000,
386	.mode = SPI_MODE_0,
387	.platform_data = &(struct fbtft_platform_data) {
388	.display = {
389	.buswidth = 8,
390	},
391	.bgr = true,
392	}
393	}
394	}, {
395	.name = "er_tftm050_2",
396	.spi = &(struct spi_board_info) {
397	.modalias = "fb_ra8875",
398	.max_speed_hz = 5000000,
399	.mode = SPI_MODE_3,
400	.platform_data = &(struct fbtft_platform_data) {
401	.display = {
402	.buswidth = 8,
403	.backlight = 1,
404	.width = 480,
405	.height = 272,
406	},
407	.bgr = true,
408	}
409	}
410	}, {
411	.name = "er_tftm070_5",
412	.spi = &(struct spi_board_info) {
413	.modalias = "fb_ra8875",
414	.max_speed_hz = 5000000,
415	.mode = SPI_MODE_3,
416	.platform_data = &(struct fbtft_platform_data) {
417	.display = {
418	.buswidth = 8,
419	.backlight = 1,
420	.width = 800,
421	.height = 480,
422	},
423	.bgr = true,
424	}
425	}
426	}, {
427	.name = "ew24ha0",
428	.spi = &(struct spi_board_info) {
429	.modalias = "fb_uc1611",
430	.max_speed_hz = 32000000,
431	.mode = SPI_MODE_3,
432	.platform_data = &(struct fbtft_platform_data) {
433	.display = {
434	.buswidth = 8,
435	},
436	}
437	}
438	}, {
439	.name = "ew24ha0_9bit",
440	.spi = &(struct spi_board_info) {
441	.modalias = "fb_uc1611",
442	.max_speed_hz = 32000000,
443	.mode = SPI_MODE_3,
444	.platform_data = &(struct fbtft_platform_data) {
445	.display = {
446	.buswidth = 9,
447	},
448	}
449	}
450	}, {
451	.name = "flexfb",
452	.spi = &(struct spi_board_info) {
453	.modalias = "flexfb",
454	.max_speed_hz = 32000000,
455	.mode = SPI_MODE_0,
456	}
457	}, {
458	.name = "flexpfb",
459	.pdev = &(struct platform_device) {
460	.name = "flexpfb",
461	.id = 0,
462	.dev = {
463	.release = fbtft_device_pdev_release,
464	}
465	}
466	}, {
467	.name = "freetronicsoled128",
468	.spi = &(struct spi_board_info) {
469	.modalias = "fb_ssd1351",
470	.max_speed_hz = 20000000,
471	.mode = SPI_MODE_0,
472	.platform_data = &(struct fbtft_platform_data) {
473	.display = {
474	.buswidth = 8,
475	.backlight = FBTFT_ONBOARD_BACKLIGHT,
476	},
477	.bgr = true,
478	}
479	}
480	}, {
481	.name = "hx8353d",
482	.spi = &(struct spi_board_info) {
483	.modalias = "fb_hx8353d",
484	.max_speed_hz = 16000000,
485	.mode = SPI_MODE_0,
486	.platform_data = &(struct fbtft_platform_data) {
487	.display = {
488	.buswidth = 8,
489	.backlight = 1,
490	},
491	}
492	}
493	}, {
494	.name = "hy28a",
495	.spi = &(struct spi_board_info) {
496	.modalias = "fb_ili9320",
497	.max_speed_hz = 32000000,
498	.mode = SPI_MODE_3,
499	.platform_data = &(struct fbtft_platform_data) {
500	.display = {
501	.buswidth = 8,
502	.backlight = 1,
503	},
504	.startbyte = 0x70,
505	.bgr = true,
506	}
507	}
508	}, {
509	.name = "hy28b",
510	.spi = &(struct spi_board_info) {
511	.modalias = "fb_ili9325",
512	.max_speed_hz = 48000000,
513	.mode = SPI_MODE_3,
514	.platform_data = &(struct fbtft_platform_data) {
515	.display = {
516	.buswidth = 8,
517	.backlight = 1,
518	.init_sequence = hy28b_init_sequence,
519	},
520	.startbyte = 0x70,
521	.bgr = true,
522	.fps = 50,
523	.gamma = HY28B_GAMMA,
524	}
525	}
526	}, {
527	.name = "ili9481",
528	.spi = &(struct spi_board_info) {
529	.modalias = "fb_ili9481",
530	.max_speed_hz = 32000000,
531	.mode = SPI_MODE_0,
532	.platform_data = &(struct fbtft_platform_data) {
533	.display = {
534	.regwidth = 16,
535	.buswidth = 8,
536	.backlight = 1,
537	},
538	.bgr = true,
539	}
540	}
541	}, {
542	.name = "itdb24",
543	.pdev = &(struct platform_device) {
544	.name = "fb_s6d1121",
545	.id = 0,
546	.dev = {
547	.release = fbtft_device_pdev_release,
548	.platform_data = &(struct fbtft_platform_data) {
549	.display = {
550	.buswidth = 8,
551	.backlight = 1,
552	},
553	.bgr = false,
554	},
555	}
556	}
557	}, {
558	.name = "itdb28",
559	.pdev = &(struct platform_device) {
560	.name = "fb_ili9325",
561	.id = 0,
562	.dev = {
563	.release = fbtft_device_pdev_release,
564	.platform_data = &(struct fbtft_platform_data) {
565	.display = {
566	.buswidth = 8,
567	.backlight = 1,
568	},
569	.bgr = true,
570	},
571	}
572	}
573	}, {
574	.name = "itdb28_spi",
575	.spi = &(struct spi_board_info) {
576	.modalias = "fb_ili9325",
577	.max_speed_hz = 32000000,
578	.mode = SPI_MODE_0,
579	.platform_data = &(struct fbtft_platform_data) {
580	.display = {
581	.buswidth = 8,
582	.backlight = 1,
583	},
584	.bgr = true,
585	}
586	}
587	}, {
588	.name = "mi0283qt-2",
589	.spi = &(struct spi_board_info) {
590	.modalias = "fb_hx8347d",
591	.max_speed_hz = 32000000,
592	.mode = SPI_MODE_0,
593	.platform_data = &(struct fbtft_platform_data) {
594	.display = {
595	.buswidth = 8,
596	.backlight = 1,
597	},
598	.startbyte = 0x70,
599	.bgr = true,
600	}
601	}
602	}, {
603	.name = "mi0283qt-9a",
604	.spi = &(struct spi_board_info) {
605	.modalias = "fb_ili9341",
606	.max_speed_hz = 32000000,
607	.mode = SPI_MODE_0,
608	.platform_data = &(struct fbtft_platform_data) {
609	.display = {
610	.buswidth = 9,
611	.backlight = 1,
612	},
613	.bgr = true,
614	}
615	}
616	}, {
617	.name = "mi0283qt-v2",
618	.spi = &(struct spi_board_info) {
619	.modalias = "fb_watterott",
620	.max_speed_hz = 4000000,
621	.mode = SPI_MODE_3,
622	.platform_data = &(struct fbtft_platform_data) {
623	}
624	}
625	}, {
626	.name = "nokia3310",
627	.spi = &(struct spi_board_info) {
628	.modalias = "fb_pcd8544",
629	.max_speed_hz = 400000,
630	.mode = SPI_MODE_0,
631	.platform_data = &(struct fbtft_platform_data) {
632	.display = {
633	.buswidth = 8,
634	},
635	}
636	}
637	}, {
638	.name = "nokia3310a",
639	.spi = &(struct spi_board_info) {
640	.modalias = "fb_tls8204",
641	.max_speed_hz = 1000000,
642	.mode = SPI_MODE_0,
643	.platform_data = &(struct fbtft_platform_data) {
644	.display = {
645	.buswidth = 8,
646	},
647	}
648	}
649	}, {
650	.name = "nokia5110",
651	.spi = &(struct spi_board_info) {
652	.modalias = "fb_ili9163",
653	.max_speed_hz = 12000000,
654	.mode = SPI_MODE_0,
655	.platform_data = &(struct fbtft_platform_data) {
656	.display = {
657	.buswidth = 8,
658	.backlight = 1,
659	},
660	.bgr = true,
661	}
662	}
663	}, {
664	.name = "piscreen",
665	.spi = &(struct spi_board_info) {
666	.modalias = "fb_ili9486",
667	.max_speed_hz = 32000000,
668	.mode = SPI_MODE_0,
669	.platform_data = &(struct fbtft_platform_data) {
670	.display = {
671	.regwidth = 16,
672	.buswidth = 8,
673	.backlight = 1,
674	},
675	.bgr = true,
676	}
677	}
678	}, {
679	.name = "pitft",
680	.spi = &(struct spi_board_info) {
681	.modalias = "fb_ili9340",
682	.max_speed_hz = 32000000,
683	.mode = SPI_MODE_0,
684	.chip_select = 0,
685	.platform_data = &(struct fbtft_platform_data) {
686	.display = {
687	.buswidth = 8,
688	.backlight = 1,
689	.init_sequence = pitft_init_sequence,
690	},
691	.bgr = true,
692	}
693	}
694	}, {
695	.name = "pioled",
696	.spi = &(struct spi_board_info) {
697	.modalias = "fb_ssd1351",
698	.max_speed_hz = 20000000,
699	.mode = SPI_MODE_0,
700	.platform_data = &(struct fbtft_platform_data) {
701	.display = {
702	.buswidth = 8,
703	},
704	.bgr = true,
705	.gamma = PIOLED_GAMMA
706	}
707	}
708	}, {
709	.name = "rpi-display",
710	.spi = &(struct spi_board_info) {
711	.modalias = "fb_ili9341",
712	.max_speed_hz = 32000000,
713	.mode = SPI_MODE_0,
714	.platform_data = &(struct fbtft_platform_data) {
715	.display = {
716	.buswidth = 8,
717	.backlight = 1,
718	},
719	.bgr = true,
720	}
721	}
722	}, {
723	.name = "s6d02a1",
724	.spi = &(struct spi_board_info) {
725	.modalias = "fb_s6d02a1",
726	.max_speed_hz = 32000000,
727	.mode = SPI_MODE_0,
728	.platform_data = &(struct fbtft_platform_data) {
729	.display = {
730	.buswidth = 8,
731	.backlight = 1,
732	},
733	.bgr = true,
734	}
735	}
736	}, {
737	.name = "sainsmart18",
738	.spi = &(struct spi_board_info) {
739	.modalias = "fb_st7735r",
740	.max_speed_hz = 32000000,
741	.mode = SPI_MODE_0,
742	.platform_data = &(struct fbtft_platform_data) {
743	.display = {
744	.buswidth = 8,
745	},
746	}
747	}
748	}, {
749	.name = "sainsmart32",
750	.pdev = &(struct platform_device) {
751	.name = "fb_ssd1289",
752	.id = 0,
753	.dev = {
754	.release = fbtft_device_pdev_release,
755	.platform_data = &(struct fbtft_platform_data) {
756	.display = {
757	.buswidth = 16,
758	.txbuflen = -2, /* disable buffer */
759	.backlight = 1,
760	.fbtftops.write = write_gpio16_wr_slow,
761	},
762	.bgr = true,
763	},
764	},
765	}
766	}, {
767	.name = "sainsmart32_fast",
768	.pdev = &(struct platform_device) {
769	.name = "fb_ssd1289",
770	.id = 0,
771	.dev = {
772	.release = fbtft_device_pdev_release,
773	.platform_data = &(struct fbtft_platform_data) {
774	.display = {
775	.buswidth = 16,
776	.txbuflen = -2, /* disable buffer */
777	.backlight = 1,
778	},
779	.bgr = true,
780	},
781	},
782	}
783	}, {
784	.name = "sainsmart32_latched",
785	.pdev = &(struct platform_device) {
786	.name = "fb_ssd1289",
787	.id = 0,
788	.dev = {
789	.release = fbtft_device_pdev_release,
790	.platform_data = &(struct fbtft_platform_data) {
791	.display = {
792	.buswidth = 16,
793	.txbuflen = -2, /* disable buffer */
794	.backlight = 1,
795	.fbtftops.write =
796	fbtft_write_gpio16_wr_latched,
797	},
798	.bgr = true,
799	},
800	},
801	}
802	}, {
803	.name = "sainsmart32_spi",
804	.spi = &(struct spi_board_info) {
805	.modalias = "fb_ssd1289",
806	.max_speed_hz = 16000000,
807	.mode = SPI_MODE_0,
808	.platform_data = &(struct fbtft_platform_data) {
809	.display = {
810	.buswidth = 8,
811	.backlight = 1,
812	},
813	.bgr = true,
814	}
815	}
816	}, {
817	.name = "spidev",
818	.spi = &(struct spi_board_info) {
819	.modalias = "spidev",
820	.max_speed_hz = 500000,
821	.bus_num = 0,
822	.chip_select = 0,
823	.mode = SPI_MODE_0,
824	.platform_data = &(struct fbtft_platform_data) {
825	}
826	}
827	}, {
828	.name = "ssd1331",
829	.spi = &(struct spi_board_info) {
830	.modalias = "fb_ssd1331",
831	.max_speed_hz = 20000000,
832	.mode = SPI_MODE_3,
833	.platform_data = &(struct fbtft_platform_data) {
834	.display = {
835	.buswidth = 8,
836	},
837	}
838	}
839	}, {
840	.name = "tinylcd35",
841	.spi = &(struct spi_board_info) {
842	.modalias = "fb_tinylcd",
843	.max_speed_hz = 32000000,
844	.mode = SPI_MODE_0,
845	.platform_data = &(struct fbtft_platform_data) {
846	.display = {
847	.buswidth = 8,
848	.backlight = 1,
849	},
850	.bgr = true,
851	}
852	}
853	}, {
854	.name = "tm022hdh26",
855	.spi = &(struct spi_board_info) {
856	.modalias = "fb_ili9341",
857	.max_speed_hz = 32000000,
858	.mode = SPI_MODE_0,
859	.platform_data = &(struct fbtft_platform_data) {
860	.display = {
861	.buswidth = 8,
862	.backlight = 1,
863	},
864	.bgr = true,
865	}
866	}
867	}, {
868	.name = "tontec35_9481", /* boards before 02 July 2014 */
869	.spi = &(struct spi_board_info) {
870	.modalias = "fb_ili9481",
871	.max_speed_hz = 128000000,
872	.mode = SPI_MODE_3,
873	.platform_data = &(struct fbtft_platform_data) {
874	.display = {
875	.buswidth = 8,
876	.backlight = 1,
877	},
878	.bgr = true,
879	}
880	}
881	}, {
882	.name = "tontec35_9486", /* boards after 02 July 2014 */
883	.spi = &(struct spi_board_info) {
884	.modalias = "fb_ili9486",
885	.max_speed_hz = 128000000,
886	.mode = SPI_MODE_3,
887	.platform_data = &(struct fbtft_platform_data) {
888	.display = {
889	.buswidth = 8,
890	.backlight = 1,
891	},
892	.bgr = true,
893	}
894	}
895	}, {
896	.name = "upd161704",
897	.spi = &(struct spi_board_info) {
898	.modalias = "fb_upd161704",
899	.max_speed_hz = 32000000,
900	.mode = SPI_MODE_0,
901	.platform_data = &(struct fbtft_platform_data) {
902	.display = {
903	.buswidth = 8,
904	},
905	}
906	}
907	}, {
908	.name = "waveshare32b",
909	.spi = &(struct spi_board_info) {
910	.modalias = "fb_ili9340",
911	.max_speed_hz = 48000000,
912	.mode = SPI_MODE_0,
913	.platform_data = &(struct fbtft_platform_data) {
914	.display = {
915	.buswidth = 8,
916	.backlight = 1,
917	.init_sequence =
918	waveshare32b_init_sequence,
919	},
920	.bgr = true,
921	}
922	}
923	}, {
924	.name = "waveshare22",
925	.spi = &(struct spi_board_info) {
926	.modalias = "fb_bd663474",
927	.max_speed_hz = 32000000,
928	.mode = SPI_MODE_3,
929	.platform_data = &(struct fbtft_platform_data) {
930	.display = {
931	.buswidth = 8,
932	},
933	}
934	}
935	}, {
936	/* This should be the last item.
937	* Used with the custom argument
938	*/
939	.name = "",
940	.spi = &(struct spi_board_info) {
941	.modalias = "",
942	.max_speed_hz = 0,
943	.mode = SPI_MODE_0,
944	.platform_data = &(struct fbtft_platform_data) {
945	}
946	},
947	.pdev = &(struct platform_device) {
948	.name = "",
949	.id = 0,
950	.dev = {
951	.release = fbtft_device_pdev_release,
952	.platform_data = &(struct fbtft_platform_data) {
953	},
954	},
955	},
956	}
957	};
958
959	static int write_gpio16_wr_slow(struct fbtft_par par, void buf, size_t len)
960	{
961	u16 data;
962	int i;
963	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
964	static u16 prev_data;
965	#endif
966
967	fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
968	"%s(len=%zu): ", __func__, len);
969
970	while (len) {
971	data = (u16 )buf;
972
973	/* Start writing by pulling down /WR */
974	gpiod_set_value(par->gpio.wr, 0);
975
976	/* Set data */
977	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
978	if (data == prev_data) {
979	gpiod_set_value(par->gpio.wr, 0); /* used as delay */
980	} else {
981	for (i = 0; i < 16; i++) {
982	if ((data & 1) != (prev_data & 1))
983	gpiod_set_value(par->gpio.db[i],
984	data & 1);
985	data >>= 1;
986	prev_data >>= 1;
987	}
988	}
989	#else
990	for (i = 0; i < 16; i++) {
991	gpiod_set_value(par->gpio.db[i], data & 1);
992	data >>= 1;
993	}
994	#endif
995
996	/* Pullup /WR */
997	gpiod_set_value(par->gpio.wr, 1);
998
999	#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
1000	prev_data = (u16 )buf;
1001	#endif
1002	buf += 2;
1003	len -= 2;
1004	}
1005
1006	return 0;
1007	}
1008
1009	static void adafruit18_green_tab_set_addr_win(struct fbtft_par *par,
1010	int xs, int ys, int xe, int ye)
1011	{
1012	write_reg(par, 0x2A, 0, xs + 2, 0, xe + 2);
1013	write_reg(par, 0x2B, 0, ys + 1, 0, ye + 1);
1014	write_reg(par, 0x2C);
1015	}
1016
1017	static void fbtft_device_pdev_release(struct device *dev)
1018	{
1019	/* Needed to silence this message:
1020	* Device 'xxx' does not have a release() function,
1021	* it is broken and must be fixed
1022	*/
1023	}
1024
1025	static int spi_device_found(struct device dev, void data)
1026	{
1027	struct spi_device *spi = to_spi_device(dev);
1028
1029	dev_info(dev, "%s %s %dkHz %d bits mode=0x%02X\n", spi->modalias,
1030	dev_name(dev), spi->max_speed_hz / 1000, spi->bits_per_word,
1031	spi->mode);
1032
1033	return 0;
1034	}
1035
1036	static void pr_spi_devices(void)
1037	{
1038	pr_debug("SPI devices registered:\n");
1039	bus_for_each_dev(&spi_bus_type, NULL, NULL, spi_device_found);
1040	}
1041
1042	static int p_device_found(struct device dev, void data)
1043	{
1044	struct platform_device
1045	*pdev = to_platform_device(dev);
1046
1047	if (strstr(pdev->name, "fb"))
1048	dev_info(dev, "%s id=%d pdata? %s\n", pdev->name, pdev->id,
1049	pdev->dev.platform_data ? "yes" : "no");
1050
1051	return 0;
1052	}
1053
1054	static void pr_p_devices(void)
1055	{
1056	pr_debug("'fb' Platform devices registered:\n");
1057	bus_for_each_dev(&platform_bus_type, NULL, NULL, p_device_found);
1058	}
1059
1060	#ifdef MODULE
1061	static void fbtft_device_spi_delete(struct spi_master *master, unsigned int cs)
1062	{
1063	struct device *dev;
1064	char str[32];
1065
1066	snprintf(str, sizeof(str), "%s.%u", dev_name(&master->dev), cs);
1067
1068	dev = bus_find_device_by_name(&spi_bus_type, NULL, str);
1069	if (dev) {
1070	if (verbose)
1071	dev_info(dev, "Deleting %s\n", str);
1072	device_del(dev);
1073	}
1074	}
1075
1076	static int fbtft_device_spi_device_register(struct spi_board_info *spi)
1077	{
1078	struct spi_master *master;
1079
1080	master = spi_busnum_to_master(spi->bus_num);
1081	if (!master) {
1082	pr_err("spi_busnum_to_master(%d) returned NULL\n",
1083	spi->bus_num);
1084	return -EINVAL;
1085	}
1086	/* make sure it's available */
1087	fbtft_device_spi_delete(master, spi->chip_select);
1088	spi_device = spi_new_device(master, spi);
1089	put_device(&master->dev);
1090	if (!spi_device) {
1091	dev_err(&master->dev, "spi_new_device() returned NULL\n");
1092	return -EPERM;
1093	}
1094	return 0;
1095	}
1096	#else
1097	static int fbtft_device_spi_device_register(struct spi_board_info *spi)
1098	{
1099	return spi_register_board_info(spi, 1);
1100	}
1101	#endif
1102
1103	static int __init fbtft_device_init(void)
1104	{
1105	struct spi_board_info *spi = NULL;
1106	struct fbtft_platform_data *pdata;
1107	bool found = false;
1108	int i = 0;
1109	int ret = 0;
1110
1111	if (!name) {
1112	#ifdef MODULE
1113	pr_err("missing module parameter: 'name'\n");
1114	return -EINVAL;
1115	#else
1116	return 0;
1117	#endif
1118	}
1119
1120	if (init_num > FBTFT_MAX_INIT_SEQUENCE) {
1121	pr_err("init parameter: exceeded max array size: %d\n",
1122	FBTFT_MAX_INIT_SEQUENCE);
1123	return -EINVAL;
1124	}
1125
1126	if (verbose > 2) {
1127	pr_spi_devices(); /* print list of registered SPI devices */
1128	pr_p_devices(); /* print list of 'fb' platform devices */
1129	}
1130
1131	pr_debug("name='%s', busnum=%d, cs=%d\n", name, busnum, cs);
1132
1133	if (rotate > 0 && rotate < 4) {
1134	rotate = (4 - rotate) * 90;
1135	pr_warn("argument 'rotate' should be an angle. Values 1-3 is deprecated. Setting it to %d.\n",
1136	rotate);
1137	}
1138	if (rotate != 0 && rotate != 90 && rotate != 180 && rotate != 270) {
1139	pr_warn("argument 'rotate' illegal value: %d. Setting it to 0.\n",
1140	rotate);
1141	rotate = 0;
1142	}
1143
1144	/* name=list lists all supported displays */
1145	if (strcmp(name, "list") == 0) {
1146	pr_info("Supported displays:\n");
1147
1148	for (i = 0; i < ARRAY_SIZE(displays); i++)
1149	pr_info("%s\n", displays[i].name);
1150	return -ECANCELED;
1151	}
1152
1153	if (custom) {
1154	i = ARRAY_SIZE(displays) - 1;
1155	displays[i].name = name;
1156	if (speed == 0) {
1157	displays[i].pdev->name = name;
1158	displays[i].spi = NULL;
1159	} else {
1160	size_t len;
1161
1162	len = strlcpy(displays[i].spi->modalias, name,
1163	SPI_NAME_SIZE);
1164	if (len >= SPI_NAME_SIZE)
1165	pr_warn("modalias (name) truncated to: %s\n",
1166	displays[i].spi->modalias);
1167	displays[i].pdev = NULL;
1168	}
1169	}
1170
1171	for (i = 0; i < ARRAY_SIZE(displays); i++) {
1172	if (strncmp(name, displays[i].name, SPI_NAME_SIZE) == 0) {
1173	if (displays[i].spi) {
1174	spi = displays[i].spi;
1175	spi->chip_select = cs;
1176	spi->bus_num = busnum;
1177	if (speed)
1178	spi->max_speed_hz = speed;
1179	if (mode != -1)
1180	spi->mode = mode;
1181	pdata = (void *)spi->platform_data;
1182	} else if (displays[i].pdev) {
1183	p_device = displays[i].pdev;
1184	pdata = p_device->dev.platform_data;
1185	} else {
1186	pr_err("broken displays array\n");
1187	return -EINVAL;
1188	}
1189
1190	pdata->rotate = rotate;
1191	if (bgr == 0)
1192	pdata->bgr = false;
1193	else if (bgr == 1)
1194	pdata->bgr = true;
1195	if (startbyte)
1196	pdata->startbyte = startbyte;
1197	if (gamma)
1198	pdata->gamma = gamma;
1199	pdata->display.debug = debug;
1200	if (fps)
1201	pdata->fps = fps;
1202	if (txbuflen)
1203	pdata->txbuflen = txbuflen;
1204	if (init_num)
1205	pdata->display.init_sequence = init;
1206	if (custom) {
1207	pdata->display.width = width;
1208	pdata->display.height = height;
1209	pdata->display.buswidth = buswidth;
1210	pdata->display.backlight = 1;
1211	}
1212
1213	if (displays[i].spi) {
1214	ret = fbtft_device_spi_device_register(spi);
1215	if (ret) {
1216	pr_err("failed to register SPI device\n");
1217	return ret;
1218	}
1219	} else {
1220	ret = platform_device_register(p_device);
1221	if (ret < 0) {
1222	pr_err("platform_device_register() returned %d\n",
1223	ret);
1224	return ret;
1225	}
1226	}
1227	found = true;
1228	break;
1229	}
1230	}
1231
1232	if (!found) {
1233	pr_err("display not supported: '%s'\n", name);
1234	return -EINVAL;
1235	}
1236
1237	if (spi_device && (verbose > 1))
1238	pr_spi_devices();
1239	if (p_device && (verbose > 1))
1240	pr_p_devices();
1241
1242	return 0;
1243	}
1244
1245	static void __exit fbtft_device_exit(void)
1246	{
1247	if (spi_device) {
1248	device_del(&spi_device->dev);
1249	kfree(spi_device);
1250	}
1251
1252	if (p_device)
1253	platform_device_unregister(p_device);
1254	}
1255
1256	arch_initcall(fbtft_device_init);
1257	module_exit(fbtft_device_exit);
1258
1259	MODULE_DESCRIPTION("Add a FBTFT device.");
1260	MODULE_AUTHOR("Noralf Tronnes");
1261	MODULE_LICENSE("GPL");

drivers/staging/fbtft/flexfb.c+0−851

@@ -1,851 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0+
2	/*
3	* Generic FB driver for TFT LCD displays
4	*
5	* Copyright (C) 2013 Noralf Tronnes
6	*/
7
8	#include <linux/module.h>
9	#include <linux/kernel.h>
10	#include <linux/init.h>
11	#include <linux/vmalloc.h>
12	#include <linux/gpio/consumer.h>
13	#include <linux/spi/spi.h>
14	#include <linux/delay.h>
15
16	#include "fbtft.h"
17
18	#define DRVNAME "flexfb"
19
20	static char *chip;
21	module_param(chip, charp, 0000);
22	MODULE_PARM_DESC(chip, "LCD controller");
23
24	static unsigned int width;
25	module_param(width, uint, 0000);
26	MODULE_PARM_DESC(width, "Display width");
27
28	static unsigned int height;
29	module_param(height, uint, 0000);
30	MODULE_PARM_DESC(height, "Display height");
31
32	static s16 init[512];
33	static int init_num;
34	module_param_array(init, short, &init_num, 0000);
35	MODULE_PARM_DESC(init, "Init sequence");
36
37	static unsigned int setaddrwin;
38	module_param(setaddrwin, uint, 0000);
39	MODULE_PARM_DESC(setaddrwin, "Which set_addr_win() implementation to use");
40
41	static unsigned int buswidth = 8;
42	module_param(buswidth, uint, 0000);
43	MODULE_PARM_DESC(buswidth, "Width of databus (default: 8)");
44
45	static unsigned int regwidth = 8;
46	module_param(regwidth, uint, 0000);
47	MODULE_PARM_DESC(regwidth, "Width of controller register (default: 8)");
48
49	static bool nobacklight;
50	module_param(nobacklight, bool, 0000);
51	MODULE_PARM_DESC(nobacklight, "Turn off backlight functionality.");
52
53	static bool latched;
54	module_param(latched, bool, 0000);
55	MODULE_PARM_DESC(latched, "Use with latched 16-bit databus");
56
57	static const s16 *initp;
58	static int initp_num;
59
60	/* default init sequences */
61	static const s16 st7735r_init[] = {
62	-1, 0x01,
63	-2, 150,
64	-1, 0x11,
65	-2, 500,
66	-1, 0xB1, 0x01, 0x2C, 0x2D,
67	-1, 0xB2, 0x01, 0x2C, 0x2D,
68	-1, 0xB3, 0x01, 0x2C, 0x2D, 0x01, 0x2C, 0x2D,
69	-1, 0xB4, 0x07,
70	-1, 0xC0, 0xA2, 0x02, 0x84,
71	-1, 0xC1, 0xC5,
72	-1, 0xC2, 0x0A, 0x00,
73	-1, 0xC3, 0x8A, 0x2A,
74	-1, 0xC4, 0x8A, 0xEE,
75	-1, 0xC5, 0x0E,
76	-1, 0x20,
77	-1, 0x36, 0xC0,
78	-1, 0x3A, 0x05,
79	-1, 0xE0, 0x0f, 0x1a, 0x0f, 0x18, 0x2f, 0x28, 0x20, 0x22,
80	0x1f, 0x1b, 0x23, 0x37, 0x00, 0x07, 0x02, 0x10,
81	-1, 0xE1, 0x0f, 0x1b, 0x0f, 0x17, 0x33, 0x2c, 0x29, 0x2e,
82	0x30, 0x30, 0x39, 0x3f, 0x00, 0x07, 0x03, 0x10,
83	-1, 0x29,
84	-2, 100,
85	-1, 0x13,
86	-2, 10,
87	-3
88	};
89
90	static const s16 ssd1289_init[] = {
91	-1, 0x00, 0x0001,
92	-1, 0x03, 0xA8A4,
93	-1, 0x0C, 0x0000,
94	-1, 0x0D, 0x080C,
95	-1, 0x0E, 0x2B00,
96	-1, 0x1E, 0x00B7,
97	-1, 0x01, 0x2B3F,
98	-1, 0x02, 0x0600,
99	-1, 0x10, 0x0000,
100	-1, 0x11, 0x6070,
101	-1, 0x05, 0x0000,
102	-1, 0x06, 0x0000,
103	-1, 0x16, 0xEF1C,
104	-1, 0x17, 0x0003,
105	-1, 0x07, 0x0233,
106	-1, 0x0B, 0x0000,
107	-1, 0x0F, 0x0000,
108	-1, 0x41, 0x0000,
109	-1, 0x42, 0x0000,
110	-1, 0x48, 0x0000,
111	-1, 0x49, 0x013F,
112	-1, 0x4A, 0x0000,
113	-1, 0x4B, 0x0000,
114	-1, 0x44, 0xEF00,
115	-1, 0x45, 0x0000,
116	-1, 0x46, 0x013F,
117	-1, 0x30, 0x0707,
118	-1, 0x31, 0x0204,
119	-1, 0x32, 0x0204,
120	-1, 0x33, 0x0502,
121	-1, 0x34, 0x0507,
122	-1, 0x35, 0x0204,
123	-1, 0x36, 0x0204,
124	-1, 0x37, 0x0502,
125	-1, 0x3A, 0x0302,
126	-1, 0x3B, 0x0302,
127	-1, 0x23, 0x0000,
128	-1, 0x24, 0x0000,
129	-1, 0x25, 0x8000,
130	-1, 0x4f, 0x0000,
131	-1, 0x4e, 0x0000,
132	-1, 0x22,
133	-3
134	};
135
136	static const s16 hx8340bn_init[] = {
137	-1, 0xC1, 0xFF, 0x83, 0x40,
138	-1, 0x11,
139	-2, 150,
140	-1, 0xCA, 0x70, 0x00, 0xD9,
141	-1, 0xB0, 0x01, 0x11,
142	-1, 0xC9, 0x90, 0x49, 0x10, 0x28, 0x28, 0x10, 0x00, 0x06,
143	-2, 20,
144	-1, 0xC2, 0x60, 0x71, 0x01, 0x0E, 0x05, 0x02, 0x09, 0x31, 0x0A,
145	-1, 0xC3, 0x67, 0x30, 0x61, 0x17, 0x48, 0x07, 0x05, 0x33,
146	-2, 10,
147	-1, 0xB5, 0x35, 0x20, 0x45,
148	-1, 0xB4, 0x33, 0x25, 0x4C,
149	-2, 10,
150	-1, 0x3A, 0x05,
151	-1, 0x29,
152	-2, 10,
153	-3
154	};
155
156	static const s16 ili9225_init[] = {
157	-1, 0x0001, 0x011C,
158	-1, 0x0002, 0x0100,
159	-1, 0x0003, 0x1030,
160	-1, 0x0008, 0x0808,
161	-1, 0x000C, 0x0000,
162	-1, 0x000F, 0x0A01,
163	-1, 0x0020, 0x0000,
164	-1, 0x0021, 0x0000,
165	-2, 50,
166	-1, 0x0010, 0x0A00,
167	-1, 0x0011, 0x1038,
168	-2, 50,
169	-1, 0x0012, 0x1121,
170	-1, 0x0013, 0x004E,
171	-1, 0x0014, 0x676F,
172	-1, 0x0030, 0x0000,
173	-1, 0x0031, 0x00DB,
174	-1, 0x0032, 0x0000,
175	-1, 0x0033, 0x0000,
176	-1, 0x0034, 0x00DB,
177	-1, 0x0035, 0x0000,
178	-1, 0x0036, 0x00AF,
179	-1, 0x0037, 0x0000,
180	-1, 0x0038, 0x00DB,
181	-1, 0x0039, 0x0000,
182	-1, 0x0050, 0x0000,
183	-1, 0x0051, 0x060A,
184	-1, 0x0052, 0x0D0A,
185	-1, 0x0053, 0x0303,
186	-1, 0x0054, 0x0A0D,
187	-1, 0x0055, 0x0A06,
188	-1, 0x0056, 0x0000,
189	-1, 0x0057, 0x0303,
190	-1, 0x0058, 0x0000,
191	-1, 0x0059, 0x0000,
192	-2, 50,
193	-1, 0x0007, 0x1017,
194	-2, 50,
195	-3
196	};
197
198	static const s16 ili9320_init[] = {
199	-1, 0x00E5, 0x8000,
200	-1, 0x0000, 0x0001,
201	-1, 0x0001, 0x0100,
202	-1, 0x0002, 0x0700,
203	-1, 0x0003, 0x1030,
204	-1, 0x0004, 0x0000,
205	-1, 0x0008, 0x0202,
206	-1, 0x0009, 0x0000,
207	-1, 0x000A, 0x0000,
208	-1, 0x000C, 0x0000,
209	-1, 0x000D, 0x0000,
210	-1, 0x000F, 0x0000,
211	-1, 0x0010, 0x0000,
212	-1, 0x0011, 0x0007,
213	-1, 0x0012, 0x0000,
214	-1, 0x0013, 0x0000,
215	-2, 200,
216	-1, 0x0010, 0x17B0,
217	-1, 0x0011, 0x0031,
218	-2, 50,
219	-1, 0x0012, 0x0138,
220	-2, 50,
221	-1, 0x0013, 0x1800,
222	-1, 0x0029, 0x0008,
223	-2, 50,
224	-1, 0x0020, 0x0000,
225	-1, 0x0021, 0x0000,
226	-1, 0x0030, 0x0000,
227	-1, 0x0031, 0x0505,
228	-1, 0x0032, 0x0004,
229	-1, 0x0035, 0x0006,
230	-1, 0x0036, 0x0707,
231	-1, 0x0037, 0x0105,
232	-1, 0x0038, 0x0002,
233	-1, 0x0039, 0x0707,
234	-1, 0x003C, 0x0704,
235	-1, 0x003D, 0x0807,
236	-1, 0x0050, 0x0000,
237	-1, 0x0051, 0x00EF,
238	-1, 0x0052, 0x0000,
239	-1, 0x0053, 0x013F,
240	-1, 0x0060, 0x2700,
241	-1, 0x0061, 0x0001,
242	-1, 0x006A, 0x0000,
243	-1, 0x0080, 0x0000,
244	-1, 0x0081, 0x0000,
245	-1, 0x0082, 0x0000,
246	-1, 0x0083, 0x0000,
247	-1, 0x0084, 0x0000,
248	-1, 0x0085, 0x0000,
249	-1, 0x0090, 0x0010,
250	-1, 0x0092, 0x0000,
251	-1, 0x0093, 0x0003,
252	-1, 0x0095, 0x0110,
253	-1, 0x0097, 0x0000,
254	-1, 0x0098, 0x0000,
255	-1, 0x0007, 0x0173,
256	-3
257	};
258
259	static const s16 ili9325_init[] = {
260	-1, 0x00E3, 0x3008,
261	-1, 0x00E7, 0x0012,
262	-1, 0x00EF, 0x1231,
263	-1, 0x0001, 0x0100,
264	-1, 0x0002, 0x0700,
265	-1, 0x0003, 0x1030,
266	-1, 0x0004, 0x0000,
267	-1, 0x0008, 0x0207,
268	-1, 0x0009, 0x0000,
269	-1, 0x000A, 0x0000,
270	-1, 0x000C, 0x0000,
271	-1, 0x000D, 0x0000,
272	-1, 0x000F, 0x0000,
273	-1, 0x0010, 0x0000,
274	-1, 0x0011, 0x0007,
275	-1, 0x0012, 0x0000,
276	-1, 0x0013, 0x0000,
277	-2, 200,
278	-1, 0x0010, 0x1690,
279	-1, 0x0011, 0x0223,
280	-2, 50,
281	-1, 0x0012, 0x000D,
282	-2, 50,
283	-1, 0x0013, 0x1200,
284	-1, 0x0029, 0x000A,
285	-1, 0x002B, 0x000C,
286	-2, 50,
287	-1, 0x0020, 0x0000,
288	-1, 0x0021, 0x0000,
289	-1, 0x0030, 0x0000,
290	-1, 0x0031, 0x0506,
291	-1, 0x0032, 0x0104,
292	-1, 0x0035, 0x0207,
293	-1, 0x0036, 0x000F,
294	-1, 0x0037, 0x0306,
295	-1, 0x0038, 0x0102,
296	-1, 0x0039, 0x0707,
297	-1, 0x003C, 0x0702,
298	-1, 0x003D, 0x1604,
299	-1, 0x0050, 0x0000,
300	-1, 0x0051, 0x00EF,
301	-1, 0x0052, 0x0000,
302	-1, 0x0053, 0x013F,
303	-1, 0x0060, 0xA700,
304	-1, 0x0061, 0x0001,
305	-1, 0x006A, 0x0000,
306	-1, 0x0080, 0x0000,
307	-1, 0x0081, 0x0000,
308	-1, 0x0082, 0x0000,
309	-1, 0x0083, 0x0000,
310	-1, 0x0084, 0x0000,
311	-1, 0x0085, 0x0000,
312	-1, 0x0090, 0x0010,
313	-1, 0x0092, 0x0600,
314	-1, 0x0007, 0x0133,
315	-3
316	};
317
318	static const s16 ili9341_init[] = {
319	-1, 0x28,
320	-2, 20,
321	-1, 0xCF, 0x00, 0x83, 0x30,
322	-1, 0xED, 0x64, 0x03, 0x12, 0x81,
323	-1, 0xE8, 0x85, 0x01, 0x79,
324	-1, 0xCB, 0x39, 0x2c, 0x00, 0x34, 0x02,
325	-1, 0xF7, 0x20,
326	-1, 0xEA, 0x00, 0x00,
327	-1, 0xC0, 0x26,
328	-1, 0xC1, 0x11,
329	-1, 0xC5, 0x35, 0x3E,
330	-1, 0xC7, 0xBE,
331	-1, 0xB1, 0x00, 0x1B,
332	-1, 0xB6, 0x0a, 0x82, 0x27, 0x00,
333	-1, 0xB7, 0x07,
334	-1, 0x3A, 0x55,
335	-1, 0x36, 0x48,
336	-1, 0x11,
337	-2, 120,
338	-1, 0x29,
339	-2, 20,
340	-3
341	};
342
343	static const s16 ssd1351_init[] = {
344	-1, 0xfd, 0x12,
345	-1, 0xfd, 0xb1,
346	-1, 0xae,
347	-1, 0xb3, 0xf1,
348	-1, 0xca, 0x7f,
349	-1, 0xa0, 0x74,
350	-1, 0x15, 0x00, 0x7f,
351	-1, 0x75, 0x00, 0x7f,
352	-1, 0xa1, 0x00,
353	-1, 0xa2, 0x00,
354	-1, 0xb5, 0x00,
355	-1, 0xab, 0x01,
356	-1, 0xb1, 0x32,
357	-1, 0xb4, 0xa0, 0xb5, 0x55,
358	-1, 0xbb, 0x17,
359	-1, 0xbe, 0x05,
360	-1, 0xc1, 0xc8, 0x80, 0xc8,
361	-1, 0xc7, 0x0f,
362	-1, 0xb6, 0x01,
363	-1, 0xa6,
364	-1, 0xaf,
365	-3
366	};
367
368	/**
369	* struct flexfb_lcd_controller - Describes the LCD controller properties
370	* @name: Model name of the chip
371	* @width: Width of display in pixels
372	* @height: Height of display in pixels
373	* @setaddrwin: Which set_addr_win() implementation to use
374	* @regwidth: LCD Controller Register width in bits
375	* @init_seq: LCD initialization sequence
376	* @init_seq_sz: Size of LCD initialization sequence
377	*/
378	struct flexfb_lcd_controller {
379	const char *name;
380	unsigned int width;
381	unsigned int height;
382	unsigned int setaddrwin;
383	unsigned int regwidth;
384	const s16 *init_seq;
385	int init_seq_sz;
386	};
387
388	static const struct flexfb_lcd_controller flexfb_chip_table[] = {
389	{
390	.name = "st7735r",
391	.width = 120,
392	.height = 160,
393	.init_seq = st7735r_init,
394	.init_seq_sz = ARRAY_SIZE(st7735r_init),
395	},
396	{
397	.name = "hx8340bn",
398	.width = 176,
399	.height = 220,
400	.init_seq = hx8340bn_init,
401	.init_seq_sz = ARRAY_SIZE(hx8340bn_init),
402	},
403	{
404	.name = "ili9225",
405	.width = 176,
406	.height = 220,
407	.regwidth = 16,
408	.init_seq = ili9225_init,
409	.init_seq_sz = ARRAY_SIZE(ili9225_init),
410	},
411	{
412	.name = "ili9320",
413	.width = 240,
414	.height = 320,
415	.setaddrwin = 1,
416	.regwidth = 16,
417	.init_seq = ili9320_init,
418	.init_seq_sz = ARRAY_SIZE(ili9320_init),
419	},
420	{
421	.name = "ili9325",
422	.width = 240,
423	.height = 320,
424	.setaddrwin = 1,
425	.regwidth = 16,
426	.init_seq = ili9325_init,
427	.init_seq_sz = ARRAY_SIZE(ili9325_init),
428	},
429	{
430	.name = "ili9341",
431	.width = 240,
432	.height = 320,
433	.init_seq = ili9341_init,
434	.init_seq_sz = ARRAY_SIZE(ili9341_init),
435	},
436	{
437	.name = "ssd1289",
438	.width = 240,
439	.height = 320,
440	.setaddrwin = 2,
441	.regwidth = 16,
442	.init_seq = ssd1289_init,
443	.init_seq_sz = ARRAY_SIZE(ssd1289_init),
444	},
445	{
446	.name = "ssd1351",
447	.width = 128,
448	.height = 128,
449	.setaddrwin = 3,
450	.init_seq = ssd1351_init,
451	.init_seq_sz = ARRAY_SIZE(ssd1351_init),
452	},
453	};
454
455	/* ili9320, ili9325 */
456	static void flexfb_set_addr_win_1(struct fbtft_par *par,
457	int xs, int ys, int xe, int ye)
458	{
459	switch (par->info->var.rotate) {
460	/* R20h = Horizontal GRAM Start Address */
461	/* R21h = Vertical GRAM Start Address */
462	case 0:
463	write_reg(par, 0x0020, xs);
464	write_reg(par, 0x0021, ys);
465	break;
466	case 180:
467	write_reg(par, 0x0020, width - 1 - xs);
468	write_reg(par, 0x0021, height - 1 - ys);
469	break;
470	case 270:
471	write_reg(par, 0x0020, width - 1 - ys);
472	write_reg(par, 0x0021, xs);
473	break;
474	case 90:
475	write_reg(par, 0x0020, ys);
476	write_reg(par, 0x0021, height - 1 - xs);
477	break;
478	}
479	write_reg(par, 0x0022); /* Write Data to GRAM */
480	}
481
482	/* ssd1289 */
483	static void flexfb_set_addr_win_2(struct fbtft_par *par,
484	int xs, int ys, int xe, int ye)
485	{
486	switch (par->info->var.rotate) {
487	/* R4Eh - Set GDDRAM X address counter */
488	/* R4Fh - Set GDDRAM Y address counter */
489	case 0:
490	write_reg(par, 0x4e, xs);
491	write_reg(par, 0x4f, ys);
492	break;
493	case 180:
494	write_reg(par, 0x4e, par->info->var.xres - 1 - xs);
495	write_reg(par, 0x4f, par->info->var.yres - 1 - ys);
496	break;
497	case 270:
498	write_reg(par, 0x4e, par->info->var.yres - 1 - ys);
499	write_reg(par, 0x4f, xs);
500	break;
501	case 90:
502	write_reg(par, 0x4e, ys);
503	write_reg(par, 0x4f, par->info->var.xres - 1 - xs);
504	break;
505	}
506
507	/* R22h - RAM data write */
508	write_reg(par, 0x22, 0);
509	}
510
511	/* ssd1351 */
512	static void set_addr_win_3(struct fbtft_par *par,
513	int xs, int ys, int xe, int ye)
514	{
515	write_reg(par, 0x15, xs, xe);
516	write_reg(par, 0x75, ys, ye);
517	write_reg(par, 0x5C);
518	}
519
520	static int flexfb_verify_gpios_dc(struct fbtft_par *par)
521	{
522	fbtft_par_dbg(DEBUG_VERIFY_GPIOS, par, "%s()\n", __func__);
523
524	if (!par->gpio.dc) {
525	dev_err(par->info->device,
526	"Missing info about 'dc' gpio. Aborting.\n");
527	return -EINVAL;
528	}
529
530	return 0;
531	}
532
533	static int flexfb_verify_gpios_db(struct fbtft_par *par)
534	{
535	int i;
536	int num_db = buswidth;
537
538	fbtft_par_dbg(DEBUG_VERIFY_GPIOS, par, "%s()\n", __func__);
539
540	if (!par->gpio.dc) {
541	dev_err(par->info->device, "Missing info about 'dc' gpio. Aborting.\n");
542	return -EINVAL;
543	}
544	if (!par->gpio.wr) {
545	dev_err(par->info->device, "Missing info about 'wr' gpio. Aborting.\n");
546	return -EINVAL;
547	}
548	if (latched && !par->gpio.latch) {
549	dev_err(par->info->device, "Missing info about 'latch' gpio. Aborting.\n");
550	return -EINVAL;
551	}
552	if (latched)
553	num_db = buswidth / 2;
554	for (i = 0; i < num_db; i++) {
555	if (!par->gpio.db[i]) {
556	dev_err(par->info->device,
557	"Missing info about 'db%02d' gpio. Aborting.\n",
558	i);
559	return -EINVAL;
560	}
561	}
562
563	return 0;
564	}
565
566	static void flexfb_chip_load_param(const struct flexfb_lcd_controller *chip)
567	{
568	if (!width)
569	width = chip->width;
570	if (!height)
571	height = chip->height;
572	setaddrwin = chip->setaddrwin;
573	if (chip->regwidth)
574	regwidth = chip->regwidth;
575	if (!init_num) {
576	initp = chip->init_seq;
577	initp_num = chip->init_seq_sz;
578	}
579	}
580
581	static struct fbtft_display flex_display = { };
582
583	static int flexfb_chip_init(const struct device *dev)
584	{
585	int i;
586
587	for (i = 0; i < ARRAY_SIZE(flexfb_chip_table); i++)
588	if (!strcmp(chip, flexfb_chip_table[i].name)) {
589	flexfb_chip_load_param(&flexfb_chip_table[i]);
590	return 0;
591	}
592
593	dev_err(dev, "chip=%s is not supported\n", chip);
594
595	return -EINVAL;
596	}
597
598	static int flexfb_probe_common(struct spi_device *sdev,
599	struct platform_device *pdev)
600	{
601	struct device *dev;
602	struct fb_info *info;
603	struct fbtft_par *par;
604	int ret;
605
606	initp = init;
607	initp_num = init_num;
608
609	if (sdev)
610	dev = &sdev->dev;
611	else
612	dev = &pdev->dev;
613
614	fbtft_init_dbg(dev, "%s(%s)\n", __func__,
615	sdev ? "'SPI device'" : "'Platform device'");
616
617	if (chip) {
618	ret = flexfb_chip_init(dev);
619	if (ret)
620	return ret;
621	}
622
623	if (width == 0 \|\| height == 0) {
624	dev_err(dev, "argument(s) missing: width and height has to be set.\n");
625	return -EINVAL;
626	}
627	flex_display.width = width;
628	flex_display.height = height;
629	fbtft_init_dbg(dev, "Display resolution: %dx%d\n", width, height);
630	fbtft_init_dbg(dev, "chip = %s\n", chip ? chip : "not set");
631	fbtft_init_dbg(dev, "setaddrwin = %d\n", setaddrwin);
632	fbtft_init_dbg(dev, "regwidth = %d\n", regwidth);
633	fbtft_init_dbg(dev, "buswidth = %d\n", buswidth);
634
635	info = fbtft_framebuffer_alloc(&flex_display, dev, dev->platform_data);
636	if (!info)
637	return -ENOMEM;
638
639	par = info->par;
640	if (sdev)
641	par->spi = sdev;
642	else
643	par->pdev = pdev;
644	if (!par->init_sequence)
645	par->init_sequence = initp;
646	par->fbtftops.init_display = fbtft_init_display;
647
648	/* registerwrite functions */
649	switch (regwidth) {
650	case 8:
651	par->fbtftops.write_register = fbtft_write_reg8_bus8;
652	break;
653	case 16:
654	par->fbtftops.write_register = fbtft_write_reg16_bus8;
655	break;
656	default:
657	dev_err(dev,
658	"argument 'regwidth': %d is not supported.\n",
659	regwidth);
660	return -EINVAL;
661	}
662
663	/* bus functions */
664	if (sdev) {
665	par->fbtftops.write = fbtft_write_spi;
666	switch (buswidth) {
667	case 8:
668	par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
669	if (!par->startbyte)
670	par->fbtftops.verify_gpios = flexfb_verify_gpios_dc;
671	break;
672	case 9:
673	if (regwidth == 16) {
674	dev_err(dev, "argument 'regwidth': %d is not supported with buswidth=%d and SPI.\n",
675	regwidth, buswidth);
676	return -EINVAL;
677	}
678	par->fbtftops.write_register = fbtft_write_reg8_bus9;
679	par->fbtftops.write_vmem = fbtft_write_vmem16_bus9;
680	if (par->spi->master->bits_per_word_mask
681	& SPI_BPW_MASK(9)) {
682	par->spi->bits_per_word = 9;
683	break;
684	}
685
686	dev_warn(dev,
687	"9-bit SPI not available, emulating using 8-bit.\n");
688	/* allocate buffer with room for dc bits */
689	par->extra = devm_kzalloc(par->info->device,
690	par->txbuf.len
691	+ (par->txbuf.len / 8) + 8,
692	GFP_KERNEL);
693	if (!par->extra) {
694	ret = -ENOMEM;
695	goto out_release;
696	}
697	par->fbtftops.write = fbtft_write_spi_emulate_9;
698
699	break;
700	default:
701	dev_err(dev,
702	"argument 'buswidth': %d is not supported with SPI.\n",
703	buswidth);
704	return -EINVAL;
705	}
706	} else {
707	par->fbtftops.verify_gpios = flexfb_verify_gpios_db;
708	switch (buswidth) {
709	case 8:
710	par->fbtftops.write = fbtft_write_gpio8_wr;
711	par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
712	break;
713	case 16:
714	par->fbtftops.write_register = fbtft_write_reg16_bus16;
715	if (latched)
716	par->fbtftops.write = fbtft_write_gpio16_wr_latched;
717	else
718	par->fbtftops.write = fbtft_write_gpio16_wr;
719	par->fbtftops.write_vmem = fbtft_write_vmem16_bus16;
720	break;
721	default:
722	dev_err(dev,
723	"argument 'buswidth': %d is not supported with parallel.\n",
724	buswidth);
725	return -EINVAL;
726	}
727	}
728
729	/* set_addr_win function */
730	switch (setaddrwin) {
731	case 0:
732	/* use default */
733	break;
734	case 1:
735	par->fbtftops.set_addr_win = flexfb_set_addr_win_1;
736	break;
737	case 2:
738	par->fbtftops.set_addr_win = flexfb_set_addr_win_2;
739	break;
740	case 3:
741	par->fbtftops.set_addr_win = set_addr_win_3;
742	break;
743	default:
744	dev_err(dev, "argument 'setaddrwin': unknown value %d.\n",
745	setaddrwin);
746	return -EINVAL;
747	}
748
749	if (!nobacklight)
750	par->fbtftops.register_backlight = fbtft_register_backlight;
751
752	ret = fbtft_register_framebuffer(info);
753	if (ret < 0)
754	goto out_release;
755
756	return 0;
757
758	out_release:
759	fbtft_framebuffer_release(info);
760
761	return ret;
762	}
763
764	static int flexfb_remove_common(struct device dev, struct fb_info info)
765	{
766	struct fbtft_par *par;
767
768	if (!info)
769	return -EINVAL;
770	par = info->par;
771	if (par)
772	fbtft_par_dbg(DEBUG_DRIVER_INIT_FUNCTIONS, par, "%s()\n",
773	__func__);
774	fbtft_unregister_framebuffer(info);
775	fbtft_framebuffer_release(info);
776
777	return 0;
778	}
779
780	static int flexfb_probe_spi(struct spi_device *spi)
781	{
782	return flexfb_probe_common(spi, NULL);
783	}
784
785	static int flexfb_remove_spi(struct spi_device *spi)
786	{
787	struct fb_info *info = spi_get_drvdata(spi);
788
789	return flexfb_remove_common(&spi->dev, info);
790	}
791
792	static int flexfb_probe_pdev(struct platform_device *pdev)
793	{
794	return flexfb_probe_common(NULL, pdev);
795	}
796
797	static int flexfb_remove_pdev(struct platform_device *pdev)
798	{
799	struct fb_info *info = platform_get_drvdata(pdev);
800
801	return flexfb_remove_common(&pdev->dev, info);
802	}
803
804	static struct spi_driver flexfb_spi_driver = {
805	.driver = {
806	.name = DRVNAME,
807	},
808	.probe = flexfb_probe_spi,
809	.remove = flexfb_remove_spi,
810	};
811
812	static const struct platform_device_id flexfb_platform_ids[] = {
813	{ "flexpfb", 0 },
814	{ },
815	};
816	MODULE_DEVICE_TABLE(platform, flexfb_platform_ids);
817
818	static struct platform_driver flexfb_platform_driver = {
819	.driver = {
820	.name = DRVNAME,
821	},
822	.id_table = flexfb_platform_ids,
823	.probe = flexfb_probe_pdev,
824	.remove = flexfb_remove_pdev,
825	};
826
827	static int __init flexfb_init(void)
828	{
829	int ret, ret2;
830
831	ret = spi_register_driver(&flexfb_spi_driver);
832	ret2 = platform_driver_register(&flexfb_platform_driver);
833	if (ret < 0)
834	return ret;
835	return ret2;
836	}
837
838	static void __exit flexfb_exit(void)
839	{
840	spi_unregister_driver(&flexfb_spi_driver);
841	platform_driver_unregister(&flexfb_platform_driver);
842	}
843
844	/* ------------------------------------------------------------------------- */
845
846	module_init(flexfb_init);
847	module_exit(flexfb_exit);
848
849	MODULE_DESCRIPTION("Generic FB driver for TFT LCD displays");
850	MODULE_AUTHOR("Noralf Tronnes");
851	MODULE_LICENSE("GPL");

drivers/staging/octeon/ethernet-tx.c+5−4

 	/* Build the PKO buffer pointer */
 	hw_buffer.u64 = 0;
 	if (skb_shinfo(skb)->nr_frags == 0) {
-		hw_buffer.s.addr = XKPHYS_TO_PHYS((u64)skb->data);
+		hw_buffer.s.addr = XKPHYS_TO_PHYS((uintptr_t)skb->data);
 		hw_buffer.s.pool = 0;
 		hw_buffer.s.size = skb->len;
 	} else {
-		hw_buffer.s.addr = XKPHYS_TO_PHYS((u64)skb->data);
+		hw_buffer.s.addr = XKPHYS_TO_PHYS((uintptr_t)skb->data);
 		hw_buffer.s.pool = 0;
 		hw_buffer.s.size = skb_headlen(skb);
 		CVM_OCT_SKB_CB(skb)[0] = hw_buffer.u64;
 			skb_frag_t *fs = skb_shinfo(skb)->frags + i;
 			hw_buffer.s.addr =
-				XKPHYS_TO_PHYS((u64)skb_frag_address(fs));
+				XKPHYS_TO_PHYS((uintptr_t)skb_frag_address(fs));
 			hw_buffer.s.size = skb_frag_size(fs);
 			CVM_OCT_SKB_CB(skb)[i + 1] = hw_buffer.u64;
 		}
-		hw_buffer.s.addr = XKPHYS_TO_PHYS((u64)CVM_OCT_SKB_CB(skb));
+		hw_buffer.s.addr =
+			XKPHYS_TO_PHYS((uintptr_t)CVM_OCT_SKB_CB(skb));
 		hw_buffer.s.size = skb_shinfo(skb)->nr_frags + 1;
 		pko_command.s.segs = skb_shinfo(skb)->nr_frags + 1;
 		pko_command.s.gather = 1;

drivers/staging/octeon/octeon-stubs.h+1−1

@@ -1202,7 +1202,7 @@ static inline int cvmx_wqe_get_grp(cvmx_wqe_t *work) · 1201 unmodified lines
1202		1202
1203	static inline void *cvmx_phys_to_ptr(uint64_t physical_address)	1203	static inline void *cvmx_phys_to_ptr(uint64_t physical_address)
1204	{	1204	{
1205	return (void *)(physical_address);	1205	return (void *)(uintptr_t)(physical_address);
1206	}	1206	}
1207		1207
1208	static inline uint64_t cvmx_ptr_to_phys(void *ptr)	1208	static inline uint64_t cvmx_ptr_to_phys(void *ptr)

drivers/staging/rtl8188eu/hal/hal8188e_rate_adaptive.c+1−1

@@ -409,7 +409,7 @@ static int odm_ARFBRefresh_8188E(struct odm_dm_struct *dm_odm, struct odm_ra_inf · 408 unmodified lines
409	pRaInfo->PTModeSS = 3;	409	pRaInfo->PTModeSS = 3;
410	else if (pRaInfo->HighestRate > 0x0b)	410	else if (pRaInfo->HighestRate > 0x0b)
411	pRaInfo->PTModeSS = 2;	411	pRaInfo->PTModeSS = 2;
412	else if (pRaInfo->HighestRate > 0x0b)	412	else if (pRaInfo->HighestRate > 0x03)
413	pRaInfo->PTModeSS = 1;	413	pRaInfo->PTModeSS = 1;
414	else	414	else
415	pRaInfo->PTModeSS = 0;	415	pRaInfo->PTModeSS = 0;

drivers/staging/rtl8188eu/os_dep/usb_intf.c+4−2

 	}
 	padapter->HalData = kzalloc(sizeof(struct hal_data_8188e), GFP_KERNEL);
-	if (!padapter->HalData)
+	if (!padapter->HalData) {
-		DBG_88E("cant not alloc memory for HAL DATA\n");
+		DBG_88E("Failed to allocate memory for HAL data\n");
+		goto free_adapter;
+	}
 	/* step read_chip_version */
 	rtw_hal_read_chip_version(padapter);

drivers/staging/speakup/sysfs-driver-speakup+369−0

@@ -0,0 +1,369 @@
	1	What: /sys/accessibility/speakup/attrib_bleep
	2	KernelVersion: 2.6
	3	Contact: speakup@linux-speakup.org
	4	Description: Beeps the PC speaker when there is an attribute change such as
	5	foreground or background color when using speakup review
	6	commands. One = on, zero = off.
	7
	8	What: /sys/accessibility/speakup/bell_pos
	9	KernelVersion: 2.6
	10	Contact: speakup@linux-speakup.org
	11	Description: This works much like a typewriter bell. If for example 72 is
	12	echoed to bell_pos, it will beep the PC speaker when typing on
	13	a line past character 72.
	14
	15	What: /sys/accessibility/speakup/bleeps
	16	KernelVersion: 2.6
	17	Contact: speakup@linux-speakup.org
	18	Description: This controls whether one hears beeps through the PC speaker
	19	when using speakup's review commands.
	20	TODO: what values does it accept?
	21
	22	What: /sys/accessibility/speakup/bleep_time
	23	KernelVersion: 2.6
	24	Contact: speakup@linux-speakup.org
	25	Description: This controls the duration of the PC speaker beeps speakup
	26	produces.
	27	TODO: What are the units? Jiffies?
	28
	29	What: /sys/accessibility/speakup/cursor_time
	30	KernelVersion: 2.6
	31	Contact: speakup@linux-speakup.org
	32	Description: This controls cursor delay when using arrow keys. When a
	33	connection is very slow, with the default setting, when moving
	34	with the arrows, or backspacing etc. speakup says the incorrect
	35	characters. Set this to a higher value to adjust for the delay
	36	and better synchronisation between cursor position and speech.
	37
	38	What: /sys/accessibility/speakup/delimiters
	39	KernelVersion: 2.6
	40	Contact: speakup@linux-speakup.org
	41	Description: Delimit a word from speakup.
	42	TODO: add more info
	43
	44	What: /sys/accessibility/speakup/ex_num
	45	KernelVersion: 2.6
	46	Contact: speakup@linux-speakup.org
	47	Description: TODO:
	48
	49	What: /sys/accessibility/speakup/key_echo
	50	KernelVersion: 2.6
	51	Contact: speakup@linux-speakup.org
	52	Description: Controls if speakup speaks keys when they are typed. One = on,
	53	zero = off or don't echo keys.
	54
	55	What: /sys/accessibility/speakup/keymap
	56	KernelVersion: 2.6
	57	Contact: speakup@linux-speakup.org
	58	Description: Speakup keymap remaps keys to Speakup functions.
	59	It uses a binary
	60	format. A special program called genmap is needed to compile a
	61	textual keymap into the binary format which is then loaded into
	62	/sys/accessibility/speakup/keymap.
	63
	64	What: /sys/accessibility/speakup/no_interrupt
	65	KernelVersion: 2.6
	66	Contact: speakup@linux-speakup.org
	67	Description: Controls if typing interrupts output from speakup. With
	68	no_interrupt set to zero, typing on the keyboard will interrupt
	69	speakup if for example
	70	the say screen command is used before the
	71	entire screen is read.
	72	With no_interrupt set to one, if the say
	73	screen command is used, and one then types on the keyboard,
	74	speakup will continue to say the whole screen regardless until
	75	it finishes.
	76
	77	What: /sys/accessibility/speakup/punc_all
	78	KernelVersion: 2.6
	79	Contact: speakup@linux-speakup.org
	80	Description: This is a list of all the punctuation speakup should speak when
	81	punc_level is set to four.
	82
	83	What: /sys/accessibility/speakup/punc_level
	84	KernelVersion: 2.6
	85	Contact: speakup@linux-speakup.org
	86	Description: Controls the level of punctuation spoken as the screen is
	87	displayed, not reviewed. Levels range from zero no punctuation,
	88	to four, all punctuation. One corresponds to punc_some, two
	89	corresponds to punc_most, and three as well as four both
	90	correspond to punc_all. Some hardware synthesizers may have
	91	different levels each corresponding to three and four for
	92	punc_level. Also note that if punc_level is set to zero, and
	93	key_echo is set to one, typed punctuation is still spoken as it
	94	is typed.
	95
	96	What: /sys/accessibility/speakup/punc_most
	97	KernelVersion: 2.6
	98	Contact: speakup@linux-speakup.org
	99	Description: This is a list of all the punctuation speakup should speak when
	100	punc_level is set to two.
	101
	102	What: /sys/accessibility/speakup/punc_some
	103	KernelVersion: 2.6
	104	Contact: speakup@linux-speakup.org
	105	Description: This is a list of all the punctuation speakup should speak when
	106	punc_level is set to one.
	107
	108	What: /sys/accessibility/speakup/reading_punc
	109	KernelVersion: 2.6
	110	Contact: speakup@linux-speakup.org
	111	Description: Almost the same as punc_level, the differences being that
	112	reading_punc controls the level of punctuation when reviewing
	113	the screen with speakup's screen review commands. The other
	114	difference is that reading_punc set to three speaks punc_all,
	115	and reading_punc set to four speaks all punctuation, including
	116	spaces.
	117
	118	What: /sys/accessibility/speakup/repeats
	119	KernelVersion: 2.6
	120	Contact: speakup@linux-speakup.org
	121	Description: A list of characters speakup repeats. Normally, when there are
	122	more than three characters in a row, speakup
	123	just reads three of
	124	those characters. For example, "......" would be read as dot,
	125	dot, dot. If a . is added to the list of characters in repeats,
	126	"......" would be read as dot, dot, dot, times six.
	127
	128	What: /sys/accessibility/speakup/say_control
	129	KernelVersion: 2.6
	130	Contact: speakup@linux-speakup.org
	131	Description: If set to one, speakup speaks shift, alt and control when those
	132	keys are pressed. If say_control is set to zero, shift, ctrl,
	133	and alt are not spoken when they are pressed.
	134
	135	What: /sys/accessibility/speakup/say_word_ctl
	136	KernelVersion: 2.6
	137	Contact: speakup@linux-speakup.org
	138	Description: TODO:
	139
	140	What: /sys/accessibility/speakup/silent
	141	KernelVersion: 2.6
	142	Contact: speakup@linux-speakup.org
	143	Description: TODO:
	144
	145	What: /sys/accessibility/speakup/spell_delay
	146	KernelVersion: 2.6
	147	Contact: speakup@linux-speakup.org
	148	Description: This controls how fast a word is spelled
	149	when speakup's say word
	150	review command is pressed twice quickly to speak the current
	151	word being reviewed. Zero just speaks the letters one after
	152	another, while values one through four
	153	seem to introduce more of
	154	a pause between the spelling of each letter by speakup.
	155
	156	What: /sys/accessibility/speakup/synth
	157	KernelVersion: 2.6
	158	Contact: speakup@linux-speakup.org
	159	Description: Gets or sets the synthesizer driver currently in use. Reading
	160	synth returns the synthesizer driver currently in use. Writing
	161	synth switches to the given synthesizer driver, provided it is
	162	either built into the kernel, or already loaded as a module.
	163
	164	What: /sys/accessibility/speakup/synth_direct
	165	KernelVersion: 2.6
	166	Contact: speakup@linux-speakup.org
	167	Description: Sends whatever is written to synth_direct
	168	directly to the speech synthesizer in use, bypassing speakup.
	169	This could be used to make the synthesizer speak
	170	a string, or to
	171	send control sequences to the synthesizer to change how the
	172	synthesizer behaves.
	173
	174	What: /sys/accessibility/speakup/version
	175	KernelVersion: 2.6
	176	Contact: speakup@linux-speakup.org
	177	Description: Reading version returns the version of speakup, and the version
	178	of the synthesizer driver currently in use.
	179
	180	What: /sys/accessibility/speakup/i18n/announcements
	181	KernelVersion: 2.6
	182	Contact: speakup@linux-speakup.org
	183	Description: This file contains various general announcements, most of which
	184	cannot be categorized. You will find messages such as "You
	185	killed Speakup", "I'm alive", "leaving help", "parked",
	186	"unparked", and others. You will also find the names of the
	187	screen edges and cursor tracking modes here.
	188
	189	What: /sys/accessibility/speakup/i18n/chartab
	190	KernelVersion: 2.6
	191	Contact: speakup@linux-speakup.org
	192	Description: TODO
	193
	194	What: /sys/accessibility/speakup/i18n/ctl_keys
	195	KernelVersion: 2.6
	196	Contact: speakup@linux-speakup.org
	197	Description: Here, you will find names of control keys. These are used with
	198	Speakup's say_control feature.
	199
	200	What: /sys/accessibility/speakup/i18n/function_names
	201	KernelVersion: 2.6
	202	Contact: speakup@linux-speakup.org
	203	Description: Here, you will find a list of names for Speakup functions.
	204	These are used by the help system. For example, suppose that
	205	you have activated help mode, and you pressed
	206	keypad 3. Speakup
	207	says: "keypad 3 is character, say next."
	208	The message "character, say next" names a Speakup function, and
	209	it comes from this function_names file.
	210
	211	What: /sys/accessibility/speakup/i18n/states
	212	KernelVersion: 2.6
	213	Contact: speakup@linux-speakup.org
	214	Description: This file contains names for key states.
	215	Again, these are part of the help system. For instance, if you
	216	had pressed speakup + keypad 3, you would hear:
	217	"speakup keypad 3 is go to bottom edge."
	218	The speakup key is depressed, so the name of the key state is
	219	speakup.
	220	This part of the message comes from the states collection.
	221
	222	What: /sys/accessibility/speakup/i18n/characters
	223	KernelVersion: 2.6
	224	Contact: speakup@linux-speakup.org
	225	Description: Through this sys entry, Speakup gives you the ability to change
	226	how Speakup pronounces a given character. You could, for
	227	example, change how some punctuation characters are spoken. You
	228	can even change how Speakup will pronounce certain letters. For
	229	further details see '12. Changing the Pronunciation of
	230	Characters' in Speakup User's Guide (file spkguide.txt in
	231	source).
	232
	233	What: /sys/accessibility/speakup/i18n/colors
	234	KernelVersion: 2.6
	235	Contact: speakup@linux-speakup.org
	236	Description: When you use the "say attributes" function, Speakup says the
	237	name of the foreground and background colors. These names come
	238	from the i18n/colors file.
	239
	240	What: /sys/accessibility/speakup/i18n/formatted
	241	KernelVersion: 2.6
	242	Contact: speakup@linux-speakup.org
	243	Description: This group of messages contains embedded formatting codes, to
	244	specify the type and width of displayed data. If you change
	245	these, you must preserve all of the formatting codes, and they
	246	must appear in the order used by the default messages.
	247
	248	What: /sys/accessibility/speakup/i18n/key_names
	249	KernelVersion: 2.6
	250	Contact: speakup@linux-speakup.org
	251	Description: Again, key_names is used by Speakup's help system. In the
	252	previous example, Speakup said that you pressed "keypad 3."
	253	This name came from the key_names file.
	254
	255	What: /sys/accessibility/speakup/<synth-name>/
	256	KernelVersion: 2.6
	257	Contact: speakup@linux-speakup.org
	258	Description: In `/sys/accessibility/speakup` is a directory corresponding to
	259	the synthesizer driver currently in use (E.G) `soft` for the
	260	soft driver. This directory contains files which control the
	261	speech synthesizer itself,
	262	as opposed to controlling the speakup
	263	screen reader. The parameters in this directory have the same
	264	names and functions across all
	265	supported synthesizers. The range
	266	of values for freq, pitch, rate, and vol is the same for all
	267	supported synthesizers, with the given range being internally
	268	mapped by the driver to more or less fit the range of values
	269	supported for a given parameter by the individual synthesizer.
	270	Below is a description of values and parameters for soft
	271	synthesizer, which is currently the most commonly used.
	272
	273	What: /sys/accessibility/speakup/soft/caps_start
	274	KernelVersion: 2.6
	275	Contact: speakup@linux-speakup.org
	276	Description: This is the string that is sent to the synthesizer to cause it
	277	to start speaking uppercase letters. For the soft synthesizer
	278	and most others, this causes the pitch of the voice to rise
	279	above the currently set pitch.
	280
	281	What: /sys/accessibility/speakup/soft/caps_stop
	282	KernelVersion: 2.6
	283	Contact: speakup@linux-speakup.org
	284	Description: This is the string sent to the synthesizer to cause it to stop
	285	speaking uppercase letters. In the case of the soft synthesizer
	286	and most others, this returns the pitch of the voice
	287	down to the
	288	currently set pitch.
	289
	290	What: /sys/accessibility/speakup/soft/delay_time
	291	KernelVersion: 2.6
	292	Contact: speakup@linux-speakup.org
	293	Description: TODO:
	294
	295	What: /sys/accessibility/speakup/soft/direct
	296	KernelVersion: 2.6
	297	Contact: speakup@linux-speakup.org
	298	Description: Controls if punctuation is spoken by speakup, or by the
	299	synthesizer.
	300	For example, speakup speaks ">" as "greater", while
	301	the espeak synthesizer used by the soft driver speaks "greater
	302	than". Zero lets speakup speak the punctuation. One lets the
	303	synthesizer itself speak punctuation.
	304
	305	What: /sys/accessibility/speakup/soft/freq
	306	KernelVersion: 2.6
	307	Contact: speakup@linux-speakup.org
	308	Description: Gets or sets the frequency of the speech synthesizer. Range is
	309	0-9.
	310
	311	What: /sys/accessibility/speakup/soft/full_time
	312	KernelVersion: 2.6
	313	Contact: speakup@linux-speakup.org
	314	Description: TODO:
	315
	316	What: /sys/accessibility/speakup/soft/jiffy_delta
	317	KernelVersion: 2.6
	318	Contact: speakup@linux-speakup.org
	319	Description: This controls how many jiffys the kernel gives to the
	320	synthesizer. Setting this too high can make a system unstable,
	321	or even crash it.
	322
	323	What: /sys/accessibility/speakup/soft/pitch
	324	KernelVersion: 2.6
	325	Contact: speakup@linux-speakup.org
	326	Description: Gets or sets the pitch of the synthesizer. The range is 0-9.
	327
	328	What: /sys/accessibility/speakup/soft/punct
	329	KernelVersion: 2.6
	330	Contact: speakup@linux-speakup.org
	331	Description: Gets or sets the amount of punctuation spoken by the
	332	synthesizer. The range for the soft driver seems to be 0-2.
	333	TODO: How is this related to speakup's punc_level, or
	334	reading_punc.
	335
	336	What: /sys/accessibility/speakup/soft/rate
	337	KernelVersion: 2.6
	338	Contact: speakup@linux-speakup.org
	339	Description: Gets or sets the rate of the synthesizer. Range is from zero
	340	slowest, to nine fastest.
	341
	342	What: /sys/accessibility/speakup/soft/tone
	343	KernelVersion: 2.6
	344	Contact: speakup@linux-speakup.org
	345	Description: Gets or sets the tone of the speech synthesizer. The range for
	346	the soft driver seems to be 0-2. This seems to make no
	347	difference if using espeak and the espeakup connector.
	348	TODO: does espeakup support different tonalities?
	349
	350	What: /sys/accessibility/speakup/soft/trigger_time
	351	KernelVersion: 2.6
	352	Contact: speakup@linux-speakup.org
	353	Description: TODO:
	354
	355	What: /sys/accessibility/speakup/soft/voice
	356	KernelVersion: 2.6
	357	Contact: speakup@linux-speakup.org
	358	Description: Gets or sets the voice used by the synthesizer if the
	359	synthesizer can speak in more than one voice. The range for the
	360	soft driver is 0-7. Note that while espeak supports multiple
	361	voices, this parameter will not set the voice when the espeakup
	362	connector is used between speakup and espeak.
	363
	364	What: /sys/accessibility/speakup/soft/vol
	365	KernelVersion: 2.6
	366	Contact: speakup@linux-speakup.org
	367	Description: Gets or sets the volume of the speech synthesizer. Range is 0-9,
	368	with zero being the softest, and nine being the loudest.
	369

drivers/staging/vc04_services/bcm2835-audio/bcm2835-pcm.c+2−2

drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c+1−0

@@ -289,6 +289,7 @@ int bcm2835_audio_stop(struct bcm2835_alsa_stream *alsa_stream) · 288 unmodified lines
289	VC_AUDIO_MSG_TYPE_STOP, false);	289	VC_AUDIO_MSG_TYPE_STOP, false);
290	}	290	}
291		291
		292	/* FIXME: this doesn't seem working as expected for "draining" */
292	int bcm2835_audio_drain(struct bcm2835_alsa_stream *alsa_stream)	293	int bcm2835_audio_drain(struct bcm2835_alsa_stream *alsa_stream)
293	{	294	{
294	struct vc_audio_msg m = {	295	struct vc_audio_msg m = {

drivers/staging/vt6655/device_main.c+3−1

@@ -1748,8 +1748,10 @@ vt6655_probe(struct pci_dev pcid, const struct pci_device_id ent) · 1747 unmodified lines
1748		1748
1749	priv->hw->max_signal = 100;	1749	priv->hw->max_signal = 100;
1750		1750
1751	if (vnt_init(priv))	1751	if (vnt_init(priv)) {
		1752	device_free_info(priv);
1752	return -ENODEV;	1753	return -ENODEV;
		1754	}
1753		1755
1754	device_print_info(priv);	1756	device_print_info(priv);
1755	pci_set_drvdata(pcid, priv);	1757	pci_set_drvdata(pcid, priv);

drivers/tty/n_hdlc.c+5−0

 }	/* end of init_module() */
+#ifdef CONFIG_SPARC
+#undef __exitdata
+#define __exitdata
+#endif
 static const char hdlc_unregister_ok[] __exitdata =
 	KERN_INFO "N_HDLC: line discipline unregistered\n";
 static const char hdlc_unregister_fail[] __exitdata =

drivers/tty/serial/8250/8250_omap.c+3−2

 	serial8250_do_set_mctrl(port, mctrl);
-	if (!up->gpios) {
+	if (!mctrl_gpio_to_gpiod(up->gpios, UART_GPIO_RTS)) {
 		/*
 		 * Turn off autoRTS if RTS is lowered and restore autoRTS
 		 * setting if RTS is raised
 	up->port.status &= ~(UPSTAT_AUTOCTS | UPSTAT_AUTORTS | UPSTAT_AUTOXOFF);
 	if (termios->c_cflag & CRTSCTS && up->port.flags & UPF_HARD_FLOW &&
-	    !up->gpios) {
+	    !mctrl_gpio_to_gpiod(up->gpios, UART_GPIO_RTS) &&
+	    !mctrl_gpio_to_gpiod(up->gpios, UART_GPIO_CTS)) {
 		/* Enable AUTOCTS (autoRTS is enabled when RTS is raised) */
 		up->port.status |= UPSTAT_AUTOCTS | UPSTAT_AUTORTS;
 		priv->efr |= UART_EFR_CTS;

drivers/tty/serial/Kconfig+1−0

@@ -1032,6 +1032,7 @@ config SERIAL_SIFIVE_CONSOLE · 1031 unmodified lines
1032	bool "Console on SiFive UART"	1032	bool "Console on SiFive UART"
1033	depends on SERIAL_SIFIVE=y	1033	depends on SERIAL_SIFIVE=y
1034	select SERIAL_CORE_CONSOLE	1034	select SERIAL_CORE_CONSOLE
		1035	select SERIAL_EARLYCON
1035	help	1036	help
1036	Select this option if you would like to use a SiFive UART as the	1037	Select this option if you would like to use a SiFive UART as the
1037	system console.	1038	system console.

drivers/tty/serial/fsl_linflexuart.c+14−7

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	* Freescale linflexuart serial port driver	3	* Freescale linflexuart serial port driver
4	*	4	*
5	* Copyright 2012-2016 Freescale Semiconductor, Inc.	5	* Copyright 2012-2016 Freescale Semiconductor, Inc.
6	* Copyright 2017-2018 NXP	6	* Copyright 2017-2019 NXP
7	*/	7	*/
8		8
9	#if defined(CONFIG_SERIAL_FSL_LINFLEXUART_CONSOLE) && \	9	#if defined(CONFIG_SERIAL_FSL_LINFLEXUART_CONSOLE) && \
@@ -246,12 +246,14 @@ static irqreturn_t linflex_rxint(int irq, void *dev_id) · 236 unmodified lines
246	struct tty_port *port = &sport->state->port;	246	struct tty_port *port = &sport->state->port;
247	unsigned long flags, status;	247	unsigned long flags, status;
248	unsigned char rx;	248	unsigned char rx;
		249	bool brk;
249		250
250	spin_lock_irqsave(&sport->lock, flags);	251	spin_lock_irqsave(&sport->lock, flags);
251		252
252	status = readl(sport->membase + UARTSR);	253	status = readl(sport->membase + UARTSR);
253	while (status & LINFLEXD_UARTSR_RMB) {	254	while (status & LINFLEXD_UARTSR_RMB) {
254	rx = readb(sport->membase + BDRM);	255	rx = readb(sport->membase + BDRM);
		256	brk = false;
255	flg = TTY_NORMAL;	257	flg = TTY_NORMAL;
256	sport->icount.rx++;	258	sport->icount.rx++;
257		259
@@ -261,8 +263,11 @@ static irqreturn_t linflex_rxint(int irq, void *dev_id) · 3 unmodified lines
261	status \|= LINFLEXD_UARTSR_SZF;	263	status \|= LINFLEXD_UARTSR_SZF;
262	if (status & LINFLEXD_UARTSR_BOF)	264	if (status & LINFLEXD_UARTSR_BOF)
263	status \|= LINFLEXD_UARTSR_BOF;	265	status \|= LINFLEXD_UARTSR_BOF;
264	if (status & LINFLEXD_UARTSR_FEF)	266	if (status & LINFLEXD_UARTSR_FEF) {
		267	if (!rx)
		268	brk = true;
265	status \|= LINFLEXD_UARTSR_FEF;	269	status \|= LINFLEXD_UARTSR_FEF;
		270	}
266	if (status & LINFLEXD_UARTSR_PE)	271	if (status & LINFLEXD_UARTSR_PE)
267	status \|= LINFLEXD_UARTSR_PE;	272	status \|= LINFLEXD_UARTSR_PE;
268	}	273	}
@@ -271,13 +276,15 @@ static irqreturn_t linflex_rxint(int irq, void *dev_id) · 2 unmodified lines
271	sport->membase + UARTSR);	276	sport->membase + UARTSR);
272	status = readl(sport->membase + UARTSR);	277	status = readl(sport->membase + UARTSR);
273		278
274	if (uart_handle_sysrq_char(sport, (unsigned char)rx))	279	if (brk) {
275	continue;	280	uart_handle_break(sport);
276		281	} else {
277	#ifdef SUPPORT_SYSRQ	282	#ifdef SUPPORT_SYSRQ
278	sport->sysrq = 0;	283	if (uart_handle_sysrq_char(sport, (unsigned char)rx))
		284	continue;
279	#endif	285	#endif
280	tty_insert_flip_char(port, rx, flg);	286	tty_insert_flip_char(port, rx, flg);
		287	}
281	}	288	}
282		289
283	spin_unlock_irqrestore(&sport->lock, flags);	290	spin_unlock_irqrestore(&sport->lock, flags);

drivers/tty/serial/fsl_lpuart.c+1−1

@@ -548,7 +548,7 @@ static void lpuart_flush_buffer(struct uart_port *port) · 547 unmodified lines
548	val \|= UARTFIFO_TXFLUSH \| UARTFIFO_RXFLUSH;	548	val \|= UARTFIFO_TXFLUSH \| UARTFIFO_RXFLUSH;
549	lpuart32_write(&sport->port, val, UARTFIFO);	549	lpuart32_write(&sport->port, val, UARTFIFO);
550	} else {	550	} else {
551	val = readb(sport->port.membase + UARTPFIFO);	551	val = readb(sport->port.membase + UARTCFIFO);
552	val \|= UARTCFIFO_TXFLUSH \| UARTCFIFO_RXFLUSH;	552	val \|= UARTCFIFO_TXFLUSH \| UARTCFIFO_RXFLUSH;
553	writeb(val, sport->port.membase + UARTCFIFO);	553	writeb(val, sport->port.membase + UARTCFIFO);
554	}	554	}

drivers/tty/serial/imx.c+2−2

@@ -2222,8 +2222,8 @@ static int imx_uart_probe(struct platform_device *pdev) · 2221 unmodified lines
2222	return PTR_ERR(base);	2222	return PTR_ERR(base);
2223		2223
2224	rxirq = platform_get_irq(pdev, 0);	2224	rxirq = platform_get_irq(pdev, 0);
2225	txirq = platform_get_irq(pdev, 1);	2225	txirq = platform_get_irq_optional(pdev, 1);
2226	rtsirq = platform_get_irq(pdev, 2);	2226	rtsirq = platform_get_irq_optional(pdev, 2);
2227		2227
2228	sport->port.dev = &pdev->dev;	2228	sport->port.dev = &pdev->dev;
2229	sport->port.mapbase = res->start;	2229	sport->port.mapbase = res->start;

drivers/tty/serial/owl-uart.c+1−1

@@ -740,7 +740,7 @@ static int __init owl_uart_init(void) · 739 unmodified lines
740	return ret;	740	return ret;
741	}	741	}
742		742
743	static void __init owl_uart_exit(void)	743	static void __exit owl_uart_exit(void)
744	{	744	{
745	platform_driver_unregister(&owl_uart_platform_driver);	745	platform_driver_unregister(&owl_uart_platform_driver);
746	uart_unregister_driver(&owl_uart_driver);	746	uart_unregister_driver(&owl_uart_driver);

drivers/tty/serial/rda-uart.c+1−1

@@ -815,7 +815,7 @@ static int __init rda_uart_init(void) · 814 unmodified lines
815	return ret;	815	return ret;
816	}	816	}
817		817
818	static void __init rda_uart_exit(void)	818	static void __exit rda_uart_exit(void)
819	{	819	{
820	platform_driver_unregister(&rda_uart_platform_driver);	820	platform_driver_unregister(&rda_uart_platform_driver);
821	uart_unregister_driver(&rda_uart_driver);	821	uart_unregister_driver(&rda_uart_driver);

drivers/tty/serial/serial_core.c+2−0

  *	   console=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options>
  *
  *	The optional form
+ *
  *	   earlycon=<name>,0x<addr>,<options>
  *	   console=<name>,0x<addr>,<options>
+ *
  *	is also accepted; the returned @iotype will be UPIO_MEM.
  *
  *	Returns 0 on success or -EINVAL on failure

drivers/tty/serial/serial_mctrl_gpio.c+3−0

 struct gpio_desc *mctrl_gpio_to_gpiod(struct mctrl_gpios *gpios,
 				      enum mctrl_gpio_idx gidx)
 {
+	if (gpios == NULL)
+		return NULL;
 	return gpios->gpio[gidx];
 }
 EXPORT_SYMBOL_GPL(mctrl_gpio_to_gpiod);

drivers/tty/serial/sh-sci.c+6−2

 	port->mapbase = res->start;
 	sci_port->reg_size = resource_size(res);
-	for (i = 0; i < ARRAY_SIZE(sci_port->irqs); ++i)
+	for (i = 0; i < ARRAY_SIZE(sci_port->irqs); ++i) {
-		sci_port->irqs[i] = platform_get_irq(dev, i);
+		if (i)
+			sci_port->irqs[i] = platform_get_irq_optional(dev, i);
+		else
+			sci_port->irqs[i] = platform_get_irq(dev, i);
+	}
 	/* The SCI generates several interrupts. They can be muxed together or
 	 * connected to different interrupt lines. In the muxed case only one

drivers/tty/serial/uartlite.c+2−1

@@ -897,7 +897,8 @@ static int __init ulite_init(void) · 896 unmodified lines
897	static void __exit ulite_exit(void)	897	static void __exit ulite_exit(void)
898	{	898	{
899	platform_driver_unregister(&ulite_platform_driver);	899	platform_driver_unregister(&ulite_platform_driver);
900	uart_unregister_driver(&ulite_uart_driver);	900	if (ulite_uart_driver.state)
		901	uart_unregister_driver(&ulite_uart_driver);
901	}	902	}
902		903
903	module_init(ulite_init);	904	module_init(ulite_init);

drivers/tty/serial/xilinx_uartps.c+7−1

 		goto err_out_id;
 	}
-	uartps_major = cdns_uart_uart_driver->tty_driver->major;
 	cdns_uart_data->cdns_uart_driver = cdns_uart_uart_driver;
 	/*
 		console_port = NULL;
 #endif
+	uartps_major = cdns_uart_uart_driver->tty_driver->major;
 	cdns_uart_data->cts_override = of_property_read_bool(pdev->dev.of_node,
 							     "cts-override");
 	return 0;
 		console_port = NULL;
 #endif
+	/* If this is last instance major number should be initialized */
+	mutex_lock(&bitmap_lock);
+	if (bitmap_empty(bitmap, MAX_UART_INSTANCES))
+		uartps_major = 0;
+	mutex_unlock(&bitmap_lock);
 	uart_unregister_driver(cdns_uart_data->cdns_uart_driver);
 	return rc;
 }

drivers/usb/cdns3/cdns3-pci-wrap.c+2−1

 		wrap->plat_dev = platform_device_register_full(&plat_info);
 		if (IS_ERR(wrap->plat_dev)) {
 			pci_disable_device(pdev);
+			err = PTR_ERR(wrap->plat_dev);
 			kfree(wrap);
-			return PTR_ERR(wrap->plat_dev);
+			return err;
 		}
 	}

drivers/usb/cdns3/core.c+19−1

@@ -160,10 +160,28 @@ static int cdns3_core_init_role(struct cdns3 *cdns) · 159 unmodified lines
160	if (ret)	160	if (ret)
161	goto err;	161	goto err;
162		162
163	if (cdns->dr_mode != USB_DR_MODE_OTG) {	163	/* Initialize idle role to start with */
		164	ret = cdns3_role_start(cdns, USB_ROLE_NONE);
		165	if (ret)
		166	goto err;
		167
		168	switch (cdns->dr_mode) {
		169	case USB_DR_MODE_UNKNOWN:
		170	case USB_DR_MODE_OTG:
164	ret = cdns3_hw_role_switch(cdns);	171	ret = cdns3_hw_role_switch(cdns);
165	if (ret)	172	if (ret)
166	goto err;	173	goto err;
		174	break;
		175	case USB_DR_MODE_PERIPHERAL:
		176	ret = cdns3_role_start(cdns, USB_ROLE_DEVICE);
		177	if (ret)
		178	goto err;
		179	break;
		180	case USB_DR_MODE_HOST:
		181	ret = cdns3_role_start(cdns, USB_ROLE_HOST);
		182	if (ret)
		183	goto err;
		184	break;
167	}	185	}
168		186
169	return ret;	187	return ret;

drivers/usb/cdns3/ep0.c+9−3

 static int cdns3_req_ep0_get_status(struct cdns3_device *priv_dev,
 				    struct usb_ctrlrequest *ctrl)
 {
+	struct cdns3_endpoint *priv_ep;
 	__le16 *response_pkt;
 	u16 usb_status = 0;
 	u32 recip;
+	u8 index;
 	recip = ctrl->bRequestType & USB_RECIP_MASK;
 	case USB_RECIP_INTERFACE:
 		return cdns3_ep0_delegate_req(priv_dev, ctrl);
 	case USB_RECIP_ENDPOINT:
-		/* check if endpoint is stalled */
+		index = cdns3_ep_addr_to_index(ctrl->wIndex);
+		priv_ep = priv_dev->eps[index];
+		/* check if endpoint is stalled or stall is pending */
 		cdns3_select_ep(priv_dev, ctrl->wIndex);
-		if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)))
+		if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)) ||
+		    (priv_ep->flags & EP_STALL_PENDING))
 			usb_status =  BIT(USB_ENDPOINT_HALT);
 		break;
 	default:
 			 * for sending status stage.
 			 * This time should be less then 3ms.
 			 */
-			usleep_range(1000, 2000);
+			mdelay(1);
 			cdns3_set_register_bit(&priv_dev->regs->usb_cmd,
 					       USB_CMD_STMODE |
 					       USB_STS_TMODE_SEL(tmode - 1));

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

 	switch (max_speed) {
 	case USB_SPEED_FULL:
 		writel(USB_CONF_SFORCE_FS, &priv_dev->regs->usb_conf);
+		writel(USB_CONF_USB3DIS, &priv_dev->regs->usb_conf);
 		break;
 	case USB_SPEED_HIGH:
 		writel(USB_CONF_USB3DIS, &priv_dev->regs->usb_conf);
 {
 	int ret = 0;
+	/* Ensure 32-bit DMA Mask in case we switched back from Host mode */
+	ret = dma_set_mask_and_coherent(cdns->dev, DMA_BIT_MASK(32));
+	if (ret) {
+		dev_err(cdns->dev, "Failed to set dma mask: %d\n", ret);
+		return ret;
+	}
 	cdns3_drd_switch_gadget(cdns, 1);
 	pm_runtime_get_sync(cdns->dev);

drivers/usb/class/usblp.c+5−3

@@ -461,10 +461,12 @@ static int usblp_release(struct inode inode, struct file file) · 460 unmodified lines
461		461
462	mutex_lock(&usblp_mutex);	462	mutex_lock(&usblp_mutex);
463	usblp->used = 0;	463	usblp->used = 0;
464	if (usblp->present) {	464	if (usblp->present)
465	usblp_unlink_urbs(usblp);	465	usblp_unlink_urbs(usblp);
466	usb_autopm_put_interface(usblp->intf);	466
467	} else /* finish cleanup from disconnect */	467	usb_autopm_put_interface(usblp->intf);
		468
		469	if (!usblp->present) /* finish cleanup from disconnect */
468	usblp_cleanup(usblp);	470	usblp_cleanup(usblp);
469	mutex_unlock(&usblp_mutex);	471	mutex_unlock(&usblp_mutex);
470	return 0;	472	return 0;

drivers/usb/dwc3/drd.c+2−5

 	struct platform_device *dwc3_pdev = to_platform_device(dwc->dev);
 	int irq;
-	irq = platform_get_irq_byname(dwc3_pdev, "otg");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "otg");
 	if (irq > 0)
 		goto out;
 	if (irq == -EPROBE_DEFER)
 		goto out;
-	irq = platform_get_irq_byname(dwc3_pdev, "dwc_usb3");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "dwc_usb3");
 	if (irq > 0)
 		goto out;
 	if (irq > 0)
 		goto out;
-	if (irq != -EPROBE_DEFER)
-		dev_err(dwc->dev, "missing OTG IRQ\n");
 	if (!irq)
 		irq = -EINVAL;

drivers/usb/dwc3/gadget.c+2−5

 	struct platform_device *dwc3_pdev = to_platform_device(dwc->dev);
 	int irq;
-	irq = platform_get_irq_byname(dwc3_pdev, "peripheral");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "peripheral");
 	if (irq > 0)
 		goto out;
 	if (irq == -EPROBE_DEFER)
 		goto out;
-	irq = platform_get_irq_byname(dwc3_pdev, "dwc_usb3");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "dwc_usb3");
 	if (irq > 0)
 		goto out;
 	if (irq > 0)
 		goto out;
-	if (irq != -EPROBE_DEFER)
-		dev_err(dwc->dev, "missing peripheral IRQ\n");
 	if (!irq)
 		irq = -EINVAL;

drivers/usb/dwc3/host.c+2−5

 	struct platform_device	*dwc3_pdev = to_platform_device(dwc->dev);
 	int irq;
-	irq = platform_get_irq_byname(dwc3_pdev, "host");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "host");
 	if (irq > 0)
 		goto out;
 	if (irq == -EPROBE_DEFER)
 		goto out;
-	irq = platform_get_irq_byname(dwc3_pdev, "dwc_usb3");
+	irq = platform_get_irq_byname_optional(dwc3_pdev, "dwc_usb3");
 	if (irq > 0)
 		goto out;
 	if (irq > 0)
 		goto out;
-	if (irq != -EPROBE_DEFER)
-		dev_err(dwc->dev, "missing host IRQ\n");
 	if (!irq)
 		irq = -EINVAL;

drivers/usb/gadget/udc/Kconfig+1−1

@@ -45,7 +45,7 @@ config USB_AT91 · 44 unmodified lines
45		45
46	config USB_LPC32XX	46	config USB_LPC32XX
47	tristate "LPC32XX USB Peripheral Controller"	47	tristate "LPC32XX USB Peripheral Controller"
48	depends on ARCH_LPC32XX	48	depends on ARCH_LPC32XX \|\| COMPILE_TEST
49	depends on I2C	49	depends on I2C
50	select USB_ISP1301	50	select USB_ISP1301
51	help	51	help

drivers/usb/gadget/udc/dummy_hcd.c+2−1

 #define DRIVER_VERSION	"02 May 2005"
 #define POWER_BUDGET	500	/* in mA; use 8 for low-power port testing */
+#define POWER_BUDGET_3	900	/* in mA */
 static const char	driver_name[] = "dummy_hcd";
 static const char	driver_desc[] = "USB Host+Gadget Emulator";
 	dum_hcd->rh_state = DUMMY_RH_RUNNING;
 	dum_hcd->stream_en_ep = 0;
 	INIT_LIST_HEAD(&dum_hcd->urbp_list);
-	dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET;
+	dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET_3;
 	dummy_hcd_to_hcd(dum_hcd)->state = HC_STATE_RUNNING;
 	dummy_hcd_to_hcd(dum_hcd)->uses_new_polling = 1;
 #ifdef CONFIG_USB_OTG

drivers/usb/gadget/udc/lpc32xx_udc.c+2−2

@@ -1151,7 +1151,7 @@ static void udc_pop_fifo(struct lpc32xx_udc udc, u8 data, u32 bytes) · 1150 unmodified lines
1151	u32 *p32, tmp, cbytes;	1151	u32 *p32, tmp, cbytes;
1152		1152
1153	/* Use optimal data transfer method based on source address and size */	1153	/* Use optimal data transfer method based on source address and size */
1154	switch (((u32) data) & 0x3) {	1154	switch (((uintptr_t) data) & 0x3) {
1155	case 0: /* 32-bit aligned */	1155	case 0: /* 32-bit aligned */
1156	p32 = (u32 *) data;	1156	p32 = (u32 *) data;
1157	cbytes = (bytes & ~0x3);	1157	cbytes = (bytes & ~0x3);
@@ -1252,7 +1252,7 @@ static void udc_stuff_fifo(struct lpc32xx_udc udc, u8 data, u32 bytes) · 94 unmodified lines
1252	u32 *p32, tmp, cbytes;	1252	u32 *p32, tmp, cbytes;
1253		1253
1254	/* Use optimal data transfer method based on source address and size */	1254	/* Use optimal data transfer method based on source address and size */
1255	switch (((u32) data) & 0x3) {	1255	switch (((uintptr_t) data) & 0x3) {
1256	case 0: /* 32-bit aligned */	1256	case 0: /* 32-bit aligned */
1257	p32 = (u32 *) data;	1257	p32 = (u32 *) data;
1258	cbytes = (bytes & ~0x3);	1258	cbytes = (bytes & ~0x3);

drivers/usb/host/xhci-ext-caps.c+1−0

@@ -57,6 +57,7 @@ static int xhci_create_intel_xhci_sw_pdev(struct xhci_hcd *xhci, u32 cap_offset) · 56 unmodified lines
57	ret = platform_device_add_properties(pdev, role_switch_props);	57	ret = platform_device_add_properties(pdev, role_switch_props);
58	if (ret) {	58	if (ret) {
59	dev_err(dev, "failed to register device properties\n");	59	dev_err(dev, "failed to register device properties\n");
		60	platform_device_put(pdev);
60	return ret;	61	return ret;
61	}	62	}
62	}	63	}

drivers/usb/host/xhci-ring.c+2−2

@@ -3202,10 +3202,10 @@ static int xhci_align_td(struct xhci_hcd xhci, struct urb urb, u32 enqd_len, · 3201 unmodified lines
3202	if (usb_urb_dir_out(urb)) {	3202	if (usb_urb_dir_out(urb)) {
3203	len = sg_pcopy_to_buffer(urb->sg, urb->num_sgs,	3203	len = sg_pcopy_to_buffer(urb->sg, urb->num_sgs,
3204	seg->bounce_buf, new_buff_len, enqd_len);	3204	seg->bounce_buf, new_buff_len, enqd_len);
3205	if (len != seg->bounce_len)	3205	if (len != new_buff_len)
3206	xhci_warn(xhci,	3206	xhci_warn(xhci,
3207	"WARN Wrong bounce buffer write length: %zu != %d\n",	3207	"WARN Wrong bounce buffer write length: %zu != %d\n",
3208	len, seg->bounce_len);	3208	len, new_buff_len);
3209	seg->bounce_dma = dma_map_single(dev, seg->bounce_buf,	3209	seg->bounce_dma = dma_map_single(dev, seg->bounce_buf,
3210	max_pkt, DMA_TO_DEVICE);	3210	max_pkt, DMA_TO_DEVICE);
3211	} else {	3211	} else {

drivers/usb/host/xhci.c+63−15

@@ -1032,7 +1032,7 @@ int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup) · 1031 unmodified lines
1032	writel(command, &xhci->op_regs->command);	1032	writel(command, &xhci->op_regs->command);
1033	xhci->broken_suspend = 0;	1033	xhci->broken_suspend = 0;
1034	if (xhci_handshake(&xhci->op_regs->status,	1034	if (xhci_handshake(&xhci->op_regs->status,
1035	STS_SAVE, 0, 10 * 1000)) {	1035	STS_SAVE, 0, 20 * 1000)) {
1036	/*	1036	/*
1037	* AMD SNPS xHC 3.0 occasionally does not clear the	1037	* AMD SNPS xHC 3.0 occasionally does not clear the
1038	* SSS bit of USBSTS and when driver tries to poll	1038	* SSS bit of USBSTS and when driver tries to poll
@@ -1108,6 +1108,18 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated) · 69 unmodified lines
1108	hibernated = true;	1108	hibernated = true;
1109		1109
1110	if (!hibernated) {	1110	if (!hibernated) {
		1111	/*
		1112	* Some controllers might lose power during suspend, so wait
		1113	* for controller not ready bit to clear, just as in xHC init.
		1114	*/
		1115	retval = xhci_handshake(&xhci->op_regs->status,
		1116	STS_CNR, 0, 10 * 1000 * 1000);
		1117	if (retval) {
		1118	xhci_warn(xhci, "Controller not ready at resume %d\n",
		1119	retval);
		1120	spin_unlock_irq(&xhci->lock);
		1121	return retval;
		1122	}
1111	/* step 1: restore register */	1123	/* step 1: restore register */
1112	xhci_restore_registers(xhci);	1124	xhci_restore_registers(xhci);
1113	/* step 2: initialize command ring buffer */	1125	/* step 2: initialize command ring buffer */
@@ -3083,6 +3095,7 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd, · 1969 unmodified lines
3083	unsigned int ep_index;	3095	unsigned int ep_index;
3084	unsigned long flags;	3096	unsigned long flags;
3085	u32 ep_flag;	3097	u32 ep_flag;
		3098	int err;
3086		3099
3087	xhci = hcd_to_xhci(hcd);	3100	xhci = hcd_to_xhci(hcd);
3088	if (!host_ep->hcpriv)	3101	if (!host_ep->hcpriv)
@@ -3142,7 +3155,17 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd, · 53 unmodified lines
3142	xhci_free_command(xhci, cfg_cmd);	3155	xhci_free_command(xhci, cfg_cmd);
3143	goto cleanup;	3156	goto cleanup;
3144	}	3157	}
3145	xhci_queue_stop_endpoint(xhci, stop_cmd, udev->slot_id, ep_index, 0);	3158
		3159	err = xhci_queue_stop_endpoint(xhci, stop_cmd, udev->slot_id,
		3160	ep_index, 0);
		3161	if (err < 0) {
		3162	spin_unlock_irqrestore(&xhci->lock, flags);
		3163	xhci_free_command(xhci, cfg_cmd);
		3164	xhci_dbg(xhci, "%s: Failed to queue stop ep command, %d ",
		3165	__func__, err);
		3166	goto cleanup;
		3167	}
		3168
3146	xhci_ring_cmd_db(xhci);	3169	xhci_ring_cmd_db(xhci);
3147	spin_unlock_irqrestore(&xhci->lock, flags);	3170	spin_unlock_irqrestore(&xhci->lock, flags);
3148		3171
@@ -3156,8 +3179,16 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd, · 7 unmodified lines
3156	ctrl_ctx, ep_flag, ep_flag);	3179	ctrl_ctx, ep_flag, ep_flag);
3157	xhci_endpoint_copy(xhci, cfg_cmd->in_ctx, vdev->out_ctx, ep_index);	3180	xhci_endpoint_copy(xhci, cfg_cmd->in_ctx, vdev->out_ctx, ep_index);
3158		3181
3159	xhci_queue_configure_endpoint(xhci, cfg_cmd, cfg_cmd->in_ctx->dma,	3182	err = xhci_queue_configure_endpoint(xhci, cfg_cmd, cfg_cmd->in_ctx->dma,
3160	udev->slot_id, false);	3183	udev->slot_id, false);
		3184	if (err < 0) {
		3185	spin_unlock_irqrestore(&xhci->lock, flags);
		3186	xhci_free_command(xhci, cfg_cmd);
		3187	xhci_dbg(xhci, "%s: Failed to queue config ep command, %d ",
		3188	__func__, err);
		3189	goto cleanup;
		3190	}
		3191
3161	xhci_ring_cmd_db(xhci);	3192	xhci_ring_cmd_db(xhci);
3162	spin_unlock_irqrestore(&xhci->lock, flags);	3193	spin_unlock_irqrestore(&xhci->lock, flags);
3163		3194
@@ -4674,12 +4705,12 @@ static int xhci_update_timeout_for_endpoint(struct xhci_hcd *xhci, · 1510 unmodified lines
4674	alt_timeout = xhci_call_host_update_timeout_for_endpoint(xhci, udev,	4705	alt_timeout = xhci_call_host_update_timeout_for_endpoint(xhci, udev,
4675	desc, state, timeout);	4706	desc, state, timeout);
4676		4707
4677	/* If we found we can't enable hub-initiated LPM, or	4708	/* If we found we can't enable hub-initiated LPM, and
4678	* the U1 or U2 exit latency was too high to allow	4709	* the U1 or U2 exit latency was too high to allow
4679	* device-initiated LPM as well, just stop searching.	4710	* device-initiated LPM as well, then we will disable LPM
		4711	* for this device, so stop searching any further.
4680	*/	4712	*/
4681	if (alt_timeout == USB3_LPM_DISABLED \|\|	4713	if (alt_timeout == USB3_LPM_DISABLED) {
4682	alt_timeout == USB3_LPM_DEVICE_INITIATED) {
4683	*timeout = alt_timeout;	4714	*timeout = alt_timeout;
4684	return -E2BIG;	4715	return -E2BIG;
4685	}	4716	}
@@ -4790,10 +4821,12 @@ static u16 xhci_calculate_lpm_timeout(struct usb_hcd *hcd, · 104 unmodified lines
4790	if (intf->dev.driver) {	4821	if (intf->dev.driver) {
4791	driver = to_usb_driver(intf->dev.driver);	4822	driver = to_usb_driver(intf->dev.driver);
4792	if (driver && driver->disable_hub_initiated_lpm) {	4823	if (driver && driver->disable_hub_initiated_lpm) {
4793	dev_dbg(&udev->dev, "Hub-initiated %s disabled "	4824	dev_dbg(&udev->dev, "Hub-initiated %s disabled at request of driver %s\n",
4794	"at request of driver %s\n",	4825	state_name, driver->name);
4795	state_name, driver->name);	4826	timeout = xhci_get_timeout_no_hub_lpm(udev,
4796	return xhci_get_timeout_no_hub_lpm(udev, state);	4827	state);
		4828	if (timeout == USB3_LPM_DISABLED)
		4829	return timeout;
4797	}	4830	}
4798	}	4831	}
4799		4832
@@ -5077,11 +5110,18 @@ int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks) · 277 unmodified lines
5077	hcd->has_tt = 1;	5110	hcd->has_tt = 1;
5078	} else {	5111	} else {
5079	/*	5112	/*
5080	* Some 3.1 hosts return sbrn 0x30, use xhci supported protocol	5113	* Early xHCI 1.1 spec did not mention USB 3.1 capable hosts
5081	* minor revision instead of sbrn. Minor revision is a two digit	5114	* should return 0x31 for sbrn, or that the minor revision
5082	* BCD containing minor and sub-minor numbers, only show minor.	5115	* is a two digit BCD containig minor and sub-minor numbers.
		5116	* This was later clarified in xHCI 1.2.
		5117	*
		5118	* Some USB 3.1 capable hosts therefore have sbrn 0x30, and
		5119	* minor revision set to 0x1 instead of 0x10.
5083	*/	5120	*/
5084	minor_rev = xhci->usb3_rhub.min_rev / 0x10;	5121	if (xhci->usb3_rhub.min_rev == 0x1)
		5122	minor_rev = 1;
		5123	else
		5124	minor_rev = xhci->usb3_rhub.min_rev / 0x10;
5085		5125
5086	switch (minor_rev) {	5126	switch (minor_rev) {
5087	case 2:	5127	case 2:
@@ -5198,8 +5238,16 @@ static void xhci_clear_tt_buffer_complete(struct usb_hcd *hcd, · 110 unmodified lines
5198	unsigned int ep_index;	5238	unsigned int ep_index;
5199	unsigned long flags;	5239	unsigned long flags;
5200		5240
		5241	/*
		5242	* udev might be NULL if tt buffer is cleared during a failed device
		5243	* enumeration due to a halted control endpoint. Usb core might
		5244	* have allocated a new udev for the next enumeration attempt.
		5245	*/
		5246
5201	xhci = hcd_to_xhci(hcd);	5247	xhci = hcd_to_xhci(hcd);
5202	udev = (struct usb_device *)ep->hcpriv;	5248	udev = (struct usb_device *)ep->hcpriv;
		5249	if (!udev)
		5250	return;
5203	slot_id = udev->slot_id;	5251	slot_id = udev->slot_id;
5204	ep_index = xhci_get_endpoint_index(&ep->desc);	5252	ep_index = xhci_get_endpoint_index(&ep->desc);
5205		5253

drivers/usb/image/microtek.c+4−0

@@ -716,6 +716,10 @@ static int mts_usb_probe(struct usb_interface *intf, · 715 unmodified lines
716		716
717	}	717	}
718		718
		719	if (ep_in_current != &ep_in_set[2]) {
		720	MTS_WARNING("couldn't find two input bulk endpoints. Bailing out.\n");
		721	return -ENODEV;
		722	}
719		723
720	if ( ep_out == -1 ) {	724	if ( ep_out == -1 ) {
721	MTS_WARNING( "couldn't find an output bulk endpoint. Bailing out.\n" );	725	MTS_WARNING( "couldn't find an output bulk endpoint. Bailing out.\n" );

drivers/usb/misc/Kconfig+0−10

@@ -47,16 +47,6 @@ config USB_SEVSEG · 46 unmodified lines
47	To compile this driver as a module, choose M here: the	47	To compile this driver as a module, choose M here: the
48	module will be called usbsevseg.	48	module will be called usbsevseg.
49		49
50	config USB_RIO500
51	tristate "USB Diamond Rio500 support"
52	help
53	Say Y here if you want to connect a USB Rio500 mp3 player to your
54	computer's USB port. Please read <file:Documentation/usb/rio.rst>
55	for more information.
56
57	To compile this driver as a module, choose M here: the
58	module will be called rio500.
59
60	config USB_LEGOTOWER	50	config USB_LEGOTOWER
61	tristate "USB Lego Infrared Tower support"	51	tristate "USB Lego Infrared Tower support"
62	help	52	help

drivers/usb/misc/Makefile+0−1

@@ -17,7 +17,6 @@ obj-$(CONFIG_USB_ISIGHTFW) += isight_firmware.o · 16 unmodified lines
17	obj-$(CONFIG_USB_LCD) += usblcd.o	17	obj-$(CONFIG_USB_LCD) += usblcd.o
18	obj-$(CONFIG_USB_LD) += ldusb.o	18	obj-$(CONFIG_USB_LD) += ldusb.o
19	obj-$(CONFIG_USB_LEGOTOWER) += legousbtower.o	19	obj-$(CONFIG_USB_LEGOTOWER) += legousbtower.o
20	obj-$(CONFIG_USB_RIO500) += rio500.o
21	obj-$(CONFIG_USB_TEST) += usbtest.o	20	obj-$(CONFIG_USB_TEST) += usbtest.o
22	obj-$(CONFIG_USB_EHSET_TEST_FIXTURE) += ehset.o	21	obj-$(CONFIG_USB_EHSET_TEST_FIXTURE) += ehset.o
23	obj-$(CONFIG_USB_TRANCEVIBRATOR) += trancevibrator.o	22	obj-$(CONFIG_USB_TRANCEVIBRATOR) += trancevibrator.o

drivers/usb/misc/adutux.c+15−9

@@ -75,6 +75,7 @@ struct adu_device { · 74 unmodified lines
75	char serial_number[8];	75	char serial_number[8];
76		76
77	int open_count; /* number of times this port has been opened */	77	int open_count; /* number of times this port has been opened */
		78	unsigned long disconnected:1;
78		79
79	char *read_buffer_primary;	80	char *read_buffer_primary;
80	int read_buffer_length;	81	int read_buffer_length;
@@ -116,7 +117,7 @@ static void adu_abort_transfers(struct adu_device *dev) · 35 unmodified lines
116	{	117	{
117	unsigned long flags;	118	unsigned long flags;
118		119
119	if (dev->udev == NULL)	120	if (dev->disconnected)
120	return;	121	return;
121		122
122	/* shutdown transfer */	123	/* shutdown transfer */
@@ -148,6 +149,7 @@ static void adu_delete(struct adu_device *dev) · 25 unmodified lines
148	kfree(dev->read_buffer_secondary);	149	kfree(dev->read_buffer_secondary);
149	kfree(dev->interrupt_in_buffer);	150	kfree(dev->interrupt_in_buffer);
150	kfree(dev->interrupt_out_buffer);	151	kfree(dev->interrupt_out_buffer);
		152	usb_put_dev(dev->udev);
151	kfree(dev);	153	kfree(dev);
152	}	154	}
153		155
@@ -243,7 +245,7 @@ static int adu_open(struct inode inode, struct file file) · 89 unmodified lines
243	}	245	}
244		246
245	dev = usb_get_intfdata(interface);	247	dev = usb_get_intfdata(interface);
246	if (!dev \|\| !dev->udev) {	248	if (!dev) {
247	retval = -ENODEV;	249	retval = -ENODEV;
248	goto exit_no_device;	250	goto exit_no_device;
249	}	251	}
@@ -326,7 +328,7 @@ static int adu_release(struct inode inode, struct file file) · 76 unmodified lines
326	}	328	}
327		329
328	adu_release_internal(dev);	330	adu_release_internal(dev);
329	if (dev->udev == NULL) {	331	if (dev->disconnected) {
330	/* the device was unplugged before the file was released */	332	/* the device was unplugged before the file was released */
331	if (!dev->open_count) /* ... and we're the last user */	333	if (!dev->open_count) /* ... and we're the last user */
332	adu_delete(dev);	334	adu_delete(dev);
@@ -354,7 +356,7 @@ static ssize_t adu_read(struct file file, __user char buffer, size_t count, · 21 unmodified lines
354	return -ERESTARTSYS;	356	return -ERESTARTSYS;
355		357
356	/* verify that the device wasn't unplugged */	358	/* verify that the device wasn't unplugged */
357	if (dev->udev == NULL) {	359	if (dev->disconnected) {
358	retval = -ENODEV;	360	retval = -ENODEV;
359	pr_err("No device or device unplugged %d\n", retval);	361	pr_err("No device or device unplugged %d\n", retval);
360	goto exit;	362	goto exit;
@@ -518,7 +520,7 @@ static ssize_t adu_write(struct file file, const __user char buffer, · 157 unmodified lines
518	goto exit_nolock;	520	goto exit_nolock;
519		521
520	/* verify that the device wasn't unplugged */	522	/* verify that the device wasn't unplugged */
521	if (dev->udev == NULL) {	523	if (dev->disconnected) {
522	retval = -ENODEV;	524	retval = -ENODEV;
523	pr_err("No device or device unplugged %d\n", retval);	525	pr_err("No device or device unplugged %d\n", retval);
524	goto exit;	526	goto exit;
@@ -663,7 +665,7 @@ static int adu_probe(struct usb_interface *interface, · 138 unmodified lines
663		665
664	mutex_init(&dev->mtx);	666	mutex_init(&dev->mtx);
665	spin_lock_init(&dev->buflock);	667	spin_lock_init(&dev->buflock);
666	dev->udev = udev;	668	dev->udev = usb_get_dev(udev);
667	init_waitqueue_head(&dev->read_wait);	669	init_waitqueue_head(&dev->read_wait);
668	init_waitqueue_head(&dev->write_wait);	670	init_waitqueue_head(&dev->write_wait);
669		671
@@ -762,14 +764,18 @@ static void adu_disconnect(struct usb_interface *interface) · 92 unmodified lines
762		764
763	dev = usb_get_intfdata(interface);	765	dev = usb_get_intfdata(interface);
764		766
765	mutex_lock(&dev->mtx); /* not interruptible */
766	dev->udev = NULL; /* poison */
767	usb_deregister_dev(interface, &adu_class);	767	usb_deregister_dev(interface, &adu_class);
768	mutex_unlock(&dev->mtx);	768
		769	usb_poison_urb(dev->interrupt_in_urb);
		770	usb_poison_urb(dev->interrupt_out_urb);
769		771
770	mutex_lock(&adutux_mutex);	772	mutex_lock(&adutux_mutex);
771	usb_set_intfdata(interface, NULL);	773	usb_set_intfdata(interface, NULL);
772		774
		775	mutex_lock(&dev->mtx); /* not interruptible */
		776	dev->disconnected = 1;
		777	mutex_unlock(&dev->mtx);
		778
773	/* if the device is not opened, then we clean up right now */	779	/* if the device is not opened, then we clean up right now */
774	if (!dev->open_count)	780	if (!dev->open_count)
775	adu_delete(dev);	781	adu_delete(dev);

drivers/usb/misc/chaoskey.c+3−2

 		usb_free_urb(dev->urb);
 		kfree(dev->name);
 		kfree(dev->buf);
+		usb_put_intf(dev->interface);
 		kfree(dev);
 	}
 }
 	if (dev == NULL)
 		goto out;
+	dev->interface = usb_get_intf(interface);
 	dev->buf = kmalloc(size, GFP_KERNEL);
 	if (dev->buf == NULL)
 			goto out;
 	}
-	dev->interface = interface;
 	dev->in_ep = in_ep;
 	if (le16_to_cpu(udev->descriptor.idVendor) != ALEA_VENDOR_ID)

drivers/usb/misc/iowarrior.c+15−33

@@ -54,11 +54,7 @@ MODULE_AUTHOR(DRIVER_AUTHOR); · 53 unmodified lines
54	MODULE_DESCRIPTION(DRIVER_DESC);	54	MODULE_DESCRIPTION(DRIVER_DESC);
55	MODULE_LICENSE("GPL");	55	MODULE_LICENSE("GPL");
56		56
57	/* Module parameters */
58	static DEFINE_MUTEX(iowarrior_mutex);
59
60	static struct usb_driver iowarrior_driver;	57	static struct usb_driver iowarrior_driver;
61	static DEFINE_MUTEX(iowarrior_open_disc_lock);
62		58
63	/--------------/	59	/--------------/
64	/* data */	60	/* data */
@@ -87,6 +83,7 @@ struct iowarrior { · 22 unmodified lines
87	char chip_serial[9]; /* the serial number string of the chip connected */	83	char chip_serial[9]; /* the serial number string of the chip connected */
88	int report_size; /* number of bytes in a report */	84	int report_size; /* number of bytes in a report */
89	u16 product_id;	85	u16 product_id;
		86	struct usb_anchor submitted;
90	};	87	};
91		88
92	/--------------/	89	/--------------/
@@ -243,6 +240,7 @@ static inline void iowarrior_delete(struct iowarrior *dev) · 150 unmodified lines
243	kfree(dev->int_in_buffer);	240	kfree(dev->int_in_buffer);
244	usb_free_urb(dev->int_in_urb);	241	usb_free_urb(dev->int_in_urb);
245	kfree(dev->read_queue);	242	kfree(dev->read_queue);
		243	usb_put_intf(dev->interface);
246	kfree(dev);	244	kfree(dev);
247	}	245	}
248		246
@@ -424,11 +422,13 @@ static ssize_t iowarrior_write(struct file *file, · 175 unmodified lines
424	retval = -EFAULT;	422	retval = -EFAULT;
425	goto error;	423	goto error;
426	}	424	}
		425	usb_anchor_urb(int_out_urb, &dev->submitted);
427	retval = usb_submit_urb(int_out_urb, GFP_KERNEL);	426	retval = usb_submit_urb(int_out_urb, GFP_KERNEL);
428	if (retval) {	427	if (retval) {
429	dev_dbg(&dev->interface->dev,	428	dev_dbg(&dev->interface->dev,
430	"submit error %d for urb nr.%d\n",	429	"submit error %d for urb nr.%d\n",
431	retval, atomic_read(&dev->write_busy));	430	retval, atomic_read(&dev->write_busy));
		431	usb_unanchor_urb(int_out_urb);
432	goto error;	432	goto error;
433	}	433	}
434	/* submit was ok */	434	/* submit was ok */
@@ -477,8 +477,6 @@ static long iowarrior_ioctl(struct file *file, unsigned int cmd, · 42 unmodified lines
477	if (!buffer)	477	if (!buffer)
478	return -ENOMEM;	478	return -ENOMEM;
479		479
480	/* lock this object */
481	mutex_lock(&iowarrior_mutex);
482	mutex_lock(&dev->mutex);	480	mutex_lock(&dev->mutex);
483		481
484	/* verify that the device wasn't unplugged */	482	/* verify that the device wasn't unplugged */
@@ -571,7 +569,6 @@ static long iowarrior_ioctl(struct file *file, unsigned int cmd, · 86 unmodified lines
571	error_out:	569	error_out:
572	/* unlock the device */	570	/* unlock the device */
573	mutex_unlock(&dev->mutex);	571	mutex_unlock(&dev->mutex);
574	mutex_unlock(&iowarrior_mutex);
575	kfree(buffer);	572	kfree(buffer);
576	return retval;	573	return retval;
577	}	574	}
@@ -586,27 +583,20 @@ static int iowarrior_open(struct inode inode, struct file file) · 8 unmodified lines
586	int subminor;	583	int subminor;
587	int retval = 0;	584	int retval = 0;
588		585
589	mutex_lock(&iowarrior_mutex);
590	subminor = iminor(inode);	586	subminor = iminor(inode);
591		587
592	interface = usb_find_interface(&iowarrior_driver, subminor);	588	interface = usb_find_interface(&iowarrior_driver, subminor);
593	if (!interface) {	589	if (!interface) {
594	mutex_unlock(&iowarrior_mutex);	590	pr_err("%s - error, can't find device for minor %d\n",
595	printk(KERN_ERR "%s - error, can't find device for minor %d\n",
596	__func__, subminor);	591	__func__, subminor);
597	return -ENODEV;	592	return -ENODEV;
598	}	593	}
599		594
600	mutex_lock(&iowarrior_open_disc_lock);
601	dev = usb_get_intfdata(interface);	595	dev = usb_get_intfdata(interface);
602	if (!dev) {	596	if (!dev)
603	mutex_unlock(&iowarrior_open_disc_lock);
604	mutex_unlock(&iowarrior_mutex);
605	return -ENODEV;	597	return -ENODEV;
606	}
607		598
608	mutex_lock(&dev->mutex);	599	mutex_lock(&dev->mutex);
609	mutex_unlock(&iowarrior_open_disc_lock);
610		600
611	/* Only one process can open each device, no sharing. */	601	/* Only one process can open each device, no sharing. */
612	if (dev->opened) {	602	if (dev->opened) {
@@ -628,7 +618,6 @@ static int iowarrior_open(struct inode inode, struct file file) · 15 unmodified lines
628		618
629	out:	619	out:
630	mutex_unlock(&dev->mutex);	620	mutex_unlock(&dev->mutex);
631	mutex_unlock(&iowarrior_mutex);
632	return retval;	621	return retval;
633	}	622	}
634		623
@@ -764,11 +753,13 @@ static int iowarrior_probe(struct usb_interface *interface, · 129 unmodified lines
764	init_waitqueue_head(&dev->write_wait);	753	init_waitqueue_head(&dev->write_wait);
765		754
766	dev->udev = udev;	755	dev->udev = udev;
767	dev->interface = interface;	756	dev->interface = usb_get_intf(interface);
768		757
769	iface_desc = interface->cur_altsetting;	758	iface_desc = interface->cur_altsetting;
770	dev->product_id = le16_to_cpu(udev->descriptor.idProduct);	759	dev->product_id = le16_to_cpu(udev->descriptor.idProduct);
771		760
		761	init_usb_anchor(&dev->submitted);
		762
772	res = usb_find_last_int_in_endpoint(iface_desc, &dev->int_in_endpoint);	763	res = usb_find_last_int_in_endpoint(iface_desc, &dev->int_in_endpoint);
773	if (res) {	764	if (res) {
774	dev_err(&interface->dev, "no interrupt-in endpoint found\n");	765	dev_err(&interface->dev, "no interrupt-in endpoint found\n");
@@ -836,7 +827,6 @@ static int iowarrior_probe(struct usb_interface *interface, · 61 unmodified lines
836	if (retval) {	827	if (retval) {
837	/* something prevented us from registering this driver */	828	/* something prevented us from registering this driver */
838	dev_err(&interface->dev, "Not able to get a minor for this device.\n");	829	dev_err(&interface->dev, "Not able to get a minor for this device.\n");
839	usb_set_intfdata(interface, NULL);
840	goto error;	830	goto error;
841	}	831	}
842		832
@@ -860,26 +850,15 @@ error: · 17 unmodified lines
860	*/	850	*/
861	static void iowarrior_disconnect(struct usb_interface *interface)	851	static void iowarrior_disconnect(struct usb_interface *interface)
862	{	852	{
863	struct iowarrior *dev;	853	struct iowarrior *dev = usb_get_intfdata(interface);
864	int minor;	854	int minor = dev->minor;
865
866	dev = usb_get_intfdata(interface);
867	mutex_lock(&iowarrior_open_disc_lock);
868	usb_set_intfdata(interface, NULL);
869	/* prevent device read, write and ioctl */
870	dev->present = 0;
871
872	minor = dev->minor;
873	mutex_unlock(&iowarrior_open_disc_lock);
874	/* give back our minor - this will call close() locks need to be dropped at this point*/
875		855
876	usb_deregister_dev(interface, &iowarrior_class);	856	usb_deregister_dev(interface, &iowarrior_class);
877		857
878	mutex_lock(&dev->mutex);	858	mutex_lock(&dev->mutex);
879		859
880	/* prevent device read, write and ioctl */	860	/* prevent device read, write and ioctl */
881		861	dev->present = 0;
882	mutex_unlock(&dev->mutex);
883		862
884	if (dev->opened) {	863	if (dev->opened) {
885	/* There is a process that holds a filedescriptor to the device ,	864	/* There is a process that holds a filedescriptor to the device ,
@@ -887,10 +866,13 @@ static void iowarrior_disconnect(struct usb_interface *interface) · 1 unmodified line
887	Deleting the device is postponed until close() was called.	866	Deleting the device is postponed until close() was called.
888	*/	867	*/
889	usb_kill_urb(dev->int_in_urb);	868	usb_kill_urb(dev->int_in_urb);
		869	usb_kill_anchored_urbs(&dev->submitted);
890	wake_up_interruptible(&dev->read_wait);	870	wake_up_interruptible(&dev->read_wait);
891	wake_up_interruptible(&dev->write_wait);	871	wake_up_interruptible(&dev->write_wait);
		872	mutex_unlock(&dev->mutex);
892	} else {	873	} else {
893	/* no process is using the device, cleanup now */	874	/* no process is using the device, cleanup now */
		875	mutex_unlock(&dev->mutex);
894	iowarrior_delete(dev);	876	iowarrior_delete(dev);
895	}	877	}
896		878

drivers/usb/misc/ldusb.c+12−12

 struct ld_usb {
 	struct mutex		mutex;		/* locks this structure */
 	struct usb_interface	*intf;		/* save off the usb interface pointer */
+	unsigned long		disconnected:1;
 	int			open_count;	/* number of times this port has been opened */
 	/* shutdown transfer */
 	if (dev->interrupt_in_running) {
 		dev->interrupt_in_running = 0;
-		if (dev->intf)
+		usb_kill_urb(dev->interrupt_in_urb);
-			usb_kill_urb(dev->interrupt_in_urb);
 	}
 	if (dev->interrupt_out_busy)
-		if (dev->intf)
+		usb_kill_urb(dev->interrupt_out_urb);
-			usb_kill_urb(dev->interrupt_out_urb);
 }
 /**
  */
 static void ld_usb_delete(struct ld_usb *dev)
 {
-	ld_usb_abort_transfers(dev);
 	/* free data structures */
 	usb_free_urb(dev->interrupt_in_urb);
 	usb_free_urb(dev->interrupt_out_urb);
 resubmit:
 	/* resubmit if we're still running */
-	if (dev->interrupt_in_running && !dev->buffer_overflow && dev->intf) {
+	if (dev->interrupt_in_running && !dev->buffer_overflow) {
 		retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);
 		if (retval) {
 			dev_err(&dev->intf->dev,
 		retval = -ENODEV;
 		goto unlock_exit;
 	}
-	if (dev->intf == NULL) {
+	if (dev->disconnected) {
 		/* the device was unplugged before the file was released */
 		mutex_unlock(&dev->mutex);
 		/* unlock here as ld_usb_delete frees dev */
 	dev = file->private_data;
-	if (!dev->intf)
+	if (dev->disconnected)
 		return EPOLLERR | EPOLLHUP;
 	poll_wait(file, &dev->read_wait, wait);
 	}
 	/* verify that the device wasn't unplugged */
-	if (dev->intf == NULL) {
+	if (dev->disconnected) {
 		retval = -ENODEV;
 		printk(KERN_ERR "ldusb: No device or device unplugged %d\n", retval);
 		goto unlock_exit;
 	}
 	/* verify that the device wasn't unplugged */
-	if (dev->intf == NULL) {
+	if (dev->disconnected) {
 		retval = -ENODEV;
 		printk(KERN_ERR "ldusb: No device or device unplugged %d\n", retval);
 		goto unlock_exit;
 	/* give back our minor */
 	usb_deregister_dev(intf, &ld_usb_class);
+	usb_poison_urb(dev->interrupt_in_urb);
+	usb_poison_urb(dev->interrupt_out_urb);
 	mutex_lock(&dev->mutex);
 	/* if the device is not opened, then we clean up right now */
 		mutex_unlock(&dev->mutex);
 		ld_usb_delete(dev);
 	} else {
-		dev->intf = NULL;
+		dev->disconnected = 1;
 		/* wake up pollers */
 		wake_up_interruptible_all(&dev->read_wait);
 		wake_up_interruptible_all(&dev->write_wait);

drivers/usb/misc/legousbtower.c+25−33

@@ -179,7 +179,6 @@ static const struct usb_device_id tower_table[] = { · 178 unmodified lines
179	};	179	};
180		180
181	MODULE_DEVICE_TABLE (usb, tower_table);	181	MODULE_DEVICE_TABLE (usb, tower_table);
182	static DEFINE_MUTEX(open_disc_mutex);
183		182
184	#define LEGO_USB_TOWER_MINOR_BASE 160	183	#define LEGO_USB_TOWER_MINOR_BASE 160
185		184
@@ -191,6 +190,7 @@ struct lego_usb_tower { · 5 unmodified lines
191	unsigned char minor; /* the starting minor number for this device */	190	unsigned char minor; /* the starting minor number for this device */
192		191
193	int open_count; /* number of times this port has been opened */	192	int open_count; /* number of times this port has been opened */
		193	unsigned long disconnected:1;
194		194
195	char* read_buffer;	195	char* read_buffer;
196	size_t read_buffer_length; /* this much came in */	196	size_t read_buffer_length; /* this much came in */
@@ -290,14 +290,13 @@ static inline void lego_usb_tower_debug_data(struct device *dev, · 93 unmodified lines
290	*/	290	*/
291	static inline void tower_delete (struct lego_usb_tower *dev)	291	static inline void tower_delete (struct lego_usb_tower *dev)
292	{	292	{
293	tower_abort_transfers (dev);
294
295	/* free data structures */	293	/* free data structures */
296	usb_free_urb(dev->interrupt_in_urb);	294	usb_free_urb(dev->interrupt_in_urb);
297	usb_free_urb(dev->interrupt_out_urb);	295	usb_free_urb(dev->interrupt_out_urb);
298	kfree (dev->read_buffer);	296	kfree (dev->read_buffer);
299	kfree (dev->interrupt_in_buffer);	297	kfree (dev->interrupt_in_buffer);
300	kfree (dev->interrupt_out_buffer);	298	kfree (dev->interrupt_out_buffer);
		299	usb_put_dev(dev->udev);
301	kfree (dev);	300	kfree (dev);
302	}	301	}
303		302
@@ -332,18 +331,14 @@ static int tower_open (struct inode inode, struct file file) · 28 unmodified lines
332	goto exit;	331	goto exit;
333	}	332	}
334		333
335	mutex_lock(&open_disc_mutex);
336	dev = usb_get_intfdata(interface);	334	dev = usb_get_intfdata(interface);
337
338	if (!dev) {	335	if (!dev) {
339	mutex_unlock(&open_disc_mutex);
340	retval = -ENODEV;	336	retval = -ENODEV;
341	goto exit;	337	goto exit;
342	}	338	}
343		339
344	/* lock this device */	340	/* lock this device */
345	if (mutex_lock_interruptible(&dev->lock)) {	341	if (mutex_lock_interruptible(&dev->lock)) {
346	mutex_unlock(&open_disc_mutex);
347	retval = -ERESTARTSYS;	342	retval = -ERESTARTSYS;
348	goto exit;	343	goto exit;
349	}	344	}
@@ -351,12 +346,9 @@ static int tower_open (struct inode inode, struct file file) · 1 unmodified line
351		346
352	/* allow opening only once */	347	/* allow opening only once */
353	if (dev->open_count) {	348	if (dev->open_count) {
354	mutex_unlock(&open_disc_mutex);
355	retval = -EBUSY;	349	retval = -EBUSY;
356	goto unlock_exit;	350	goto unlock_exit;
357	}	351	}
358	dev->open_count = 1;
359	mutex_unlock(&open_disc_mutex);
360		352
361	/* reset the tower */	353	/* reset the tower */
362	result = usb_control_msg (dev->udev,	354	result = usb_control_msg (dev->udev,
@@ -396,13 +388,14 @@ static int tower_open (struct inode inode, struct file file) · 33 unmodified lines
396	dev_err(&dev->udev->dev,	388	dev_err(&dev->udev->dev,
397	"Couldn't submit interrupt_in_urb %d\n", retval);	389	"Couldn't submit interrupt_in_urb %d\n", retval);
398	dev->interrupt_in_running = 0;	390	dev->interrupt_in_running = 0;
399	dev->open_count = 0;
400	goto unlock_exit;	391	goto unlock_exit;
401	}	392	}
402		393
403	/* save device in the file's private structure */	394	/* save device in the file's private structure */
404	file->private_data = dev;	395	file->private_data = dev;
405		396
		397	dev->open_count = 1;
		398
406	unlock_exit:	399	unlock_exit:
407	mutex_unlock(&dev->lock);	400	mutex_unlock(&dev->lock);
408		401
@@ -423,10 +416,9 @@ static int tower_release (struct inode inode, struct file file) · 14 unmodified lines
423		416
424	if (dev == NULL) {	417	if (dev == NULL) {
425	retval = -ENODEV;	418	retval = -ENODEV;
426	goto exit_nolock;	419	goto exit;
427	}	420	}
428		421
429	mutex_lock(&open_disc_mutex);
430	if (mutex_lock_interruptible(&dev->lock)) {	422	if (mutex_lock_interruptible(&dev->lock)) {
431	retval = -ERESTARTSYS;	423	retval = -ERESTARTSYS;
432	goto exit;	424	goto exit;
@@ -438,7 +430,8 @@ static int tower_release (struct inode inode, struct file file) · 5 unmodified lines
438	retval = -ENODEV;	430	retval = -ENODEV;
439	goto unlock_exit;	431	goto unlock_exit;
440	}	432	}
441	if (dev->udev == NULL) {	433
		434	if (dev->disconnected) {
442	/* the device was unplugged before the file was released */	435	/* the device was unplugged before the file was released */
443		436
444	/* unlock here as tower_delete frees dev */	437	/* unlock here as tower_delete frees dev */
@@ -456,10 +449,7 @@ static int tower_release (struct inode inode, struct file file) · 11 unmodified lines
456		449
457	unlock_exit:	450	unlock_exit:
458	mutex_unlock(&dev->lock);	451	mutex_unlock(&dev->lock);
459
460	exit:	452	exit:
461	mutex_unlock(&open_disc_mutex);
462	exit_nolock:
463	return retval;	453	return retval;
464	}	454	}
465		455
@@ -477,10 +467,9 @@ static void tower_abort_transfers (struct lego_usb_tower *dev) · 11 unmodified lines
477	if (dev->interrupt_in_running) {	467	if (dev->interrupt_in_running) {
478	dev->interrupt_in_running = 0;	468	dev->interrupt_in_running = 0;
479	mb();	469	mb();
480	if (dev->udev)	470	usb_kill_urb(dev->interrupt_in_urb);
481	usb_kill_urb (dev->interrupt_in_urb);
482	}	471	}
483	if (dev->interrupt_out_busy && dev->udev)	472	if (dev->interrupt_out_busy)
484	usb_kill_urb(dev->interrupt_out_urb);	473	usb_kill_urb(dev->interrupt_out_urb);
485	}	474	}
486		475
@@ -516,7 +505,7 @@ static __poll_t tower_poll (struct file file, poll_table wait) · 29 unmodified lines
516		505
517	dev = file->private_data;	506	dev = file->private_data;
518		507
519	if (!dev->udev)	508	if (dev->disconnected)
520	return EPOLLERR \| EPOLLHUP;	509	return EPOLLERR \| EPOLLHUP;
521		510
522	poll_wait(file, &dev->read_wait, wait);	511	poll_wait(file, &dev->read_wait, wait);
@@ -563,7 +552,7 @@ static ssize_t tower_read (struct file file, char __user buffer, size_t count, · 40 unmodified lines
563	}	552	}
564		553
565	/* verify that the device wasn't unplugged */	554	/* verify that the device wasn't unplugged */
566	if (dev->udev == NULL) {	555	if (dev->disconnected) {
567	retval = -ENODEV;	556	retval = -ENODEV;
568	pr_err("No device or device unplugged %d\n", retval);	557	pr_err("No device or device unplugged %d\n", retval);
569	goto unlock_exit;	558	goto unlock_exit;
@@ -649,7 +638,7 @@ static ssize_t tower_write (struct file file, const char __user buffer, size_t · 79 unmodified lines
649	}	638	}
650		639
651	/* verify that the device wasn't unplugged */	640	/* verify that the device wasn't unplugged */
652	if (dev->udev == NULL) {	641	if (dev->disconnected) {
653	retval = -ENODEV;	642	retval = -ENODEV;
654	pr_err("No device or device unplugged %d\n", retval);	643	pr_err("No device or device unplugged %d\n", retval);
655	goto unlock_exit;	644	goto unlock_exit;
@@ -759,7 +748,7 @@ static void tower_interrupt_in_callback (struct urb *urb) · 103 unmodified lines
759		748
760	resubmit:	749	resubmit:
761	/* resubmit if we're still running */	750	/* resubmit if we're still running */
762	if (dev->interrupt_in_running && dev->udev) {	751	if (dev->interrupt_in_running) {
763	retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);	752	retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);
764	if (retval)	753	if (retval)
765	dev_err(&dev->udev->dev,	754	dev_err(&dev->udev->dev,
@@ -822,8 +811,9 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device · 56 unmodified lines
822		811
823	mutex_init(&dev->lock);	812	mutex_init(&dev->lock);
824		813
825	dev->udev = udev;	814	dev->udev = usb_get_dev(udev);
826	dev->open_count = 0;	815	dev->open_count = 0;
		816	dev->disconnected = 0;
827		817
828	dev->read_buffer = NULL;	818	dev->read_buffer = NULL;
829	dev->read_buffer_length = 0;	819	dev->read_buffer_length = 0;
@@ -891,8 +881,10 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device · 61 unmodified lines
891	get_version_reply,	881	get_version_reply,
892	sizeof(*get_version_reply),	882	sizeof(*get_version_reply),
893	1000);	883	1000);
894	if (result < 0) {	884	if (result < sizeof(*get_version_reply)) {
895	dev_err(idev, "LEGO USB Tower get version control request failed\n");	885	if (result >= 0)
		886	result = -EIO;
		887	dev_err(idev, "get version request failed: %d\n", result);
896	retval = result;	888	retval = result;
897	goto error;	889	goto error;
898	}	890	}
@@ -910,7 +902,6 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device · 11 unmodified lines
910	if (retval) {	902	if (retval) {
911	/* something prevented us from registering this driver */	903	/* something prevented us from registering this driver */
912	dev_err(idev, "Not able to get a minor for this device.\n");	904	dev_err(idev, "Not able to get a minor for this device.\n");
913	usb_set_intfdata (interface, NULL);
914	goto error;	905	goto error;
915	}	906	}
916	dev->minor = interface->minor;	907	dev->minor = interface->minor;
@@ -942,23 +933,24 @@ static void tower_disconnect (struct usb_interface *interface) · 25 unmodified lines
942	int minor;	933	int minor;
943		934
944	dev = usb_get_intfdata (interface);	935	dev = usb_get_intfdata (interface);
945	mutex_lock(&open_disc_mutex);
946	usb_set_intfdata (interface, NULL);
947		936
948	minor = dev->minor;	937	minor = dev->minor;
949		938
950	/* give back our minor */	939	/* give back our minor and prevent further open() */
951	usb_deregister_dev (interface, &tower_class);	940	usb_deregister_dev (interface, &tower_class);
952		941
		942	/* stop I/O */
		943	usb_poison_urb(dev->interrupt_in_urb);
		944	usb_poison_urb(dev->interrupt_out_urb);
		945
953	mutex_lock(&dev->lock);	946	mutex_lock(&dev->lock);
954	mutex_unlock(&open_disc_mutex);
955		947
956	/* if the device is not opened, then we clean up right now */	948	/* if the device is not opened, then we clean up right now */
957	if (!dev->open_count) {	949	if (!dev->open_count) {
958	mutex_unlock(&dev->lock);	950	mutex_unlock(&dev->lock);
959	tower_delete (dev);	951	tower_delete (dev);
960	} else {	952	} else {
961	dev->udev = NULL;	953	dev->disconnected = 1;
962	/* wake up pollers */	954	/* wake up pollers */
963	wake_up_interruptible_all(&dev->read_wait);	955	wake_up_interruptible_all(&dev->read_wait);
964	wake_up_interruptible_all(&dev->write_wait);	956	wake_up_interruptible_all(&dev->write_wait);

drivers/usb/misc/rio500.c+0−554

@@ -1,554 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0+
2	/* -- linux-c -- */
3
4	/*
5	* Driver for USB Rio 500
6	*
7	* Cesar Miquel (miquel@df.uba.ar)
8	*
9	* based on hp_scanner.c by David E. Nelson (dnelson@jump.net)
10	*
11	* Based upon mouse.c (Brad Keryan) and printer.c (Michael Gee).
12	*
13	* Changelog:
14	* 30/05/2003 replaced lock/unlock kernel with up/down
15	* Daniele Bellucci bellucda@tiscali.it
16	* */
17
18	#include <linux/module.h>
19	#include <linux/kernel.h>
20	#include <linux/signal.h>
21	#include <linux/sched/signal.h>
22	#include <linux/mutex.h>
23	#include <linux/errno.h>
24	#include <linux/random.h>
25	#include <linux/poll.h>
26	#include <linux/slab.h>
27	#include <linux/spinlock.h>
28	#include <linux/usb.h>
29	#include <linux/wait.h>
30
31	#include "rio500_usb.h"
32
33	#define DRIVER_AUTHOR "Cesar Miquel <miquel@df.uba.ar>"
34	#define DRIVER_DESC "USB Rio 500 driver"
35
36	#define RIO_MINOR 64
37
38	/* stall/wait timeout for rio */
39	#define NAK_TIMEOUT (HZ)
40
41	#define IBUF_SIZE 0x1000
42
43	/* Size of the rio buffer */
44	#define OBUF_SIZE 0x10000
45
46	struct rio_usb_data {
47	struct usb_device rio_dev; / init: probe_rio */
48	unsigned int ifnum; /* Interface number of the USB device */
49	int isopen; /* nz if open */
50	int present; /* Device is present on the bus */
51	char obuf, ibuf; /* transfer buffers */
52	char bulk_in_ep, bulk_out_ep; /* Endpoint assignments */
53	wait_queue_head_t wait_q; /* for timeouts */
54	};
55
56	static DEFINE_MUTEX(rio500_mutex);
57	static struct rio_usb_data rio_instance;
58
59	static int open_rio(struct inode inode, struct file file)
60	{
61	struct rio_usb_data *rio = &rio_instance;
62
63	/* against disconnect() */
64	mutex_lock(&rio500_mutex);
65
66	if (rio->isopen \|\| !rio->present) {
67	mutex_unlock(&rio500_mutex);
68	return -EBUSY;
69	}
70	rio->isopen = 1;
71
72	init_waitqueue_head(&rio->wait_q);
73
74
75	dev_info(&rio->rio_dev->dev, "Rio opened.\n");
76	mutex_unlock(&rio500_mutex);
77
78	return 0;
79	}
80
81	static int close_rio(struct inode inode, struct file file)
82	{
83	struct rio_usb_data *rio = &rio_instance;
84
85	/* against disconnect() */
86	mutex_lock(&rio500_mutex);
87
88	rio->isopen = 0;
89	if (!rio->present) {
90	/* cleanup has been delayed */
91	kfree(rio->ibuf);
92	kfree(rio->obuf);
93	rio->ibuf = NULL;
94	rio->obuf = NULL;
95	} else {
96	dev_info(&rio->rio_dev->dev, "Rio closed.\n");
97	}
98	mutex_unlock(&rio500_mutex);
99	return 0;
100	}
101
102	static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
103	{
104	struct RioCommand rio_cmd;
105	struct rio_usb_data *rio = &rio_instance;
106	void __user *data;
107	unsigned char *buffer;
108	int result, requesttype;
109	int retries;
110	int retval=0;
111
112	mutex_lock(&rio500_mutex);
113	/* Sanity check to make sure rio is connected, powered, etc */
114	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
115	retval = -ENODEV;
116	goto err_out;
117	}
118
119	switch (cmd) {
120	case RIO_RECV_COMMAND:
121	data = (void __user *) arg;
122	if (data == NULL)
123	break;
124	if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
125	retval = -EFAULT;
126	goto err_out;
127	}
128	if (rio_cmd.length < 0 \|\| rio_cmd.length > PAGE_SIZE) {
129	retval = -EINVAL;
130	goto err_out;
131	}
132	buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
133	if (buffer == NULL) {
134	retval = -ENOMEM;
135	goto err_out;
136	}
137	if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
138	retval = -EFAULT;
139	free_page((unsigned long) buffer);
140	goto err_out;
141	}
142
143	requesttype = rio_cmd.requesttype \| USB_DIR_IN \|
144	USB_TYPE_VENDOR \| USB_RECIP_DEVICE;
145	dev_dbg(&rio->rio_dev->dev,
146	"sending command:reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
147	requesttype, rio_cmd.request, rio_cmd.value,
148	rio_cmd.index, rio_cmd.length);
149	/* Send rio control message */
150	retries = 3;
151	while (retries) {
152	result = usb_control_msg(rio->rio_dev,
153	usb_rcvctrlpipe(rio-> rio_dev, 0),
154	rio_cmd.request,
155	requesttype,
156	rio_cmd.value,
157	rio_cmd.index, buffer,
158	rio_cmd.length,
159	jiffies_to_msecs(rio_cmd.timeout));
160	if (result == -ETIMEDOUT)
161	retries--;
162	else if (result < 0) {
163	dev_err(&rio->rio_dev->dev,
164	"Error executing ioctrl. code = %d\n",
165	result);
166	retries = 0;
167	} else {
168	dev_dbg(&rio->rio_dev->dev,
169	"Executed ioctl. Result = %d (data=%02x)\n",
170	result, buffer[0]);
171	if (copy_to_user(rio_cmd.buffer, buffer,
172	rio_cmd.length)) {
173	free_page((unsigned long) buffer);
174	retval = -EFAULT;
175	goto err_out;
176	}
177	retries = 0;
178	}
179
180	/* rio_cmd.buffer contains a raw stream of single byte
181	data which has been returned from rio. Data is
182	interpreted at application level. For data that
183	will be cast to data types longer than 1 byte, data
184	will be little_endian and will potentially need to
185	be swapped at the app level */
186
187	}
188	free_page((unsigned long) buffer);
189	break;
190
191	case RIO_SEND_COMMAND:
192	data = (void __user *) arg;
193	if (data == NULL)
194	break;
195	if (copy_from_user(&rio_cmd, data, sizeof(struct RioCommand))) {
196	retval = -EFAULT;
197	goto err_out;
198	}
199	if (rio_cmd.length < 0 \|\| rio_cmd.length > PAGE_SIZE) {
200	retval = -EINVAL;
201	goto err_out;
202	}
203	buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
204	if (buffer == NULL) {
205	retval = -ENOMEM;
206	goto err_out;
207	}
208	if (copy_from_user(buffer, rio_cmd.buffer, rio_cmd.length)) {
209	free_page((unsigned long)buffer);
210	retval = -EFAULT;
211	goto err_out;
212	}
213
214	requesttype = rio_cmd.requesttype \| USB_DIR_OUT \|
215	USB_TYPE_VENDOR \| USB_RECIP_DEVICE;
216	dev_dbg(&rio->rio_dev->dev,
217	"sending command: reqtype=%0x req=%0x value=%0x index=%0x len=%0x\n",
218	requesttype, rio_cmd.request, rio_cmd.value,
219	rio_cmd.index, rio_cmd.length);
220	/* Send rio control message */
221	retries = 3;
222	while (retries) {
223	result = usb_control_msg(rio->rio_dev,
224	usb_sndctrlpipe(rio-> rio_dev, 0),
225	rio_cmd.request,
226	requesttype,
227	rio_cmd.value,
228	rio_cmd.index, buffer,
229	rio_cmd.length,
230	jiffies_to_msecs(rio_cmd.timeout));
231	if (result == -ETIMEDOUT)
232	retries--;
233	else if (result < 0) {
234	dev_err(&rio->rio_dev->dev,
235	"Error executing ioctrl. code = %d\n",
236	result);
237	retries = 0;
238	} else {
239	dev_dbg(&rio->rio_dev->dev,
240	"Executed ioctl. Result = %d\n", result);
241	retries = 0;
242
243	}
244
245	}
246	free_page((unsigned long) buffer);
247	break;
248
249	default:
250	retval = -ENOTTY;
251	break;
252	}
253
254
255	err_out:
256	mutex_unlock(&rio500_mutex);
257	return retval;
258	}
259
260	static ssize_t
261	write_rio(struct file file, const char __user buffer,
262	size_t count, loff_t * ppos)
263	{
264	DEFINE_WAIT(wait);
265	struct rio_usb_data *rio = &rio_instance;
266
267	unsigned long copy_size;
268	unsigned long bytes_written = 0;
269	unsigned int partial;
270
271	int result = 0;
272	int maxretry;
273	int errn = 0;
274	int intr;
275
276	intr = mutex_lock_interruptible(&rio500_mutex);
277	if (intr)
278	return -EINTR;
279	/* Sanity check to make sure rio is connected, powered, etc */
280	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
281	mutex_unlock(&rio500_mutex);
282	return -ENODEV;
283	}
284
285
286
287	do {
288	unsigned long thistime;
289	char *obuf = rio->obuf;
290
291	thistime = copy_size =
292	(count >= OBUF_SIZE) ? OBUF_SIZE : count;
293	if (copy_from_user(rio->obuf, buffer, copy_size)) {
294	errn = -EFAULT;
295	goto error;
296	}
297	maxretry = 5;
298	while (thistime) {
299	if (!rio->rio_dev) {
300	errn = -ENODEV;
301	goto error;
302	}
303	if (signal_pending(current)) {
304	mutex_unlock(&rio500_mutex);
305	return bytes_written ? bytes_written : -EINTR;
306	}
307
308	result = usb_bulk_msg(rio->rio_dev,
309	usb_sndbulkpipe(rio->rio_dev, 2),
310	obuf, thistime, &partial, 5000);
311
312	dev_dbg(&rio->rio_dev->dev,
313	"write stats: result:%d thistime:%lu partial:%u\n",
314	result, thistime, partial);
315
316	if (result == -ETIMEDOUT) { /* NAK - so hold for a while */
317	if (!maxretry--) {
318	errn = -ETIME;
319	goto error;
320	}
321	prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
322	schedule_timeout(NAK_TIMEOUT);
323	finish_wait(&rio->wait_q, &wait);
324	continue;
325	} else if (!result && partial) {
326	obuf += partial;
327	thistime -= partial;
328	} else
329	break;
330	}
331	if (result) {
332	dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
333	result);
334	errn = -EIO;
335	goto error;
336	}
337	bytes_written += copy_size;
338	count -= copy_size;
339	buffer += copy_size;
340	} while (count > 0);
341
342	mutex_unlock(&rio500_mutex);
343
344	return bytes_written ? bytes_written : -EIO;
345
346	error:
347	mutex_unlock(&rio500_mutex);
348	return errn;
349	}
350
351	static ssize_t
352	read_rio(struct file file, char __user buffer, size_t count, loff_t * ppos)
353	{
354	DEFINE_WAIT(wait);
355	struct rio_usb_data *rio = &rio_instance;
356	ssize_t read_count;
357	unsigned int partial;
358	int this_read;
359	int result;
360	int maxretry = 10;
361	char *ibuf;
362	int intr;
363
364	intr = mutex_lock_interruptible(&rio500_mutex);
365	if (intr)
366	return -EINTR;
367	/* Sanity check to make sure rio is connected, powered, etc */
368	if (rio->present == 0 \|\| rio->rio_dev == NULL) {
369	mutex_unlock(&rio500_mutex);
370	return -ENODEV;
371	}
372
373	ibuf = rio->ibuf;
374
375	read_count = 0;
376
377
378	while (count > 0) {
379	if (signal_pending(current)) {
380	mutex_unlock(&rio500_mutex);
381	return read_count ? read_count : -EINTR;
382	}
383	if (!rio->rio_dev) {
384	mutex_unlock(&rio500_mutex);
385	return -ENODEV;
386	}
387	this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
388
389	result = usb_bulk_msg(rio->rio_dev,
390	usb_rcvbulkpipe(rio->rio_dev, 1),
391	ibuf, this_read, &partial,
392	8000);
393
394	dev_dbg(&rio->rio_dev->dev,
395	"read stats: result:%d this_read:%u partial:%u\n",
396	result, this_read, partial);
397
398	if (partial) {
399	count = this_read = partial;
400	} else if (result == -ETIMEDOUT \|\| result == 15) { /* FIXME: 15 ??? */
401	if (!maxretry--) {
402	mutex_unlock(&rio500_mutex);
403	dev_err(&rio->rio_dev->dev,
404	"read_rio: maxretry timeout\n");
405	return -ETIME;
406	}
407	prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
408	schedule_timeout(NAK_TIMEOUT);
409	finish_wait(&rio->wait_q, &wait);
410	continue;
411	} else if (result != -EREMOTEIO) {
412	mutex_unlock(&rio500_mutex);
413	dev_err(&rio->rio_dev->dev,
414	"Read Whoops - result:%d partial:%u this_read:%u\n",
415	result, partial, this_read);
416	return -EIO;
417	} else {
418	mutex_unlock(&rio500_mutex);
419	return (0);
420	}
421
422	if (this_read) {
423	if (copy_to_user(buffer, ibuf, this_read)) {
424	mutex_unlock(&rio500_mutex);
425	return -EFAULT;
426	}
427	count -= this_read;
428	read_count += this_read;
429	buffer += this_read;
430	}
431	}
432	mutex_unlock(&rio500_mutex);
433	return read_count;
434	}
435
436	static const struct file_operations usb_rio_fops = {
437	.owner = THIS_MODULE,
438	.read = read_rio,
439	.write = write_rio,
440	.unlocked_ioctl = ioctl_rio,
441	.open = open_rio,
442	.release = close_rio,
443	.llseek = noop_llseek,
444	};
445
446	static struct usb_class_driver usb_rio_class = {
447	.name = "rio500%d",
448	.fops = &usb_rio_fops,
449	.minor_base = RIO_MINOR,
450	};
451
452	static int probe_rio(struct usb_interface *intf,
453	const struct usb_device_id *id)
454	{
455	struct usb_device *dev = interface_to_usbdev(intf);
456	struct rio_usb_data *rio = &rio_instance;
457	int retval = -ENOMEM;
458	char ibuf, obuf;
459
460	if (rio->present) {
461	dev_info(&intf->dev, "Second USB Rio at address %d refused\n", dev->devnum);
462	return -EBUSY;
463	}
464	dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);
465
466	obuf = kmalloc(OBUF_SIZE, GFP_KERNEL);
467	if (!obuf) {
468	dev_err(&dev->dev,
469	"probe_rio: Not enough memory for the output buffer\n");
470	goto err_obuf;
471	}
472	dev_dbg(&intf->dev, "obuf address: %p\n", obuf);
473
474	ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL);
475	if (!ibuf) {
476	dev_err(&dev->dev,
477	"probe_rio: Not enough memory for the input buffer\n");
478	goto err_ibuf;
479	}
480	dev_dbg(&intf->dev, "ibuf address: %p\n", ibuf);
481
482	mutex_lock(&rio500_mutex);
483	rio->rio_dev = dev;
484	rio->ibuf = ibuf;
485	rio->obuf = obuf;
486	rio->present = 1;
487	mutex_unlock(&rio500_mutex);
488
489	retval = usb_register_dev(intf, &usb_rio_class);
490	if (retval) {
491	dev_err(&dev->dev,
492	"Not able to get a minor for this device.\n");
493	goto err_register;
494	}
495
496	usb_set_intfdata(intf, rio);
497	return retval;
498
499	err_register:
500	mutex_lock(&rio500_mutex);
501	rio->present = 0;
502	mutex_unlock(&rio500_mutex);
503	err_ibuf:
504	kfree(obuf);
505	err_obuf:
506	return retval;
507	}
508
509	static void disconnect_rio(struct usb_interface *intf)
510	{
511	struct rio_usb_data *rio = usb_get_intfdata (intf);
512
513	usb_set_intfdata (intf, NULL);
514	if (rio) {
515	usb_deregister_dev(intf, &usb_rio_class);
516
517	mutex_lock(&rio500_mutex);
518	if (rio->isopen) {
519	rio->isopen = 0;
520	/* better let it finish - the release will do whats needed */
521	rio->rio_dev = NULL;
522	mutex_unlock(&rio500_mutex);
523	return;
524	}
525	kfree(rio->ibuf);
526	kfree(rio->obuf);
527
528	dev_info(&intf->dev, "USB Rio disconnected.\n");
529
530	rio->present = 0;
531	mutex_unlock(&rio500_mutex);
532	}
533	}
534
535	static const struct usb_device_id rio_table[] = {
536	{ USB_DEVICE(0x0841, 1) }, /* Rio 500 */
537	{ } /* Terminating entry */
538	};
539
540	MODULE_DEVICE_TABLE (usb, rio_table);
541
542	static struct usb_driver rio_driver = {
543	.name = "rio500",
544	.probe = probe_rio,
545	.disconnect = disconnect_rio,
546	.id_table = rio_table,
547	};
548
549	module_usb_driver(rio_driver);
550
551	MODULE_AUTHOR( DRIVER_AUTHOR );
552	MODULE_DESCRIPTION( DRIVER_DESC );
553	MODULE_LICENSE("GPL");
554

drivers/usb/misc/rio500_usb.h+0−20

@@ -1,20 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0+
2	/* ----------------------------------------------------------------------
3	Copyright (C) 2000 Cesar Miquel (miquel@df.uba.ar)
4	---------------------------------------------------------------------- */
5
6	#define RIO_SEND_COMMAND 0x1
7	#define RIO_RECV_COMMAND 0x2
8
9	#define RIO_DIR_OUT 0x0
10	#define RIO_DIR_IN 0x1
11
12	struct RioCommand {
13	short length;
14	int request;
15	int requesttype;
16	int value;
17	int index;
18	void __user *buffer;
19	int timeout;
20	};

drivers/usb/misc/usblcd.c+33−27

 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/mutex.h>
+#include <linux/rwsem.h>
 #include <linux/uaccess.h>
 #include <linux/usb.h>
 #define IOCTL_GET_DRV_VERSION	2
-static DEFINE_MUTEX(lcd_mutex);
 static const struct usb_device_id id_table[] = {
 	{ .idVendor = 0x10D2, .match_flags = USB_DEVICE_ID_MATCH_VENDOR, },
 	{ },
 };
 MODULE_DEVICE_TABLE(usb, id_table);
-static DEFINE_MUTEX(open_disc_mutex);
 struct usb_lcd {
 	struct usb_device	*udev;			/* init: probe_lcd */
 	struct usb_interface	*interface;		/* the interface for
 							   using up all RAM */
 	struct usb_anchor	submitted;		/* URBs to wait for
 							   before suspend */
+	struct rw_semaphore	io_rwsem;
+	unsigned long		disconnected:1;
 };
 #define to_lcd_dev(d) container_of(d, struct usb_lcd, kref)
 	struct usb_interface *interface;
 	int subminor, r;
-	mutex_lock(&lcd_mutex);
 	subminor = iminor(inode);
 	interface = usb_find_interface(&lcd_driver, subminor);
 	if (!interface) {
-		mutex_unlock(&lcd_mutex);
+		pr_err("USBLCD: %s - error, can't find device for minor %d\n",
-		printk(KERN_ERR "USBLCD: %s - error, can't find device for minor %d\n",
 		       __func__, subminor);
 		return -ENODEV;
 	}
-	mutex_lock(&open_disc_mutex);
 	dev = usb_get_intfdata(interface);
-	if (!dev) {
-		mutex_unlock(&open_disc_mutex);
-		mutex_unlock(&lcd_mutex);
-		return -ENODEV;
-	}
 	/* increment our usage count for the device */
 	kref_get(&dev->kref);
-	mutex_unlock(&open_disc_mutex);
 	/* grab a power reference */
 	r = usb_autopm_get_interface(interface);
 	if (r < 0) {
 		kref_put(&dev->kref, lcd_delete);
-		mutex_unlock(&lcd_mutex);
 		return r;
 	}
 	/* save our object in the file's private structure */
 	file->private_data = dev;
-	mutex_unlock(&lcd_mutex);
 	return 0;
 }
 	dev = file->private_data;
+	down_read(&dev->io_rwsem);
+	if (dev->disconnected) {
+		retval = -ENODEV;
+		goto out_up_io;
+	}
 	/* do a blocking bulk read to get data from the device */
 	retval = usb_bulk_msg(dev->udev,
 			      usb_rcvbulkpipe(dev->udev,
 			retval = bytes_read;
 	}
+out_up_io:
+	up_read(&dev->io_rwsem);
 	return retval;
 }
 	switch (cmd) {
 	case IOCTL_GET_HARD_VERSION:
-		mutex_lock(&lcd_mutex);
 		bcdDevice = le16_to_cpu((dev->udev)->descriptor.bcdDevice);
 		sprintf(buf, "%1d%1d.%1d%1d",
 			(bcdDevice & 0xF000)>>12,
 			(bcdDevice & 0xF00)>>8,
 			(bcdDevice & 0xF0)>>4,
 			(bcdDevice & 0xF));
-		mutex_unlock(&lcd_mutex);
 		if (copy_to_user((void __user *)arg, buf, strlen(buf)) != 0)
 			return -EFAULT;
 		break;
 	if (r < 0)
 		return -EINTR;
+	down_read(&dev->io_rwsem);
+	if (dev->disconnected) {
+		retval = -ENODEV;
+		goto err_up_io;
+	}
 	/* create a urb, and a buffer for it, and copy the data to the urb */
 	urb = usb_alloc_urb(0, GFP_KERNEL);
 	if (!urb) {
 		retval = -ENOMEM;
-		goto err_no_buf;
+		goto err_up_io;
 	}
 	buf = usb_alloc_coherent(dev->udev, count, GFP_KERNEL,
 	   the USB core will eventually free it entirely */
 	usb_free_urb(urb);
+	up_read(&dev->io_rwsem);
 exit:
 	return count;
 error_unanchor:
 error:
 	usb_free_coherent(dev->udev, count, buf, urb->transfer_dma);
 	usb_free_urb(urb);
-err_no_buf:
+err_up_io:
+	up_read(&dev->io_rwsem);
 	up(&dev->limit_sem);
 	return retval;
 }
 	kref_init(&dev->kref);
 	sema_init(&dev->limit_sem, USB_LCD_CONCURRENT_WRITES);
+	init_rwsem(&dev->io_rwsem);
 	init_usb_anchor(&dev->submitted);
 	dev->udev = usb_get_dev(interface_to_usbdev(interface));
 		/* something prevented us from registering this driver */
 		dev_err(&interface->dev,
 			"Not able to get a minor for this device.\n");
-		usb_set_intfdata(interface, NULL);
 		goto error;
 	}
 static void lcd_disconnect(struct usb_interface *interface)
 {
-	struct usb_lcd *dev;
+	struct usb_lcd *dev = usb_get_intfdata(interface);
 	int minor = interface->minor;
-	mutex_lock(&open_disc_mutex);
-	dev = usb_get_intfdata(interface);
-	usb_set_intfdata(interface, NULL);
-	mutex_unlock(&open_disc_mutex);
 	/* give back our minor */
 	usb_deregister_dev(interface, &lcd_class);
+	down_write(&dev->io_rwsem);
+	dev->disconnected = 1;
+	up_write(&dev->io_rwsem);
+	usb_kill_anchored_urbs(&dev->submitted);
 	/* decrement our usage count */
 	kref_put(&dev->kref, lcd_delete);

drivers/usb/misc/yurex.c+11−7

 	struct kref		kref;
 	struct mutex		io_mutex;
+	unsigned long		disconnected:1;
 	struct fasync_struct	*async_queue;
 	wait_queue_head_t	waitq;
 				dev->int_buffer, dev->urb->transfer_dma);
 		usb_free_urb(dev->urb);
 	}
+	usb_put_intf(dev->interface);
 	usb_put_dev(dev->udev);
 	kfree(dev);
 }
 	switch (status) {
 	case 0: /*success*/
 		break;
+	/* The device is terminated or messed up, give up */
 	case -EOVERFLOW:
 		dev_err(&dev->interface->dev,
 			"%s - overflow with length %d, actual length is %d\n",
 	case -ENOENT:
 	case -ESHUTDOWN:
 	case -EILSEQ:
-		/* The device is terminated, clean up */
+	case -EPROTO:
+	case -ETIME:
 		return;
 	default:
 		dev_err(&dev->interface->dev,
 			"%s - unknown status received: %d\n", __func__, status);
-		goto exit;
+		return;
 	}
 	/* handle received message */
 		break;
 	}
-exit:
 	retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 	if (retval) {
 		dev_err(&dev->interface->dev, "%s - usb_submit_urb failed: %d\n",
 	init_waitqueue_head(&dev->waitq);
 	dev->udev = usb_get_dev(interface_to_usbdev(interface));
-	dev->interface = interface;
+	dev->interface = usb_get_intf(interface);
 	/* set up the endpoint information */
 	iface_desc = interface->cur_altsetting;
 	/* prevent more I/O from starting */
 	usb_poison_urb(dev->urb);
+	usb_poison_urb(dev->cntl_urb);
 	mutex_lock(&dev->io_mutex);
-	dev->interface = NULL;
+	dev->disconnected = 1;
 	mutex_unlock(&dev->io_mutex);
 	/* wakeup waiters */
 	dev = file->private_data;
 	mutex_lock(&dev->io_mutex);
-	if (!dev->interface) {		/* already disconnected */
+	if (dev->disconnected) {		/* already disconnected */
 		mutex_unlock(&dev->io_mutex);
 		return -ENODEV;
 	}
 		goto error;
 	mutex_lock(&dev->io_mutex);
-	if (!dev->interface) {		/* already disconnected */
+	if (dev->disconnected) {		/* already disconnected */
 		mutex_unlock(&dev->io_mutex);
 		retval = -ENODEV;
 		goto error;

drivers/usb/renesas_usbhs/common.h+1−0

@@ -211,6 +211,7 @@ struct usbhs_priv; · 210 unmodified lines
211	/* DCPCTR */	211	/* DCPCTR */
212	#define BSTS (1 << 15) /* Buffer Status */	212	#define BSTS (1 << 15) /* Buffer Status */
213	#define SUREQ (1 << 14) /* Sending SETUP Token */	213	#define SUREQ (1 << 14) /* Sending SETUP Token */
		214	#define INBUFM (1 << 14) /* (PIPEnCTR) Transfer Buffer Monitor */
214	#define CSSTS (1 << 12) /* CSSTS Status */	215	#define CSSTS (1 << 12) /* CSSTS Status */
215	#define ACLRM (1 << 9) /* Buffer Auto-Clear Mode */	216	#define ACLRM (1 << 9) /* Buffer Auto-Clear Mode */
216	#define SQCLR (1 << 8) /* Toggle Bit Clear */	217	#define SQCLR (1 << 8) /* Toggle Bit Clear */

drivers/usb/renesas_usbhs/fifo.c+1−1

@@ -89,7 +89,7 @@ static void __usbhsf_pkt_del(struct usbhs_pkt *pkt) · 88 unmodified lines
89	list_del_init(&pkt->node);	89	list_del_init(&pkt->node);
90	}	90	}
91		91
92	static struct usbhs_pkt __usbhsf_pkt_get(struct usbhs_pipe pipe)	92	struct usbhs_pkt __usbhsf_pkt_get(struct usbhs_pipe pipe)
93	{	93	{
94	return list_first_entry_or_null(&pipe->list, struct usbhs_pkt, node);	94	return list_first_entry_or_null(&pipe->list, struct usbhs_pkt, node);
95	}	95	}

drivers/usb/renesas_usbhs/fifo.h+1−0

@@ -97,5 +97,6 @@ void usbhs_pkt_push(struct usbhs_pipe pipe, struct usbhs_pkt pkt, · 96 unmodified lines
97	void *buf, int len, int zero, int sequence);	97	void *buf, int len, int zero, int sequence);
98	struct usbhs_pkt usbhs_pkt_pop(struct usbhs_pipe pipe, struct usbhs_pkt *pkt);	98	struct usbhs_pkt usbhs_pkt_pop(struct usbhs_pipe pipe, struct usbhs_pkt *pkt);
99	void usbhs_pkt_start(struct usbhs_pipe *pipe);	99	void usbhs_pkt_start(struct usbhs_pipe *pipe);
		100	struct usbhs_pkt __usbhsf_pkt_get(struct usbhs_pipe pipe);
100		101
101	#endif /* RENESAS_USB_FIFO_H */	102	#endif /* RENESAS_USB_FIFO_H */

drivers/usb/renesas_usbhs/mod_gadget.c+15−3

@@ -722,8 +722,7 @@ static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge) · 721 unmodified lines
722	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);	722	struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv);
723	struct device *dev = usbhsg_gpriv_to_dev(gpriv);	723	struct device *dev = usbhsg_gpriv_to_dev(gpriv);
724	unsigned long flags;	724	unsigned long flags;
725		725	int ret = 0;
726	usbhsg_pipe_disable(uep);
727		726
728	dev_dbg(dev, "set halt %d (pipe %d)\n",	727	dev_dbg(dev, "set halt %d (pipe %d)\n",
729	halt, usbhs_pipe_number(pipe));	728	halt, usbhs_pipe_number(pipe));
@@ -731,6 +730,18 @@ static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge) · 1 unmodified line
731	/****************** spin lock ******************/	730	/****************** spin lock ******************/
732	usbhs_lock(priv, flags);	731	usbhs_lock(priv, flags);
733		732
		733	/*
		734	* According to usb_ep_set_halt()'s description, this function should
		735	* return -EAGAIN if the IN endpoint has any queue or data. Note
		736	* that the usbhs_pipe_is_dir_in() returns false if the pipe is an
		737	* IN endpoint in the gadget mode.
		738	*/
		739	if (!usbhs_pipe_is_dir_in(pipe) && (__usbhsf_pkt_get(pipe) \|\|
		740	usbhs_pipe_contains_transmittable_data(pipe))) {
		741	ret = -EAGAIN;
		742	goto out;
		743	}
		744
734	if (halt)	745	if (halt)
735	usbhs_pipe_stall(pipe);	746	usbhs_pipe_stall(pipe);
736	else	747	else
@@ -741,10 +752,11 @@ static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge) · 4 unmodified lines
741	else	752	else
742	usbhsg_status_clr(gpriv, USBHSG_STATUS_WEDGE);	753	usbhsg_status_clr(gpriv, USBHSG_STATUS_WEDGE);
743		754
		755	out:
744	usbhs_unlock(priv, flags);	756	usbhs_unlock(priv, flags);
745	/****************** spin unlock ****************/	757	/****************** spin unlock ****************/
746		758
747	return 0;	759	return ret;
748	}	760	}
749		761
750	static int usbhsg_ep_set_halt(struct usb_ep *ep, int value)	762	static int usbhsg_ep_set_halt(struct usb_ep *ep, int value)

drivers/usb/renesas_usbhs/pipe.c+15−0

@@ -277,6 +277,21 @@ int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe) · 276 unmodified lines
277	return -EBUSY;	277	return -EBUSY;
278	}	278	}
279		279
		280	bool usbhs_pipe_contains_transmittable_data(struct usbhs_pipe *pipe)
		281	{
		282	u16 val;
		283
		284	/* Do not support for DCP pipe */
		285	if (usbhs_pipe_is_dcp(pipe))
		286	return false;
		287
		288	val = usbhsp_pipectrl_get(pipe);
		289	if (val & INBUFM)
		290	return true;
		291
		292	return false;
		293	}
		294
280	/*	295	/*
281	* PID ctrl	296	* PID ctrl
282	*/	297	*/

drivers/usb/renesas_usbhs/pipe.h+1−0

@@ -83,6 +83,7 @@ void usbhs_pipe_clear(struct usbhs_pipe *pipe); · 82 unmodified lines
83	void usbhs_pipe_clear_without_sequence(struct usbhs_pipe *pipe,	83	void usbhs_pipe_clear_without_sequence(struct usbhs_pipe *pipe,
84	int needs_bfre, int bfre_enable);	84	int needs_bfre, int bfre_enable);
85	int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe);	85	int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe);
		86	bool usbhs_pipe_contains_transmittable_data(struct usbhs_pipe *pipe);
86	void usbhs_pipe_enable(struct usbhs_pipe *pipe);	87	void usbhs_pipe_enable(struct usbhs_pipe *pipe);
87	void usbhs_pipe_disable(struct usbhs_pipe *pipe);	88	void usbhs_pipe_disable(struct usbhs_pipe *pipe);
88	void usbhs_pipe_stall(struct usbhs_pipe *pipe);	89	void usbhs_pipe_stall(struct usbhs_pipe *pipe);

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

 	/* EZPrototypes devices */
 	{ USB_DEVICE(EZPROTOTYPES_VID, HJELMSLUND_USB485_ISO_PID) },
 	{ USB_DEVICE_INTERFACE_NUMBER(UNJO_VID, UNJO_ISODEBUG_V1_PID, 1) },
+	/* Sienna devices */
+	{ USB_DEVICE(FTDI_VID, FTDI_SIENNA_PID) },
+	{ USB_DEVICE(ECHELON_VID, ECHELON_U20_PID) },
 	{ }					/* Terminating entry */
 };

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

 #define FTDI_LUMEL_PD12_PID	0x6002
+/* Sienna Serial Interface by Secyourit GmbH */
+#define FTDI_SIENNA_PID		0x8348
 /* Cyber Cortex AV by Fabulous Silicon (http://fabuloussilicon.com) */
 #define CYBER_CORTEX_AV_PID	0x8698
 #define BANDB_TTL3USB9M_PID	0xAC50
 #define BANDB_ZZ_PROG1_USB_PID	0xBA02
+/*
+ * Echelon USB Serial Interface
+ */
+#define ECHELON_VID		0x0920
+#define ECHELON_U20_PID		0x7500
 /*
  * Intrepid Control Systems (http://www.intrepidcs.com/) ValueCAN and NeoVI
  */

drivers/usb/serial/keyspan.c+2−2

@@ -1741,8 +1741,8 @@ static struct urb keyspan_setup_urb(struct usb_serial serial, int endpoint, · 1740 unmodified lines
1741		1741
1742	ep_desc = find_ep(serial, endpoint);	1742	ep_desc = find_ep(serial, endpoint);
1743	if (!ep_desc) {	1743	if (!ep_desc) {
1744	/* leak the urb, something's wrong and the callers don't care */	1744	usb_free_urb(urb);
1745	return urb;	1745	return NULL;
1746	}	1746	}
1747	if (usb_endpoint_xfer_int(ep_desc)) {	1747	if (usb_endpoint_xfer_int(ep_desc)) {
1748	ep_type_name = "INT";	1748	ep_type_name = "INT";

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

 #define CINTERION_PRODUCT_PH8_AUDIO		0x0083
 #define CINTERION_PRODUCT_AHXX_2RMNET		0x0084
 #define CINTERION_PRODUCT_AHXX_AUDIO		0x0085
+#define CINTERION_PRODUCT_CLS8			0x00b0
 /* Olivetti products */
 #define OLIVETTI_VENDOR_ID			0x0b3c
 	  .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) | RSVD(3) },
 	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, TELIT_PRODUCT_LE922_USBCFG5, 0xff),
 	  .driver_info = RSVD(0) | RSVD(1) | NCTRL(2) | RSVD(3) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1050, 0xff),	/* Telit FN980 (rmnet) */
+	  .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1051, 0xff),	/* Telit FN980 (MBIM) */
+	  .driver_info = NCTRL(0) | RSVD(1) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1052, 0xff),	/* Telit FN980 (RNDIS) */
+	  .driver_info = NCTRL(2) | RSVD(3) },
+	{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1053, 0xff),	/* Telit FN980 (ECM) */
+	  .driver_info = NCTRL(0) | RSVD(1) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_ME910),
 	  .driver_info = NCTRL(0) | RSVD(1) | RSVD(3) },
 	{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_ME910_DUAL_MODEM),
 	  .driver_info = RSVD(4) },
 	{ USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX_2RMNET, 0xff) },
 	{ USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX_AUDIO, 0xff) },
+	{ USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_CLS8, 0xff),
+	  .driver_info = RSVD(0) | RSVD(4) },
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) },
 	{ USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDMNET) },
 	{ USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC25_MDM) },

drivers/usb/serial/usb-serial.c+1−4

 	serial = port->serial;
 	owner = serial->type->driver.owner;
-	mutex_lock(&serial->disc_mutex);
+	usb_autopm_put_interface(serial->interface);
-	if (!serial->disconnected)
-		usb_autopm_put_interface(serial->interface);
-	mutex_unlock(&serial->disc_mutex);
 	usb_serial_put(serial);
 	module_put(owner);

drivers/usb/typec/tcpm/tcpm.c+8−6

 	/* USB data support is optional */
 	ret = fwnode_property_read_string(fwnode, "data-role", &cap_str);
 	if (ret == 0) {
-		port->typec_caps.data = typec_find_port_data_role(cap_str);
+		ret = typec_find_port_data_role(cap_str);
-		if (port->typec_caps.data < 0)
+		if (ret < 0)
-			return -EINVAL;
+			return ret;
+		port->typec_caps.data = ret;
 	}
 	ret = fwnode_property_read_string(fwnode, "power-role", &cap_str);
 	if (ret < 0)
 		return ret;
-	port->typec_caps.type = typec_find_port_power_role(cap_str);
+	ret = typec_find_port_power_role(cap_str);
-	if (port->typec_caps.type < 0)
+	if (ret < 0)
-		return -EINVAL;
+		return ret;
+	port->typec_caps.type = ret;
 	port->port_type = port->typec_caps.type;
 	if (port->port_type == TYPEC_PORT_SNK)

drivers/usb/typec/ucsi/displayport.c+2−0

@@ -75,6 +75,8 @@ static int ucsi_displayport_enter(struct typec_altmode *alt) · 74 unmodified lines
75		75
76	if (cur != 0xff) {	76	if (cur != 0xff) {
77	mutex_unlock(&dp->con->lock);	77	mutex_unlock(&dp->con->lock);
		78	if (dp->con->port_altmode[cur] == alt)
		79	return 0;
78	return -EBUSY;	80	return -EBUSY;
79	}	81	}
80		82

drivers/usb/typec/ucsi/ucsi_ccg.c+4−38

 	/* fw build with vendor information */
 	u16 fw_build;
-	bool run_isr; /* flag to call ISR routine during resume */
 	struct work_struct pm_work;
 };
 	if (quirks && quirks->max_read_len)
 		max_read_len = quirks->max_read_len;
-	if (uc->fw_build == CCG_FW_BUILD_NVIDIA &&
-	    uc->fw_version <= CCG_OLD_FW_VERSION) {
-		mutex_lock(&uc->lock);
-		/*
-		 * Do not schedule pm_work to run ISR in
-		 * ucsi_ccg_runtime_resume() after pm_runtime_get_sync()
-		 * since we are already in ISR path.
-		 */
-		uc->run_isr = false;
-		mutex_unlock(&uc->lock);
-	}
 	pm_runtime_get_sync(uc->dev);
 	while (rem_len > 0) {
 		msgs[1].buf = &data[len - rem_len];
 	msgs[0].len = len + sizeof(rab);
 	msgs[0].buf = buf;
-	if (uc->fw_build == CCG_FW_BUILD_NVIDIA &&
-	    uc->fw_version <= CCG_OLD_FW_VERSION) {
-		mutex_lock(&uc->lock);
-		/*
-		 * Do not schedule pm_work to run ISR in
-		 * ucsi_ccg_runtime_resume() after pm_runtime_get_sync()
-		 * since we are already in ISR path.
-		 */
-		uc->run_isr = false;
-		mutex_unlock(&uc->lock);
-	}
 	pm_runtime_get_sync(uc->dev);
 	status = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 	if (status < 0) {
 	uc->ppm.sync = ucsi_ccg_sync;
 	uc->dev = dev;
 	uc->client = client;
-	uc->run_isr = true;
 	mutex_init(&uc->lock);
 	INIT_WORK(&uc->work, ccg_update_firmware);
 	INIT_WORK(&uc->pm_work, ccg_pm_workaround_work);
 	pm_runtime_set_active(uc->dev);
 	pm_runtime_enable(uc->dev);
+	pm_runtime_use_autosuspend(uc->dev);
+	pm_runtime_set_autosuspend_delay(uc->dev, 5000);
 	pm_runtime_idle(uc->dev);
 	return 0;
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct ucsi_ccg *uc = i2c_get_clientdata(client);
-	bool schedule = true;
 	/*
 	 * Firmware version 3.1.10 or earlier, built for NVIDIA has known issue
 	 * Schedule a work to call ISR as a workaround.
 	 */
 	if (uc->fw_build == CCG_FW_BUILD_NVIDIA &&
-	    uc->fw_version <= CCG_OLD_FW_VERSION) {
+	    uc->fw_version <= CCG_OLD_FW_VERSION)
-		mutex_lock(&uc->lock);
+		schedule_work(&uc->pm_work);
-		if (!uc->run_isr) {
-			uc->run_isr = true;
-			schedule = false;
-		}
-		mutex_unlock(&uc->lock);
-		if (schedule)
-			schedule_work(&uc->pm_work);
-	}
 	return 0;
 }

drivers/usb/usb-skeleton.c+9−10

 	spinlock_t		err_lock;		/* lock for errors */
 	struct kref		kref;
 	struct mutex		io_mutex;		/* synchronize I/O with disconnect */
+	unsigned long		disconnected:1;
 	wait_queue_head_t	bulk_in_wait;		/* to wait for an ongoing read */
 };
 #define to_skel_dev(d) container_of(d, struct usb_skel, kref)
 	struct usb_skel *dev = to_skel_dev(kref);
 	usb_free_urb(dev->bulk_in_urb);
+	usb_put_intf(dev->interface);
 	usb_put_dev(dev->udev);
 	kfree(dev->bulk_in_buffer);
 	kfree(dev);
 		return -ENODEV;
 	/* allow the device to be autosuspended */
-	mutex_lock(&dev->io_mutex);
+	usb_autopm_put_interface(dev->interface);
-	if (dev->interface)
-		usb_autopm_put_interface(dev->interface);
-	mutex_unlock(&dev->io_mutex);
 	/* decrement the count on our device */
 	kref_put(&dev->kref, skel_delete);
 	dev = file->private_data;
-	/* if we cannot read at all, return EOF */
+	if (!count)
-	if (!dev->bulk_in_urb || !count)
 		return 0;
 	/* no concurrent readers */
 	if (rv < 0)
 		return rv;
-	if (!dev->interface) {		/* disconnect() was called */
+	if (dev->disconnected) {		/* disconnect() was called */
 		rv = -ENODEV;
 		goto exit;
 	}
 	/* this lock makes sure we don't submit URBs to gone devices */
 	mutex_lock(&dev->io_mutex);
-	if (!dev->interface) {		/* disconnect() was called */
+	if (dev->disconnected) {		/* disconnect() was called */
 		mutex_unlock(&dev->io_mutex);
 		retval = -ENODEV;
 		goto error;
 	init_waitqueue_head(&dev->bulk_in_wait);
 	dev->udev = usb_get_dev(interface_to_usbdev(interface));
-	dev->interface = interface;
+	dev->interface = usb_get_intf(interface);
 	/* set up the endpoint information */
 	/* use only the first bulk-in and bulk-out endpoints */
 	/* prevent more I/O from starting */
 	mutex_lock(&dev->io_mutex);
-	dev->interface = NULL;
+	dev->disconnected = 1;
 	mutex_unlock(&dev->io_mutex);
+	usb_kill_urb(dev->bulk_in_urb);
 	usb_kill_anchored_urbs(&dev->submitted);
 	/* decrement our usage count */

drivers/usb/usbip/vhci_hcd.c+2−2

@@ -1195,12 +1195,12 @@ static int vhci_start(struct usb_hcd *hcd) · 1194 unmodified lines
1195	if (id == 0 && usb_hcd_is_primary_hcd(hcd)) {	1195	if (id == 0 && usb_hcd_is_primary_hcd(hcd)) {
1196	err = vhci_init_attr_group();	1196	err = vhci_init_attr_group();
1197	if (err) {	1197	if (err) {
1198	pr_err("init attr group\n");	1198	dev_err(hcd_dev(hcd), "init attr group failed, err = %d\n", err);
1199	return err;	1199	return err;
1200	}	1200	}
1201	err = sysfs_create_group(&hcd_dev(hcd)->kobj, &vhci_attr_group);	1201	err = sysfs_create_group(&hcd_dev(hcd)->kobj, &vhci_attr_group);
1202	if (err) {	1202	if (err) {
1203	pr_err("create sysfs files\n");	1203	dev_err(hcd_dev(hcd), "create sysfs files failed, err = %d\n", err);
1204	vhci_finish_attr_group();	1204	vhci_finish_attr_group();
1205	return err;	1205	return err;
1206	}	1206	}

drivers/vhost/test.c+2−0

 	vhost_test_stop(n, &private);
 	vhost_test_flush(n);
+	vhost_dev_stop(&n->dev);
 	vhost_dev_cleanup(&n->dev);
 	/* We do an extra flush before freeing memory,
 	 * since jobs can re-queue themselves. */
 	}
 	vhost_test_stop(n, &priv);
 	vhost_test_flush(n);
+	vhost_dev_stop(&n->dev);
 	vhost_dev_reset_owner(&n->dev, umem);
 done:
 	mutex_unlock(&n->dev.mutex);

drivers/virt/vboxguest/vboxguest_utils.c+2−1

 	if (!bounce_buf)
 		return -ENOMEM;
+	*bounce_buf_ret = bounce_buf;
 	if (copy_in) {
 		ret = copy_from_user(bounce_buf, (void __user *)buf, len);
 		if (ret)
 		memset(bounce_buf, 0, len);
 	}
-	*bounce_buf_ret = bounce_buf;
 	hgcm_call_add_pagelist_size(bounce_buf, len, extra);
 	return 0;
 }

drivers/w1/slaves/Kconfig+1−0

@@ -103,6 +103,7 @@ config W1_SLAVE_DS2438 · 102 unmodified lines
103		103
104	config W1_SLAVE_DS250X	104	config W1_SLAVE_DS250X
105	tristate "512b/1kb/16kb EPROM family support"	105	tristate "512b/1kb/16kb EPROM family support"
		106	select CRC16
106	help	107	help
107	Say Y here if you want to use a 1-wire	108	Say Y here if you want to use a 1-wire
108	512b/1kb/16kb EPROM family device (DS250x).	109	512b/1kb/16kb EPROM family device (DS250x).

drivers/xen/gntdev.c+2−11

@@ -22,6 +22,7 @@ · 21 unmodified lines
22		22
23	#define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt	23	#define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt
24		24
		25	#include <linux/dma-mapping.h>
25	#include <linux/module.h>	26	#include <linux/module.h>
26	#include <linux/kernel.h>	27	#include <linux/kernel.h>
27	#include <linux/init.h>	28	#include <linux/init.h>
@@ -34,9 +35,6 @@ · 6 unmodified lines
34	#include <linux/slab.h>	35	#include <linux/slab.h>
35	#include <linux/highmem.h>	36	#include <linux/highmem.h>
36	#include <linux/refcount.h>	37	#include <linux/refcount.h>
37	#ifdef CONFIG_XEN_GRANT_DMA_ALLOC
38	#include <linux/of_device.h>
39	#endif
40		38
41	#include <xen/xen.h>	39	#include <xen/xen.h>
42	#include <xen/grant_table.h>	40	#include <xen/grant_table.h>
@@ -625,14 +623,7 @@ static int gntdev_open(struct inode inode, struct file flip) · 582 unmodified lines
625	flip->private_data = priv;	623	flip->private_data = priv;
626	#ifdef CONFIG_XEN_GRANT_DMA_ALLOC	624	#ifdef CONFIG_XEN_GRANT_DMA_ALLOC
627	priv->dma_dev = gntdev_miscdev.this_device;	625	priv->dma_dev = gntdev_miscdev.this_device;
628		626	dma_coerce_mask_and_coherent(priv->dma_dev, DMA_BIT_MASK(64));
629	/*
630	* The device is not spawn from a device tree, so arch_setup_dma_ops
631	* is not called, thus leaving the device with dummy DMA ops.
632	* Fix this by calling of_dma_configure() with a NULL node to set
633	* default DMA ops.
634	*/
635	of_dma_configure(priv->dma_dev, NULL, true);
636	#endif	627	#endif
637	pr_debug("priv %p\n", priv);	628	pr_debug("priv %p\n", priv);
638		629

drivers/xen/grant-table.c+1−2

 	if (xen_feature(XENFEAT_auto_translated_physmap) && gnttab_shared.addr == NULL) {
 		gnttab_shared.addr = xen_auto_xlat_grant_frames.vaddr;
 		if (gnttab_shared.addr == NULL) {
-			pr_warn("gnttab share frames (addr=0x%08lx) is not mapped!\n",
+			pr_warn("gnttab share frames is not mapped!\n");
-				(unsigned long)xen_auto_xlat_grant_frames.vaddr);
 			return -ENOMEM;
 		}
 	}

drivers/xen/pvcalls-back.c+1−1

@@ -775,7 +775,7 @@ static int pvcalls_back_poll(struct xenbus_device *dev, · 774 unmodified lines
775	mappass->reqcopy = *req;	775	mappass->reqcopy = *req;
776	icsk = inet_csk(mappass->sock->sk);	776	icsk = inet_csk(mappass->sock->sk);
777	queue = &icsk->icsk_accept_queue;	777	queue = &icsk->icsk_accept_queue;
778	data = queue->rskq_accept_head != NULL;	778	data = READ_ONCE(queue->rskq_accept_head) != NULL;
779	if (data) {	779	if (data) {
780	mappass->reqcopy.cmd = 0;	780	mappass->reqcopy.cmd = 0;
781	ret = 0;	781	ret = 0;

fs/btrfs/file.c+12−1

 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
 	struct btrfs_root *root = BTRFS_I(inode)->root;
 	struct page **pages = NULL;
-	struct extent_state *cached_state = NULL;
 	struct extent_changeset *data_reserved = NULL;
 	u64 release_bytes = 0;
 	u64 lockstart;
 		return -ENOMEM;
 	while (iov_iter_count(i) > 0) {
+		struct extent_state *cached_state = NULL;
 		size_t offset = offset_in_page(pos);
 		size_t sector_offset;
 		size_t write_bytes = min(iov_iter_count(i),
 		if (copied > 0)
 			ret = btrfs_dirty_pages(inode, pages, dirty_pages,
 						pos, copied, &cached_state);
+		/*
+		 * If we have not locked the extent range, because the range's
+		 * start offset is >= i_size, we might still have a non-NULL
+		 * cached extent state, acquired while marking the extent range
+		 * as delalloc through btrfs_dirty_pages(). Therefore free any
+		 * possible cached extent state to avoid a memory leak.
+		 */
 		if (extents_locked)
 			unlock_extent_cached(&BTRFS_I(inode)->io_tree,
 					     lockstart, lockend, &cached_state);
+		else
+			free_extent_state(cached_state);
 		btrfs_delalloc_release_extents(BTRFS_I(inode), reserve_bytes,
 					       true);
 		if (ret) {

fs/btrfs/inode.c+3−0

 	u32 sizes[2];
 	int nitems = name ? 2 : 1;
 	unsigned long ptr;
+	unsigned int nofs_flag;
 	int ret;
 	path = btrfs_alloc_path();
 	if (!path)
 		return ERR_PTR(-ENOMEM);
+	nofs_flag = memalloc_nofs_save();
 	inode = new_inode(fs_info->sb);
+	memalloc_nofs_restore(nofs_flag);
 	if (!inode) {
 		btrfs_free_path(path);
 		return ERR_PTR(-ENOMEM);

fs/btrfs/ref-verify.c+1−1

@@ -500,7 +500,7 @@ static int process_leaf(struct btrfs_root *root, · 499 unmodified lines
500	struct btrfs_extent_data_ref *dref;	500	struct btrfs_extent_data_ref *dref;
501	struct btrfs_shared_data_ref *sref;	501	struct btrfs_shared_data_ref *sref;
502	u32 count;	502	u32 count;
503	int i = 0, tree_block_level = 0, ret;	503	int i = 0, tree_block_level = 0, ret = 0;
504	struct btrfs_key key;	504	struct btrfs_key key;
505	int nritems = btrfs_header_nritems(leaf);	505	int nritems = btrfs_header_nritems(leaf);
506		506

fs/btrfs/send.c+1−1

@@ -5085,7 +5085,7 @@ static int clone_range(struct send_ctx *sctx, · 5084 unmodified lines
5085	struct btrfs_path *path;	5085	struct btrfs_path *path;
5086	struct btrfs_key key;	5086	struct btrfs_key key;
5087	int ret;	5087	int ret;
5088	u64 clone_src_i_size;	5088	u64 clone_src_i_size = 0;
5089		5089
5090	/*	5090	/*
5091	* Prevent cloning from a zero offset with a length matching the sector	5091	* Prevent cloning from a zero offset with a length matching the sector

fs/btrfs/tree-log.c+27−9

  * in the tree of log roots
  */
 static int update_log_root(struct btrfs_trans_handle *trans,
-			   struct btrfs_root *log)
+			   struct btrfs_root *log,
+			   struct btrfs_root_item *root_item)
 {
 	struct btrfs_fs_info *fs_info = log->fs_info;
 	int ret;
 	if (log->log_transid == 1) {
 		/* insert root item on the first sync */
 		ret = btrfs_insert_root(trans, fs_info->log_root_tree,
-				&log->root_key, &log->root_item);
+				&log->root_key, root_item);
 	} else {
 		ret = btrfs_update_root(trans, fs_info->log_root_tree,
-				&log->root_key, &log->root_item);
+				&log->root_key, root_item);
 	}
 	return ret;
 }
 	struct btrfs_fs_info *fs_info = root->fs_info;
 	struct btrfs_root *log = root->log_root;
 	struct btrfs_root *log_root_tree = fs_info->log_root_tree;
+	struct btrfs_root_item new_root_item;
 	int log_transid = 0;
 	struct btrfs_log_ctx root_log_ctx;
 	struct blk_plug plug;
 		goto out;
 	}
+	/*
+	 * We _must_ update under the root->log_mutex in order to make sure we
+	 * have a consistent view of the log root we are trying to commit at
+	 * this moment.
+	 *
+	 * We _must_ copy this into a local copy, because we are not holding the
+	 * log_root_tree->log_mutex yet.  This is important because when we
+	 * commit the log_root_tree we must have a consistent view of the
+	 * log_root_tree when we update the super block to point at the
+	 * log_root_tree bytenr.  If we update the log_root_tree here we'll race
+	 * with the commit and possibly point at the new block which we may not
+	 * have written out.
+	 */
 	btrfs_set_root_node(&log->root_item, log->node);
+	memcpy(&new_root_item, &log->root_item, sizeof(new_root_item));
 	root->log_transid++;
 	log->log_transid = root->log_transid;
 	root->log_start_pid = 0;
-	/*
-	 * Update or create log root item under the root's log_mutex to prevent
-	 * races with concurrent log syncs that can lead to failure to update
-	 * log root item because it was not created yet.
-	 */
-	ret = update_log_root(trans, log);
 	/*
 	 * IO has been started, blocks of the log tree have WRITTEN flag set
 	 * in their headers. new modifications of the log will be written to
 	mutex_unlock(&log_root_tree->log_mutex);
 	mutex_lock(&log_root_tree->log_mutex);
+	/*
+	 * Now we are safe to update the log_root_tree because we're under the
+	 * log_mutex, and we're a current writer so we're holding the commit
+	 * open until we drop the log_mutex.
+	 */
+	ret = update_log_root(trans, log, &new_root_item);
 	if (atomic_dec_and_test(&log_root_tree->log_writers)) {
 		/* atomic_dec_and_test implies a barrier */
 		cond_wake_up_nomb(&log_root_tree->log_writer_wait);

fs/btrfs/volumes.c+5−1

 		return !extended; /* "0" is valid for usual profiles */
 	/* true if exactly one bit set */
-	return is_power_of_2(flags);
+	/*
+	 * Don't use is_power_of_2(unsigned long) because it won't work
+	 * for the single profile (1ULL << 48) on 32-bit CPUs.
+	 */
+	return flags != 0 && (flags & (flags - 1)) == 0;
 }
 static inline int balance_need_close(struct btrfs_fs_info *fs_info)

fs/ceph/mds_client.c+11−10

 	}
 done:
-	if (*p != end)
+	/* Skip over any unrecognized fields */
-		goto bad;
+	*p = end;
 	return 0;
 bad:
 		goto bad;
 	info->filelock_reply = *p;
-	*p += sizeof(*info->filelock_reply);
-	if (unlikely(*p != end))
+	/* Skip over any unrecognized fields */
-		goto bad;
+	*p = end;
 	return 0;
 bad:
 	return -EIO;
 }
 {
 	if (features == (u64)-1 ||
 	    (features & CEPH_FEATURE_REPLY_CREATE_INODE)) {
+		/* Malformed reply? */
 		if (*p == end) {
 			info->has_create_ino = false;
 		} else {
 			info->has_create_ino = true;
-			info->ino = ceph_decode_64(p);
+			ceph_decode_64_safe(p, end, info->ino, bad);
 		}
+	} else {
+		if (*p != end)
+			goto bad;
 	}
-	if (unlikely(*p != end))
+	/* Skip over any unrecognized fields */
-		goto bad;
+	*p = end;
 	return 0;
 bad:
 	return -EIO;
 }

fs/cifs/cifsfs.c+16−8

@@ -169,18 +169,26 @@ cifs_read_super(struct super_block *sb) · 168 unmodified lines
169	else	169	else
170	sb->s_maxbytes = MAX_NON_LFS;	170	sb->s_maxbytes = MAX_NON_LFS;
171		171
172	/* BB FIXME fix time_gran to be larger for LANMAN sessions */	172	/* Some very old servers like DOS and OS/2 used 2 second granularity */
173	sb->s_time_gran = 100;	173	if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
174		174	((tcon->ses->capabilities &
175	if (tcon->unix_ext) {	175	tcon->ses->server->vals->cap_nt_find) == 0) &&
176	ts = cifs_NTtimeToUnix(0);	176	!tcon->unix_ext) {
		177	sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
		178	ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
177	sb->s_time_min = ts.tv_sec;	179	sb->s_time_min = ts.tv_sec;
178	ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));	180	ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
		181	cpu_to_le16(SMB_TIME_MAX), 0);
179	sb->s_time_max = ts.tv_sec;	182	sb->s_time_max = ts.tv_sec;
180	} else {	183	} else {
181	ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);	184	/*
		185	* Almost every server, including all SMB2+, uses DCE TIME
		186	* ie 100 nanosecond units, since 1601. See MS-DTYP and MS-FSCC
		187	*/
		188	sb->s_time_gran = 100;
		189	ts = cifs_NTtimeToUnix(0);
182	sb->s_time_min = ts.tv_sec;	190	sb->s_time_min = ts.tv_sec;
183	ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX), cpu_to_le16(SMB_TIME_MAX), 0);	191	ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
184	sb->s_time_max = ts.tv_sec;	192	sb->s_time_max = ts.tv_sec;
185	}	193	}
186		194

fs/cifs/cifsglob.h+1−1

@@ -1210,7 +1210,7 @@ struct cifs_search_info { · 1209 unmodified lines
1210	bool smallBuf:1; /* so we know which buf_release function to call */	1210	bool smallBuf:1; /* so we know which buf_release function to call */
1211	};	1211	};
1212		1212
1213	#define ACL_NO_MODE -1	1213	#define ACL_NO_MODE ((umode_t)(-1))
1214	struct cifs_open_parms {	1214	struct cifs_open_parms {
1215	struct cifs_tcon *tcon;	1215	struct cifs_tcon *tcon;
1216	struct cifs_sb_info *cifs_sb;	1216	struct cifs_sb_info *cifs_sb;

fs/cifs/connect.c+2−2

@@ -4264,7 +4264,7 @@ static int mount_get_conns(struct smb_vol vol, struct cifs_sb_info cifs_sb, · 4263 unmodified lines
4264	server->ops->qfs_tcon(*xid, tcon);	4264	server->ops->qfs_tcon(*xid, tcon);
4265	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {	4265	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
4266	if (tcon->fsDevInfo.DeviceCharacteristics &	4266	if (tcon->fsDevInfo.DeviceCharacteristics &
4267	FILE_READ_ONLY_DEVICE)	4267	cpu_to_le32(FILE_READ_ONLY_DEVICE))
4268	cifs_dbg(VFS, "mounted to read only share\n");	4268	cifs_dbg(VFS, "mounted to read only share\n");
4269	else if ((cifs_sb->mnt_cifs_flags &	4269	else if ((cifs_sb->mnt_cifs_flags &
4270	CIFS_MOUNT_RW_CACHE) == 0)	4270	CIFS_MOUNT_RW_CACHE) == 0)
@@ -4445,7 +4445,7 @@ static int setup_dfs_tgt_conn(const char *path, · 174 unmodified lines
4445	int rc;	4445	int rc;
4446	struct dfs_info3_param ref = {0};	4446	struct dfs_info3_param ref = {0};
4447	char mdata = NULL, fake_devname = NULL;	4447	char mdata = NULL, fake_devname = NULL;
4448	struct smb_vol fake_vol = {0};	4448	struct smb_vol fake_vol = {NULL};
4449		4449
4450	cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);	4450	cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
4451		4451

fs/cifs/dir.c+7−1

 static int
 cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
 {
+	struct inode *inode;
 	if (flags & LOOKUP_RCU)
 		return -ECHILD;
 	if (d_really_is_positive(direntry)) {
+		inode = d_inode(direntry);
+		if ((flags & LOOKUP_REVAL) && !CIFS_CACHE_READ(CIFS_I(inode)))
+			CIFS_I(inode)->time = 0; /* force reval */
 		if (cifs_revalidate_dentry(direntry))
 			return 0;
 		else {
 			 * attributes will have been updated by
 			 * cifs_revalidate_dentry().
 			 */
-			if (IS_AUTOMOUNT(d_inode(direntry)) &&
+			if (IS_AUTOMOUNT(inode) &&
 			   !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) {
 				spin_lock(&direntry->d_lock);
 				direntry->d_flags |= DCACHE_NEED_AUTOMOUNT;

fs/cifs/file.c+17−16

 		rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 					 xid, fid);
+	if (rc) {
+		server->ops->close(xid, tcon, fid);
+		if (rc == -ESTALE)
+			rc = -EOPENSTALE;
+	}
 out:
 	kfree(buf);
 	return rc;
 {
 	struct cifsFileInfo *open_file = NULL;
 	struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
-	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 	/* only filter by fsuid on multiuser mounts */
 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
 		fsuid_only = false;
-	spin_lock(&tcon->open_file_lock);
+	spin_lock(&cifs_inode->open_file_lock);
 	/* we could simply get the first_list_entry since write-only entries
 	   are always at the end of the list but since the first entry might
 	   have a close pending, we go through the whole list */
 				/* found a good file */
 				/* lock it so it will not be closed on us */
 				cifsFileInfo_get(open_file);
-				spin_unlock(&tcon->open_file_lock);
+				spin_unlock(&cifs_inode->open_file_lock);
 				return open_file;
 			} /* else might as well continue, and look for
 			     another, or simply have the caller reopen it
 		} else /* write only file */
 			break; /* write only files are last so must be done */
 	}
-	spin_unlock(&tcon->open_file_lock);
+	spin_unlock(&cifs_inode->open_file_lock);
 	return NULL;
 }
 {
 	struct cifsFileInfo *open_file, *inv_file = NULL;
 	struct cifs_sb_info *cifs_sb;
-	struct cifs_tcon *tcon;
 	bool any_available = false;
 	int rc = -EBADF;
 	unsigned int refind = 0;
 	}
 	cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
-	tcon = cifs_sb_master_tcon(cifs_sb);
 	/* only filter by fsuid on multiuser mounts */
 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
 		fsuid_only = false;
-	spin_lock(&tcon->open_file_lock);
+	spin_lock(&cifs_inode->open_file_lock);
 refind_writable:
 	if (refind > MAX_REOPEN_ATT) {
-		spin_unlock(&tcon->open_file_lock);
+		spin_unlock(&cifs_inode->open_file_lock);
 		return rc;
 	}
 	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
 			if (!open_file->invalidHandle) {
 				/* found a good writable file */
 				cifsFileInfo_get(open_file);
-				spin_unlock(&tcon->open_file_lock);
+				spin_unlock(&cifs_inode->open_file_lock);
 				*ret_file = open_file;
 				return 0;
 			} else {
 		cifsFileInfo_get(inv_file);
 	}
-	spin_unlock(&tcon->open_file_lock);
+	spin_unlock(&cifs_inode->open_file_lock);
 	if (inv_file) {
 		rc = cifs_reopen_file(inv_file, false);
 		cifsFileInfo_put(inv_file);
 		++refind;
 		inv_file = NULL;
-		spin_lock(&tcon->open_file_lock);
+		spin_lock(&cifs_inode->open_file_lock);
 		goto refind_writable;
 	}
 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
 {
 	struct cifsFileInfo *open_file;
-	struct cifs_tcon *tcon =
-		cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
-	spin_lock(&tcon->open_file_lock);
+	spin_lock(&cifs_inode->open_file_lock);
 	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
 		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
-			spin_unlock(&tcon->open_file_lock);
+			spin_unlock(&cifs_inode->open_file_lock);
 			return 1;
 		}
 	}
-	spin_unlock(&tcon->open_file_lock);
+	spin_unlock(&cifs_inode->open_file_lock);
 	return 0;
 }

fs/cifs/inode.c+4−0

 		/* if uniqueid is different, return error */
 		if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
 		    CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
+			CIFS_I(*pinode)->time = 0; /* force reval */
 			rc = -ESTALE;
 			goto cgiiu_exit;
 		}
 		/* if filetype is different, return error */
 		if (unlikely(((*pinode)->i_mode & S_IFMT) !=
 		    (fattr.cf_mode & S_IFMT))) {
+			CIFS_I(*pinode)->time = 0; /* force reval */
 			rc = -ESTALE;
 			goto cgiiu_exit;
 		}
 		/* if uniqueid is different, return error */
 		if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
 		    CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
+			CIFS_I(*inode)->time = 0; /* force reval */
 			rc = -ESTALE;
 			goto cgii_exit;
 		}
 		/* if filetype is different, return error */
 		if (unlikely(((*inode)->i_mode & S_IFMT) !=
 		    (fattr.cf_mode & S_IFMT))) {
+			CIFS_I(*inode)->time = 0; /* force reval */
 			rc = -ESTALE;
 			goto cgii_exit;
 		}

fs/cifs/netmisc.c+0−4

 	{0, 0}
 };
-static const struct smb_to_posix_error mapping_table_ERRHRD[] = {
-	{0, 0}
-};
 /*
  * Convert a string containing text IPv4 or IPv6 address to binary form.
  *

fs/cifs/smb2pdu.c+6−8

 	unsigned int num = *num_iovec;
 	iov[num].iov_base = create_posix_buf(mode);
-	if (mode == -1)
+	if (mode == ACL_NO_MODE)
-		cifs_dbg(VFS, "illegal mode\n"); /* BB REMOVEME */
+		cifs_dbg(FYI, "illegal mode\n");
 	if (iov[num].iov_base == NULL)
 		return -ENOMEM;
 	iov[num].iov_len = sizeof(struct create_posix);
 			return rc;
 	}
-	/* TODO: add handling for the mode on create */
+	if ((oparms->disposition == FILE_CREATE) &&
-	if (oparms->disposition == FILE_CREATE)
+	    (oparms->mode != ACL_NO_MODE)) {
-		cifs_dbg(VFS, "mode is 0x%x\n", oparms->mode); /* BB REMOVEME */
-	if ((oparms->disposition == FILE_CREATE) && (oparms->mode != -1)) {
 		if (n_iov > 2) {
 			struct create_context *ccontext =
 			    (struct create_context *)iov[n_iov-1].iov_base;
 	req->PersistentFileId = persistent_fid;
 	req->VolatileFileId = volatile_fid;
-	req->OutputBufferLength = SMB2_MAX_BUFFER_SIZE - MAX_SMB2_HDR_SIZE;
+	req->OutputBufferLength =
+		cpu_to_le32(SMB2_MAX_BUFFER_SIZE - MAX_SMB2_HDR_SIZE);
 	req->CompletionFilter = cpu_to_le32(completion_filter);
 	if (watch_tree)
 		req->Flags = cpu_to_le16(SMB2_WATCH_TREE);

fs/cifs/smb2proto.h+4−0

 			   bool is_fsctl, char *in_data, u32 indatalen,
 			   __u32 max_response_size);
 extern void SMB2_ioctl_free(struct smb_rqst *rqst);
+extern int SMB2_change_notify(const unsigned int xid, struct cifs_tcon *tcon,
+			u64 persistent_fid, u64 volatile_fid, bool watch_tree,
+			u32 completion_filter);
 extern int SMB2_close(const unsigned int xid, struct cifs_tcon *tcon,
 		      u64 persistent_file_id, u64 volatile_file_id);
 extern int SMB2_close_flags(const unsigned int xid, struct cifs_tcon *tcon,

fs/direct-io.c+1−2

 	}
 }
-/**
+/*
  * dio_complete() - called when all DIO BIO I/O has been completed
- * @offset: the byte offset in the file of the completed operation
  *
  * This drops i_dio_count, lets interested parties know that a DIO operation
  * has completed, and calculates the resulting return code for the operation.

fs/fs-writeback.c+8−3

 	if (work->auto_free)
 		kfree(work);
-	if (done && atomic_dec_and_test(&done->cnt))
+	if (done) {
-		wake_up_all(done->waitq);
+		wait_queue_head_t *waitq = done->waitq;
+		/* @done can't be accessed after the following dec */
+		if (atomic_dec_and_test(&done->cnt))
+			wake_up_all(waitq);
+	}
 }
 static void wb_queue_work(struct bdi_writeback *wb,
  * cgroup_writeback_by_id - initiate cgroup writeback from bdi and memcg IDs
  * @bdi_id: target bdi id
  * @memcg_id: target memcg css id
- * @nr_pages: number of pages to write, 0 for best-effort dirty flushing
+ * @nr: number of pages to write, 0 for best-effort dirty flushing
  * @reason: reason why some writeback work initiated
  * @done: target wb_completion
  *

fs/io_uring.c+90−55

@@ -322,6 +322,8 @@ struct io_kiocb { · 321 unmodified lines
322	#define REQ_F_FAIL_LINK 256 /* fail rest of links */	322	#define REQ_F_FAIL_LINK 256 /* fail rest of links */
323	#define REQ_F_SHADOW_DRAIN 512 /* link-drain shadow req */	323	#define REQ_F_SHADOW_DRAIN 512 /* link-drain shadow req */
324	#define REQ_F_TIMEOUT 1024 /* timeout request */	324	#define REQ_F_TIMEOUT 1024 /* timeout request */
		325	#define REQ_F_ISREG 2048 /* regular file */
		326	#define REQ_F_MUST_PUNT 4096 /* must be punted even for NONBLOCK */
325	u64 user_data;	327	u64 user_data;
326	u32 result;	328	u32 result;
327	u32 sequence;	329	u32 sequence;
@@ -415,27 +417,27 @@ static struct io_ring_ctx io_ring_ctx_alloc(struct io_uring_params p) · 87 unmodified lines
415	return ctx;	417	return ctx;
416	}	418	}
417		419
		420	static inline bool __io_sequence_defer(struct io_ring_ctx *ctx,
		421	struct io_kiocb *req)
		422	{
		423	return req->sequence != ctx->cached_cq_tail + ctx->rings->sq_dropped;
		424	}
		425
418	static inline bool io_sequence_defer(struct io_ring_ctx *ctx,	426	static inline bool io_sequence_defer(struct io_ring_ctx *ctx,
419	struct io_kiocb *req)	427	struct io_kiocb *req)
420	{	428	{
421	/* timeout requests always honor sequence */	429	if ((req->flags & (REQ_F_IO_DRAIN\|REQ_F_IO_DRAINED)) != REQ_F_IO_DRAIN)
422	if (!(req->flags & REQ_F_TIMEOUT) &&
423	(req->flags & (REQ_F_IO_DRAIN\|REQ_F_IO_DRAINED)) != REQ_F_IO_DRAIN)
424	return false;	430	return false;
425		431
426	return req->sequence != ctx->cached_cq_tail + ctx->rings->sq_dropped;	432	return __io_sequence_defer(ctx, req);
427	}	433	}
428		434
429	static struct io_kiocb __io_get_deferred_req(struct io_ring_ctx ctx,	435	static struct io_kiocb io_get_deferred_req(struct io_ring_ctx ctx)
430	struct list_head *list)
431	{	436	{
432	struct io_kiocb *req;	437	struct io_kiocb *req;
433		438
434	if (list_empty(list))	439	req = list_first_entry_or_null(&ctx->defer_list, struct io_kiocb, list);
435	return NULL;	440	if (req && !io_sequence_defer(ctx, req)) {
436
437	req = list_first_entry(list, struct io_kiocb, list);
438	if (!io_sequence_defer(ctx, req)) {
439	list_del_init(&req->list);	441	list_del_init(&req->list);
440	return req;	442	return req;
441	}	443	}
@@ -443,14 +445,17 @@ static struct io_kiocb __io_get_deferred_req(struct io_ring_ctx ctx, · 1 unmodified line
443	return NULL;	445	return NULL;
444	}	446	}
445		447
446	static struct io_kiocb io_get_deferred_req(struct io_ring_ctx ctx)
447	{
448	return __io_get_deferred_req(ctx, &ctx->defer_list);
449	}
450
451	static struct io_kiocb io_get_timeout_req(struct io_ring_ctx ctx)	448	static struct io_kiocb io_get_timeout_req(struct io_ring_ctx ctx)
452	{	449	{
453	return __io_get_deferred_req(ctx, &ctx->timeout_list);	450	struct io_kiocb *req;
		451
		452	req = list_first_entry_or_null(&ctx->timeout_list, struct io_kiocb, list);
		453	if (req && !__io_sequence_defer(ctx, req)) {
		454	list_del_init(&req->list);
		455	return req;
		456	}
		457
		458	return NULL;
454	}	459	}
455		460
456	static void __io_commit_cqring(struct io_ring_ctx *ctx)	461	static void __io_commit_cqring(struct io_ring_ctx *ctx)
@@ -591,14 +596,6 @@ static void io_cqring_add_event(struct io_ring_ctx *ctx, u64 user_data, · 134 unmodified lines
591	io_cqring_ev_posted(ctx);	596	io_cqring_ev_posted(ctx);
592	}	597	}
593		598
594	static void io_ring_drop_ctx_refs(struct io_ring_ctx *ctx, unsigned refs)
595	{
596	percpu_ref_put_many(&ctx->refs, refs);
597
598	if (waitqueue_active(&ctx->wait))
599	wake_up(&ctx->wait);
600	}
601
602	static struct io_kiocb io_get_req(struct io_ring_ctx ctx,	599	static struct io_kiocb io_get_req(struct io_ring_ctx ctx,
603	struct io_submit_state *state)	600	struct io_submit_state *state)
604	{	601	{
@@ -646,7 +643,7 @@ static struct io_kiocb io_get_req(struct io_ring_ctx ctx, · 41 unmodified lines
646	req->result = 0;	643	req->result = 0;
647	return req;	644	return req;
648	out:	645	out:
649	io_ring_drop_ctx_refs(ctx, 1);	646	percpu_ref_put(&ctx->refs);
650	return NULL;	647	return NULL;
651	}	648	}
652		649
@@ -654,7 +651,7 @@ static void io_free_req_many(struct io_ring_ctx ctx, void reqs, int nr) · 1 unmodified line
654	{	651	{
655	if (*nr) {	652	if (*nr) {
656	kmem_cache_free_bulk(req_cachep, *nr, reqs);	653	kmem_cache_free_bulk(req_cachep, *nr, reqs);
657	io_ring_drop_ctx_refs(ctx, *nr);	654	percpu_ref_put_many(&ctx->refs, *nr);
658	*nr = 0;	655	*nr = 0;
659	}	656	}
660	}	657	}
@@ -663,7 +660,7 @@ static void __io_free_req(struct io_kiocb *req) · 2 unmodified lines
663	{	660	{
664	if (req->file && !(req->flags & REQ_F_FIXED_FILE))	661	if (req->file && !(req->flags & REQ_F_FIXED_FILE))
665	fput(req->file);	662	fput(req->file);
666	io_ring_drop_ctx_refs(req->ctx, 1);	663	percpu_ref_put(&req->ctx->refs);
667	kmem_cache_free(req_cachep, req);	664	kmem_cache_free(req_cachep, req);
668	}	665	}
669		666
@@ -919,26 +916,26 @@ static int io_iopoll_check(struct io_ring_ctx ctx, unsigned nr_events, · 249 unmodified lines
919	return ret;	916	return ret;
920	}	917	}
921		918
922	static void kiocb_end_write(struct kiocb *kiocb)	919	static void kiocb_end_write(struct io_kiocb *req)
923	{	920	{
924	if (kiocb->ki_flags & IOCB_WRITE) {	921	/*
925	struct inode *inode = file_inode(kiocb->ki_filp);	922	* Tell lockdep we inherited freeze protection from submission
		923	* thread.
		924	*/
		925	if (req->flags & REQ_F_ISREG) {
		926	struct inode *inode = file_inode(req->file);
926		927
927	/*	928	__sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE);
928	* Tell lockdep we inherited freeze protection from submission
929	* thread.
930	*/
931	if (S_ISREG(inode->i_mode))
932	__sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE);
933	file_end_write(kiocb->ki_filp);
934	}	929	}
		930	file_end_write(req->file);
935	}	931	}
936		932
937	static void io_complete_rw(struct kiocb *kiocb, long res, long res2)	933	static void io_complete_rw(struct kiocb *kiocb, long res, long res2)
938	{	934	{
939	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);	935	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);
940		936
941	kiocb_end_write(kiocb);	937	if (kiocb->ki_flags & IOCB_WRITE)
		938	kiocb_end_write(req);
942		939
943	if ((req->flags & REQ_F_LINK) && res != req->result)	940	if ((req->flags & REQ_F_LINK) && res != req->result)
944	req->flags \|= REQ_F_FAIL_LINK;	941	req->flags \|= REQ_F_FAIL_LINK;
@@ -950,7 +947,8 @@ static void io_complete_rw_iopoll(struct kiocb *kiocb, long res, long res2) · 5 unmodified lines
950	{	947	{
951	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);	948	struct io_kiocb *req = container_of(kiocb, struct io_kiocb, rw);
952		949
953	kiocb_end_write(kiocb);	950	if (kiocb->ki_flags & IOCB_WRITE)
		951	kiocb_end_write(req);
954		952
955	if ((req->flags & REQ_F_LINK) && res != req->result)	953	if ((req->flags & REQ_F_LINK) && res != req->result)
956	req->flags \|= REQ_F_FAIL_LINK;	954	req->flags \|= REQ_F_FAIL_LINK;
@@ -1064,8 +1062,17 @@ static int io_prep_rw(struct io_kiocb req, const struct sqe_submit s, · 107 unmodified lines
1064	if (!req->file)	1062	if (!req->file)
1065	return -EBADF;	1063	return -EBADF;
1066		1064
1067	if (force_nonblock && !io_file_supports_async(req->file))	1065	if (S_ISREG(file_inode(req->file)->i_mode))
1068	force_nonblock = false;	1066	req->flags \|= REQ_F_ISREG;
		1067
		1068	/*
		1069	* If the file doesn't support async, mark it as REQ_F_MUST_PUNT so
		1070	* we know to async punt it even if it was opened O_NONBLOCK
		1071	*/
		1072	if (force_nonblock && !io_file_supports_async(req->file)) {
		1073	req->flags \|= REQ_F_MUST_PUNT;
		1074	return -EAGAIN;
		1075	}
1069		1076
1070	kiocb->ki_pos = READ_ONCE(sqe->off);	1077	kiocb->ki_pos = READ_ONCE(sqe->off);
1071	kiocb->ki_flags = iocb_flags(kiocb->ki_filp);	1078	kiocb->ki_flags = iocb_flags(kiocb->ki_filp);
@@ -1086,7 +1093,8 @@ static int io_prep_rw(struct io_kiocb req, const struct sqe_submit s, · 14 unmodified lines
1086	return ret;	1093	return ret;
1087		1094
1088	/* don't allow async punt if RWF_NOWAIT was requested */	1095	/* don't allow async punt if RWF_NOWAIT was requested */
1089	if (kiocb->ki_flags & IOCB_NOWAIT)	1096	if ((kiocb->ki_flags & IOCB_NOWAIT) \|\|
		1097	(req->file->f_flags & O_NONBLOCK))
1090	req->flags \|= REQ_F_NOWAIT;	1098	req->flags \|= REQ_F_NOWAIT;
1091		1099
1092	if (force_nonblock)	1100	if (force_nonblock)
@@ -1387,7 +1395,9 @@ static int io_read(struct io_kiocb req, const struct sqe_submit s, · 294 unmodified lines
1387	* need async punt anyway, so it's more efficient to do it	1395	* need async punt anyway, so it's more efficient to do it
1388	* here.	1396	* here.
1389	*/	1397	*/
1390	if (force_nonblock && ret2 > 0 && ret2 < read_size)	1398	if (force_nonblock && !(req->flags & REQ_F_NOWAIT) &&
		1399	(req->flags & REQ_F_ISREG) &&
		1400	ret2 > 0 && ret2 < read_size)
1391	ret2 = -EAGAIN;	1401	ret2 = -EAGAIN;
1392	/* Catch -EAGAIN return for forced non-blocking submission */	1402	/* Catch -EAGAIN return for forced non-blocking submission */
1393	if (!force_nonblock \|\| ret2 != -EAGAIN) {	1403	if (!force_nonblock \|\| ret2 != -EAGAIN) {
@@ -1452,7 +1462,7 @@ static int io_write(struct io_kiocb req, const struct sqe_submit s, · 58 unmodified lines
1452	* released so that it doesn't complain about the held lock when	1462	* released so that it doesn't complain about the held lock when
1453	* we return to userspace.	1463	* we return to userspace.
1454	*/	1464	*/
1455	if (S_ISREG(file_inode(file)->i_mode)) {	1465	if (req->flags & REQ_F_ISREG) {
1456	__sb_start_write(file_inode(file)->i_sb,	1466	__sb_start_write(file_inode(file)->i_sb,
1457	SB_FREEZE_WRITE, true);	1467	SB_FREEZE_WRITE, true);
1458	__sb_writers_release(file_inode(file)->i_sb,	1468	__sb_writers_release(file_inode(file)->i_sb,
@@ -1889,7 +1899,7 @@ static enum hrtimer_restart io_timeout_fn(struct hrtimer *timer) · 430 unmodified lines
1889		1899
1890	static int io_timeout(struct io_kiocb req, const struct io_uring_sqe sqe)	1900	static int io_timeout(struct io_kiocb req, const struct io_uring_sqe sqe)
1891	{	1901	{
1892	unsigned count, req_dist, tail_index;	1902	unsigned count;
1893	struct io_ring_ctx *ctx = req->ctx;	1903	struct io_ring_ctx *ctx = req->ctx;
1894	struct list_head *entry;	1904	struct list_head *entry;
1895	struct timespec64 ts;	1905	struct timespec64 ts;
@@ -1912,21 +1922,36 @@ static int io_timeout(struct io_kiocb req, const struct io_uring_sqe sqe) · 16 unmodified lines
1912	count = 1;	1922	count = 1;
1913		1923
1914	req->sequence = ctx->cached_sq_head + count - 1;	1924	req->sequence = ctx->cached_sq_head + count - 1;
		1925	/* reuse it to store the count */
		1926	req->submit.sequence = count;
1915	req->flags \|= REQ_F_TIMEOUT;	1927	req->flags \|= REQ_F_TIMEOUT;
1916		1928
1917	/*	1929	/*
1918	* Insertion sort, ensuring the first entry in the list is always	1930	* Insertion sort, ensuring the first entry in the list is always
1919	* the one we need first.	1931	* the one we need first.
1920	*/	1932	*/
1921	tail_index = ctx->cached_cq_tail - ctx->rings->sq_dropped;
1922	req_dist = req->sequence - tail_index;
1923	spin_lock_irq(&ctx->completion_lock);	1933	spin_lock_irq(&ctx->completion_lock);
1924	list_for_each_prev(entry, &ctx->timeout_list) {	1934	list_for_each_prev(entry, &ctx->timeout_list) {
1925	struct io_kiocb *nxt = list_entry(entry, struct io_kiocb, list);	1935	struct io_kiocb *nxt = list_entry(entry, struct io_kiocb, list);
1926	unsigned dist;	1936	unsigned nxt_sq_head;
		1937	long long tmp, tmp_nxt;
1927		1938
1928	dist = nxt->sequence - tail_index;	1939	/*
1929	if (req_dist >= dist)	1940	* Since cached_sq_head + count - 1 can overflow, use type long
		1941	* long to store it.
		1942	*/
		1943	tmp = (long long)ctx->cached_sq_head + count - 1;
		1944	nxt_sq_head = nxt->sequence - nxt->submit.sequence + 1;
		1945	tmp_nxt = (long long)nxt_sq_head + nxt->submit.sequence - 1;
		1946
		1947	/*
		1948	* cached_sq_head may overflow, and it will never overflow twice
		1949	* once there is some timeout req still be valid.
		1950	*/
		1951	if (ctx->cached_sq_head < nxt_sq_head)
		1952	tmp += UINT_MAX;
		1953
		1954	if (tmp >= tmp_nxt)
1930	break;	1955	break;
1931	}	1956	}
1932	list_add(&req->list, entry);	1957	list_add(&req->list, entry);
@@ -2272,7 +2297,13 @@ static int __io_queue_sqe(struct io_ring_ctx ctx, struct io_kiocb req, · 339 unmodified lines
2272	int ret;	2297	int ret;
2273		2298
2274	ret = __io_submit_sqe(ctx, req, s, force_nonblock);	2299	ret = __io_submit_sqe(ctx, req, s, force_nonblock);
2275	if (ret == -EAGAIN && !(req->flags & REQ_F_NOWAIT)) {	2300
		2301	/*
		2302	* We async punt it if the file wasn't marked NOWAIT, or if the file
		2303	* doesn't support non-blocking read/write attempts
		2304	*/
		2305	if (ret == -EAGAIN && (!(req->flags & REQ_F_NOWAIT) \|\|
		2306	(req->flags & REQ_F_MUST_PUNT))) {
2276	struct io_uring_sqe *sqe_copy;	2307	struct io_uring_sqe *sqe_copy;
2277		2308
2278	sqe_copy = kmemdup(s->sqe, sizeof(*sqe_copy), GFP_KERNEL);	2309	sqe_copy = kmemdup(s->sqe, sizeof(*sqe_copy), GFP_KERNEL);
@@ -2761,7 +2792,7 @@ out: · 482 unmodified lines
2761		2792
2762	if (link)	2793	if (link)
2763	io_queue_link_head(ctx, link, &link->submit, shadow_req,	2794	io_queue_link_head(ctx, link, &link->submit, shadow_req,
2764	block_for_last);	2795	!block_for_last);
2765	if (statep)	2796	if (statep)
2766	io_submit_state_end(statep);	2797	io_submit_state_end(statep);
2767		2798
@@ -2920,8 +2951,12 @@ static void io_finish_async(struct io_ring_ctx *ctx) · 152 unmodified lines
2920	static void io_destruct_skb(struct sk_buff *skb)	2951	static void io_destruct_skb(struct sk_buff *skb)
2921	{	2952	{
2922	struct io_ring_ctx *ctx = skb->sk->sk_user_data;	2953	struct io_ring_ctx *ctx = skb->sk->sk_user_data;
		2954	int i;
		2955
		2956	for (i = 0; i < ARRAY_SIZE(ctx->sqo_wq); i++)
		2957	if (ctx->sqo_wq[i])
		2958	flush_workqueue(ctx->sqo_wq[i]);
2923		2959
2924	io_finish_async(ctx);
2925	unix_destruct_scm(skb);	2960	unix_destruct_scm(skb);
2926	}	2961	}
2927		2962
@@ -3630,7 +3665,7 @@ SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit, · 702 unmodified lines
3630	}	3665	}
3631	}	3666	}
3632		3667
3633	io_ring_drop_ctx_refs(ctx, 1);	3668	percpu_ref_put(&ctx->refs);
3634	out_fput:	3669	out_fput:
3635	fdput(f);	3670	fdput(f);
3636	return submitted ? submitted : ret;	3671	return submitted ? submitted : ret;

fs/libfs.c+72−68

@@ -89,58 +89,45 @@ int dcache_dir_close(struct inode inode, struct file file) · 88 unmodified lines
89	EXPORT_SYMBOL(dcache_dir_close);	89	EXPORT_SYMBOL(dcache_dir_close);
90		90
91	/* parent is locked at least shared */	91	/* parent is locked at least shared */
92	static struct dentry next_positive(struct dentry parent,	92	/*
93	struct list_head *from,	93	* Returns an element of siblings' list.
94	int count)	94	* We are looking for <count>th positive after <p>; if
		95	* found, dentry is grabbed and returned to caller.
		96	* If no such element exists, NULL is returned.
		97	*/
		98	static struct dentry scan_positives(struct dentry cursor,
		99	struct list_head *p,
		100	loff_t count,
		101	struct dentry *last)
95	{	102	{
96	unsigned *seq = &parent->d_inode->i_dir_seq, n;	103	struct dentry dentry = cursor->d_parent, found = NULL;
97	struct dentry *res;
98	struct list_head *p;
99	bool skipped;
100	int i;
101		104
102	retry:	105	spin_lock(&dentry->d_lock);
103	i = count;	106	while ((p = p->next) != &dentry->d_subdirs) {
104	skipped = false;
105	n = smp_load_acquire(seq) & ~1;
106	res = NULL;
107	rcu_read_lock();
108	for (p = from->next; p != &parent->d_subdirs; p = p->next) {
109	struct dentry *d = list_entry(p, struct dentry, d_child);	107	struct dentry *d = list_entry(p, struct dentry, d_child);
110	if (!simple_positive(d)) {	108	// we must at least skip cursors, to avoid livelocks
111	skipped = true;	109	if (d->d_flags & DCACHE_DENTRY_CURSOR)
112	} else if (!--i) {	110	continue;
113	res = d;	111	if (simple_positive(d) && !--count) {
114	break;	112	spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
		113	if (simple_positive(d))
		114	found = dget_dlock(d);
		115	spin_unlock(&d->d_lock);
		116	if (likely(found))
		117	break;
		118	count = 1;
		119	}
		120	if (need_resched()) {
		121	list_move(&cursor->d_child, p);
		122	p = &cursor->d_child;
		123	spin_unlock(&dentry->d_lock);
		124	cond_resched();
		125	spin_lock(&dentry->d_lock);
115	}	126	}
116	}	127	}
117	rcu_read_unlock();	128	spin_unlock(&dentry->d_lock);
118	if (skipped) {	129	dput(last);
119	smp_rmb();	130	return found;
120	if (unlikely(*seq != n))
121	goto retry;
122	}
123	return res;
124	}
125
126	static void move_cursor(struct dentry cursor, struct list_head after)
127	{
128	struct dentry *parent = cursor->d_parent;
129	unsigned n, *seq = &parent->d_inode->i_dir_seq;
130	spin_lock(&parent->d_lock);
131	for (;;) {
132	n = *seq;
133	if (!(n & 1) && cmpxchg(seq, n, n + 1) == n)
134	break;
135	cpu_relax();
136	}
137	__list_del(cursor->d_child.prev, cursor->d_child.next);
138	if (after)
139	list_add(&cursor->d_child, after);
140	else
141	list_add_tail(&cursor->d_child, &parent->d_subdirs);
142	smp_store_release(seq, n + 2);
143	spin_unlock(&parent->d_lock);
144	}	131	}
145		132
146	loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)	133	loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
@@ -158,17 +145,25 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence) · 11 unmodified lines
158	return -EINVAL;	145	return -EINVAL;
159	}	146	}
160	if (offset != file->f_pos) {	147	if (offset != file->f_pos) {
		148	struct dentry *cursor = file->private_data;
		149	struct dentry *to = NULL;
		150
		151	inode_lock_shared(dentry->d_inode);
		152
		153	if (offset > 2)
		154	to = scan_positives(cursor, &dentry->d_subdirs,
		155	offset - 2, NULL);
		156	spin_lock(&dentry->d_lock);
		157	if (to)
		158	list_move(&cursor->d_child, &to->d_child);
		159	else
		160	list_del_init(&cursor->d_child);
		161	spin_unlock(&dentry->d_lock);
		162	dput(to);
		163
161	file->f_pos = offset;	164	file->f_pos = offset;
162	if (file->f_pos >= 2) {	165
163	struct dentry *cursor = file->private_data;	166	inode_unlock_shared(dentry->d_inode);
164	struct dentry *to;
165	loff_t n = file->f_pos - 2;
166
167	inode_lock_shared(dentry->d_inode);
168	to = next_positive(dentry, &dentry->d_subdirs, n);
169	move_cursor(cursor, to ? &to->d_child : NULL);
170	inode_unlock_shared(dentry->d_inode);
171	}
172	}	167	}
173	return offset;	168	return offset;
174	}	169	}
@@ -190,25 +185,35 @@ int dcache_readdir(struct file file, struct dir_context ctx) · 15 unmodified lines
190	{	185	{
191	struct dentry *dentry = file->f_path.dentry;	186	struct dentry *dentry = file->f_path.dentry;
192	struct dentry *cursor = file->private_data;	187	struct dentry *cursor = file->private_data;
193	struct list_head *p = &cursor->d_child;	188	struct list_head *anchor = &dentry->d_subdirs;
194	struct dentry *next;	189	struct dentry *next = NULL;
195	bool moved = false;	190	struct list_head *p;
196		191
197	if (!dir_emit_dots(file, ctx))	192	if (!dir_emit_dots(file, ctx))
198	return 0;	193	return 0;
199		194
200	if (ctx->pos == 2)	195	if (ctx->pos == 2)
201	p = &dentry->d_subdirs;	196	p = anchor;
202	while ((next = next_positive(dentry, p, 1)) != NULL) {	197	else if (!list_empty(&cursor->d_child))
		198	p = &cursor->d_child;
		199	else
		200	return 0;
		201
		202	while ((next = scan_positives(cursor, p, 1, next)) != NULL) {
203	if (!dir_emit(ctx, next->d_name.name, next->d_name.len,	203	if (!dir_emit(ctx, next->d_name.name, next->d_name.len,
204	d_inode(next)->i_ino, dt_type(d_inode(next))))	204	d_inode(next)->i_ino, dt_type(d_inode(next))))
205	break;	205	break;
206	moved = true;
207	p = &next->d_child;
208	ctx->pos++;	206	ctx->pos++;
		207	p = &next->d_child;
209	}	208	}
210	if (moved)	209	spin_lock(&dentry->d_lock);
211	move_cursor(cursor, p);	210	if (next)
		211	list_move_tail(&cursor->d_child, &next->d_child);
		212	else
		213	list_del_init(&cursor->d_child);
		214	spin_unlock(&dentry->d_lock);
		215	dput(next);
		216
212	return 0;	217	return 0;
213	}	218	}
214	EXPORT_SYMBOL(dcache_readdir);	219	EXPORT_SYMBOL(dcache_readdir);
@@ -468,8 +473,7 @@ EXPORT_SYMBOL(simple_write_begin); · 253 unmodified lines
468		473
469	/**	474	/**
470	* simple_write_end - .write_end helper for non-block-device FSes	475	* simple_write_end - .write_end helper for non-block-device FSes
471	* @available: See .write_end of address_space_operations	476	* @file: See .write_end of address_space_operations
472	* @file: "
473	* @mapping: "	477	* @mapping: "
474	* @pos: "	478	* @pos: "
475	* @len: "	479	* @len: "

fs/nfs/direct.c+36−70

 static struct kmem_cache *nfs_direct_cachep;
-/*
- * This represents a set of asynchronous requests that we're waiting on
- */
-struct nfs_direct_mirror {
-	ssize_t count;
-};
 struct nfs_direct_req {
 	struct kref		kref;		/* release manager */
 	atomic_t		io_count;	/* i/os we're waiting for */
 	spinlock_t		lock;		/* protect completion state */
-	struct nfs_direct_mirror mirrors[NFS_PAGEIO_DESCRIPTOR_MIRROR_MAX];
-	int			mirror_count;
 	loff_t			io_start;	/* Start offset for I/O */
 	ssize_t			count,		/* bytes actually processed */
 				max_count,	/* max expected count */
 }
 static void
-nfs_direct_good_bytes(struct nfs_direct_req *dreq, struct nfs_pgio_header *hdr)
+nfs_direct_handle_truncated(struct nfs_direct_req *dreq,
+			    const struct nfs_pgio_header *hdr,
+			    ssize_t dreq_len)
 {
-	int i;
+	if (!(test_bit(NFS_IOHDR_ERROR, &hdr->flags) ||
-	ssize_t count;
+	      test_bit(NFS_IOHDR_EOF, &hdr->flags)))
+		return;
+	if (dreq->max_count >= dreq_len) {
+		dreq->max_count = dreq_len;
+		if (dreq->count > dreq_len)
+			dreq->count = dreq_len;
+		if (test_bit(NFS_IOHDR_ERROR, &hdr->flags))
+			dreq->error = hdr->error;
+		else /* Clear outstanding error if this is EOF */
+			dreq->error = 0;
+	}
+}
-	WARN_ON_ONCE(dreq->count >= dreq->max_count);
+static void
+nfs_direct_count_bytes(struct nfs_direct_req *dreq,
+		       const struct nfs_pgio_header *hdr)
+{
+	loff_t hdr_end = hdr->io_start + hdr->good_bytes;
+	ssize_t dreq_len = 0;
-	if (dreq->mirror_count == 1) {
+	if (hdr_end > dreq->io_start)
-		dreq->mirrors[hdr->pgio_mirror_idx].count += hdr->good_bytes;
+		dreq_len = hdr_end - dreq->io_start;
-		dreq->count += hdr->good_bytes;
-	} else {
-		/* mirrored writes */
-		count = dreq->mirrors[hdr->pgio_mirror_idx].count;
-		if (count + dreq->io_start < hdr->io_start + hdr->good_bytes) {
-			count = hdr->io_start + hdr->good_bytes - dreq->io_start;
-			dreq->mirrors[hdr->pgio_mirror_idx].count = count;
-		}
-		/* update the dreq->count by finding the minimum agreed count from all
-		 * mirrors */
-		count = dreq->mirrors[0].count;
-		for (i = 1; i < dreq->mirror_count; i++)
+	nfs_direct_handle_truncated(dreq, hdr, dreq_len);
-			count = min(count, dreq->mirrors[i].count);
-		dreq->count = count;
+	if (dreq_len > dreq->max_count)
-	}
+		dreq_len = dreq->max_count;
+	if (dreq->count < dreq_len)
+		dreq->count = dreq_len;
 }
 /*
 	cinfo->completion_ops = &nfs_direct_commit_completion_ops;
 }
-static inline void nfs_direct_setup_mirroring(struct nfs_direct_req *dreq,
-					     struct nfs_pageio_descriptor *pgio,
-					     struct nfs_page *req)
-{
-	int mirror_count = 1;
-	if (pgio->pg_ops->pg_get_mirror_count)
-		mirror_count = pgio->pg_ops->pg_get_mirror_count(pgio, req);
-	dreq->mirror_count = mirror_count;
-}
 static inline struct nfs_direct_req *nfs_direct_req_alloc(void)
 {
 	struct nfs_direct_req *dreq;
 	INIT_LIST_HEAD(&dreq->mds_cinfo.list);
 	dreq->verf.committed = NFS_INVALID_STABLE_HOW;	/* not set yet */
 	INIT_WORK(&dreq->work, nfs_direct_write_schedule_work);
-	dreq->mirror_count = 1;
 	spin_lock_init(&dreq->lock);
 	return dreq;
 	struct nfs_direct_req *dreq = hdr->dreq;
 	spin_lock(&dreq->lock);
-	if (test_bit(NFS_IOHDR_ERROR, &hdr->flags))
-		dreq->error = hdr->error;
 	if (test_bit(NFS_IOHDR_REDO, &hdr->flags)) {
 		spin_unlock(&dreq->lock);
 		goto out_put;
 	}
-	if (hdr->good_bytes != 0)
+	nfs_direct_count_bytes(dreq, hdr);
-		nfs_direct_good_bytes(dreq, hdr);
-	if (test_bit(NFS_IOHDR_EOF, &hdr->flags))
-		dreq->error = 0;
 	spin_unlock(&dreq->lock);
 	while (!list_empty(&hdr->pages)) {
 	LIST_HEAD(reqs);
 	struct nfs_commit_info cinfo;
 	LIST_HEAD(failed);
-	int i;
 	nfs_init_cinfo_from_dreq(&cinfo, dreq);
 	nfs_direct_write_scan_commit_list(dreq->inode, &reqs, &cinfo);
 	dreq->count = 0;
+	dreq->max_count = 0;
+	list_for_each_entry(req, &reqs, wb_list)
+		dreq->max_count += req->wb_bytes;
 	dreq->verf.committed = NFS_INVALID_STABLE_HOW;
 	nfs_clear_pnfs_ds_commit_verifiers(&dreq->ds_cinfo);
-	for (i = 0; i < dreq->mirror_count; i++)
-		dreq->mirrors[i].count = 0;
 	get_dreq(dreq);
 	nfs_pageio_init_write(&desc, dreq->inode, FLUSH_STABLE, false,
 			      &nfs_direct_write_completion_ops);
 	desc.pg_dreq = dreq;
-	req = nfs_list_entry(reqs.next);
-	nfs_direct_setup_mirroring(dreq, &desc, req);
-	if (desc.pg_error < 0) {
-		list_splice_init(&reqs, &failed);
-		goto out_failed;
-	}
 	list_for_each_entry_safe(req, tmp, &reqs, wb_list) {
 		/* Bump the transmission count */
 		req->wb_nio++;
 	}
 	nfs_pageio_complete(&desc);
-out_failed:
 	while (!list_empty(&failed)) {
 		req = nfs_list_entry(failed.next);
 		nfs_list_remove_request(req);
 	nfs_init_cinfo_from_dreq(&cinfo, dreq);
 	spin_lock(&dreq->lock);
-	if (test_bit(NFS_IOHDR_ERROR, &hdr->flags))
-		dreq->error = hdr->error;
 	if (test_bit(NFS_IOHDR_REDO, &hdr->flags)) {
 		spin_unlock(&dreq->lock);
 		goto out_put;
 	}
+	nfs_direct_count_bytes(dreq, hdr);
 	if (hdr->good_bytes != 0) {
-		nfs_direct_good_bytes(dreq, hdr);
 		if (nfs_write_need_commit(hdr)) {
 			if (dreq->flags == NFS_ODIRECT_RESCHED_WRITES)
 				request_commit = true;
 				break;
 			}
-			nfs_direct_setup_mirroring(dreq, &desc, req);
 			if (desc.pg_error < 0) {
 				nfs_free_request(req);
 				result = desc.pg_error;

fs/nfs/nfs4proc.c+1−0

@@ -6106,6 +6106,7 @@ int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, · 6105 unmodified lines
6106		6106
6107	status = nfs4_call_sync_custom(&task_setup_data);	6107	status = nfs4_call_sync_custom(&task_setup_data);
6108	if (setclientid.sc_cred) {	6108	if (setclientid.sc_cred) {
		6109	kfree(clp->cl_acceptor);
6109	clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred);	6110	clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred);
6110	put_rpccred(setclientid.sc_cred);	6111	put_rpccred(setclientid.sc_cred);
6111	}	6112	}

fs/nfs/write.c+3−2

 	struct nfs_inode *nfsi = NFS_I(inode);
 	struct nfs_page *head;
-	atomic_long_dec(&nfsi->nrequests);
 	if (nfs_page_group_sync_on_bit(req, PG_REMOVE)) {
 		head = req->wb_head;
 		spin_unlock(&mapping->private_lock);
 	}
-	if (test_and_clear_bit(PG_INODE_REF, &req->wb_flags))
+	if (test_and_clear_bit(PG_INODE_REF, &req->wb_flags)) {
 		nfs_release_request(req);
+		atomic_long_dec(&nfsi->nrequests);
+	}
 }
 static void

fs/ocfs2/aops.c+23−2

 		inode->i_mtime = inode->i_ctime = current_time(inode);
 		di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec);
 		di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
-		ocfs2_update_inode_fsync_trans(handle, inode, 1);
+		if (handle)
+			ocfs2_update_inode_fsync_trans(handle, inode, 1);
 	}
 	if (handle)
 		ocfs2_journal_dirty(handle, wc->w_di_bh);
 	struct ocfs2_dio_write_ctxt *dwc = NULL;
 	struct buffer_head *di_bh = NULL;
 	u64 p_blkno;
-	loff_t pos = iblock << inode->i_sb->s_blocksize_bits;
+	unsigned int i_blkbits = inode->i_sb->s_blocksize_bits;
+	loff_t pos = iblock << i_blkbits;
+	sector_t endblk = (i_size_read(inode) - 1) >> i_blkbits;
 	unsigned len, total_len = bh_result->b_size;
 	int ret = 0, first_get_block = 0;
 	len = osb->s_clustersize - (pos & (osb->s_clustersize - 1));
 	len = min(total_len, len);
+	/*
+	 * bh_result->b_size is count in get_more_blocks according to write
+	 * "pos" and "end", we need map twice to return different buffer state:
+	 * 1. area in file size, not set NEW;
+	 * 2. area out file size, set  NEW.
+	 *
+	 *		   iblock    endblk
+	 * |--------|---------|---------|---------
+	 * |<-------area in file------->|
+	 */
+	if ((iblock <= endblk) &&
+	    ((iblock + ((len - 1) >> i_blkbits)) > endblk))
+		len = (endblk - iblock + 1) << i_blkbits;
 	mlog(0, "get block of %lu at %llu:%u req %u\n",
 			inode->i_ino, pos, len, total_len);
 	if (desc->c_needs_zero)
 		set_buffer_new(bh_result);
+	if (iblock > endblk)
+		set_buffer_new(bh_result);
 	/* May sleep in end_io. It should not happen in a irq context. So defer
 	 * it to dio work queue. */
 	set_buffer_defer_completion(bh_result);

fs/ocfs2/file.c+2−0

 			transfer_to[USRQUOTA] = dqget(sb, make_kqid_uid(attr->ia_uid));
 			if (IS_ERR(transfer_to[USRQUOTA])) {
 				status = PTR_ERR(transfer_to[USRQUOTA]);
+				transfer_to[USRQUOTA] = NULL;
 				goto bail_unlock;
 			}
 		}
 			transfer_to[GRPQUOTA] = dqget(sb, make_kqid_gid(attr->ia_gid));
 			if (IS_ERR(transfer_to[GRPQUOTA])) {
 				status = PTR_ERR(transfer_to[GRPQUOTA]);
+				transfer_to[GRPQUOTA] = NULL;
 				goto bail_unlock;
 			}
 		}

fs/ocfs2/ioctl.c+1−1

@@ -283,7 +283,7 @@ static int ocfs2_info_scan_inode_alloc(struct ocfs2_super *osb, · 282 unmodified lines
283	if (inode_alloc)	283	if (inode_alloc)
284	inode_lock(inode_alloc);	284	inode_lock(inode_alloc);
285		285
286	if (o2info_coherent(&fi->ifi_req)) {	286	if (inode_alloc && o2info_coherent(&fi->ifi_req)) {
287	status = ocfs2_inode_lock(inode_alloc, &bh, 0);	287	status = ocfs2_inode_lock(inode_alloc, &bh, 0);
288	if (status < 0) {	288	if (status < 0) {
289	mlog_errno(status);	289	mlog_errno(status);

fs/ocfs2/journal.c+2−1

@@ -217,7 +217,8 @@ void ocfs2_recovery_exit(struct ocfs2_super *osb) · 216 unmodified lines
217	/* At this point, we know that no more recovery threads can be	217	/* At this point, we know that no more recovery threads can be
218	* launched, so wait for any recovery completion work to	218	* launched, so wait for any recovery completion work to
219	* complete. */	219	* complete. */
220	flush_workqueue(osb->ocfs2_wq);	220	if (osb->ocfs2_wq)
		221	flush_workqueue(osb->ocfs2_wq);
221		222
222	/*	223	/*
223	* Now that recovery is shut down, and the osb is about to be	224	* Now that recovery is shut down, and the osb is about to be

fs/ocfs2/localalloc.c+2−1

@@ -377,7 +377,8 @@ void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb) · 376 unmodified lines
377	struct ocfs2_dinode *alloc = NULL;	377	struct ocfs2_dinode *alloc = NULL;
378		378
379	cancel_delayed_work(&osb->la_enable_wq);	379	cancel_delayed_work(&osb->la_enable_wq);
380	flush_workqueue(osb->ocfs2_wq);	380	if (osb->ocfs2_wq)
		381	flush_workqueue(osb->ocfs2_wq);
381		382
382	if (osb->local_alloc_state == OCFS2_LA_UNUSED)	383	if (osb->local_alloc_state == OCFS2_LA_UNUSED)
383	goto out;	384	goto out;

fs/ocfs2/xattr.c+23−33

@@ -1490,18 +1490,6 @@ static int ocfs2_xa_check_space(struct ocfs2_xa_loc *loc, · 1489 unmodified lines
1490	return loc->xl_ops->xlo_check_space(loc, xi);	1490	return loc->xl_ops->xlo_check_space(loc, xi);
1491	}	1491	}
1492		1492
1493	static void ocfs2_xa_add_entry(struct ocfs2_xa_loc *loc, u32 name_hash)
1494	{
1495	loc->xl_ops->xlo_add_entry(loc, name_hash);
1496	loc->xl_entry->xe_name_hash = cpu_to_le32(name_hash);
1497	/*
1498	* We can't leave the new entry's xe_name_offset at zero or
1499	* add_namevalue() will go nuts. We set it to the size of our
1500	* storage so that it can never be less than any other entry.
1501	*/
1502	loc->xl_entry->xe_name_offset = cpu_to_le16(loc->xl_size);
1503	}
1504
1505	static void ocfs2_xa_add_namevalue(struct ocfs2_xa_loc *loc,	1493	static void ocfs2_xa_add_namevalue(struct ocfs2_xa_loc *loc,
1506	struct ocfs2_xattr_info *xi)	1494	struct ocfs2_xattr_info *xi)
1507	{	1495	{
@@ -2133,29 +2121,31 @@ static int ocfs2_xa_prepare_entry(struct ocfs2_xa_loc *loc, · 625 unmodified lines
2133	if (rc)	2121	if (rc)
2134	goto out;	2122	goto out;
2135		2123
2136	if (loc->xl_entry) {	2124	if (!loc->xl_entry) {
2137	if (ocfs2_xa_can_reuse_entry(loc, xi)) {	2125	rc = -EINVAL;
2138	orig_value_size = loc->xl_entry->xe_value_size;	2126	goto out;
2139	rc = ocfs2_xa_reuse_entry(loc, xi, ctxt);	2127	}
2140	if (rc)
2141	goto out;
2142	goto alloc_value;
2143	}
2144		2128
2145	if (!ocfs2_xattr_is_local(loc->xl_entry)) {	2129	if (ocfs2_xa_can_reuse_entry(loc, xi)) {
2146	orig_clusters = ocfs2_xa_value_clusters(loc);	2130	orig_value_size = loc->xl_entry->xe_value_size;
2147	rc = ocfs2_xa_value_truncate(loc, 0, ctxt);	2131	rc = ocfs2_xa_reuse_entry(loc, xi, ctxt);
2148	if (rc) {	2132	if (rc)
2149	mlog_errno(rc);	2133	goto out;
2150	ocfs2_xa_cleanup_value_truncate(loc,	2134	goto alloc_value;
2151	"overwriting",	2135	}
2152	orig_clusters);	2136
2153	goto out;	2137	if (!ocfs2_xattr_is_local(loc->xl_entry)) {
2154	}	2138	orig_clusters = ocfs2_xa_value_clusters(loc);
		2139	rc = ocfs2_xa_value_truncate(loc, 0, ctxt);
		2140	if (rc) {
		2141	mlog_errno(rc);
		2142	ocfs2_xa_cleanup_value_truncate(loc,
		2143	"overwriting",
		2144	orig_clusters);
		2145	goto out;
2155	}	2146	}
2156	ocfs2_xa_wipe_namevalue(loc);	2147	}
2157	} else	2148	ocfs2_xa_wipe_namevalue(loc);
2158	ocfs2_xa_add_entry(loc, name_hash);
2159		2149
2160	/*	2150	/*
2161	* If we get here, we have a blank entry. Fill it. We grow our	2151	* If we get here, we have a blank entry. Fill it. We grow our

fs/proc/meminfo.c+2−2

@@ -132,9 +132,9 @@ static int meminfo_proc_show(struct seq_file m, void v) · 131 unmodified lines
132	global_node_page_state(NR_SHMEM_THPS) * HPAGE_PMD_NR);	132	global_node_page_state(NR_SHMEM_THPS) * HPAGE_PMD_NR);
133	show_val_kb(m, "ShmemPmdMapped: ",	133	show_val_kb(m, "ShmemPmdMapped: ",
134	global_node_page_state(NR_SHMEM_PMDMAPPED) * HPAGE_PMD_NR);	134	global_node_page_state(NR_SHMEM_PMDMAPPED) * HPAGE_PMD_NR);
135	show_val_kb(m, "FileHugePages: ",	135	show_val_kb(m, "FileHugePages: ",
136	global_node_page_state(NR_FILE_THPS) * HPAGE_PMD_NR);	136	global_node_page_state(NR_FILE_THPS) * HPAGE_PMD_NR);
137	show_val_kb(m, "FilePmdMapped: ",	137	show_val_kb(m, "FilePmdMapped: ",
138	global_node_page_state(NR_FILE_PMDMAPPED) * HPAGE_PMD_NR);	138	global_node_page_state(NR_FILE_PMDMAPPED) * HPAGE_PMD_NR);
139	#endif	139	#endif
140		140

fs/proc/page.c+16−12

@@ -42,10 +42,12 @@ static ssize_t kpagecount_read(struct file file, char __user buf, · 41 unmodified lines
42	return -EINVAL;	42	return -EINVAL;
43		43
44	while (count > 0) {	44	while (count > 0) {
45	if (pfn_valid(pfn))	45	/*
46	ppage = pfn_to_page(pfn);	46	* TODO: ZONE_DEVICE support requires to identify
47	else	47	* memmaps that were actually initialized.
48	ppage = NULL;	48	*/
		49	ppage = pfn_to_online_page(pfn);
		50
49	if (!ppage \|\| PageSlab(ppage) \|\| page_has_type(ppage))	51	if (!ppage \|\| PageSlab(ppage) \|\| page_has_type(ppage))
50	pcount = 0;	52	pcount = 0;
51	else	53	else
@@ -216,10 +218,11 @@ static ssize_t kpageflags_read(struct file file, char __user buf, · 164 unmodified lines
216	return -EINVAL;	218	return -EINVAL;
217		219
218	while (count > 0) {	220	while (count > 0) {
219	if (pfn_valid(pfn))	221	/*
220	ppage = pfn_to_page(pfn);	222	* TODO: ZONE_DEVICE support requires to identify
221	else	223	* memmaps that were actually initialized.
222	ppage = NULL;	224	*/
		225	ppage = pfn_to_online_page(pfn);
223		226
224	if (put_user(stable_page_flags(ppage), out)) {	227	if (put_user(stable_page_flags(ppage), out)) {
225	ret = -EFAULT;	228	ret = -EFAULT;
@@ -261,10 +264,11 @@ static ssize_t kpagecgroup_read(struct file file, char __user buf, · 35 unmodified lines
261	return -EINVAL;	264	return -EINVAL;
262		265
263	while (count > 0) {	266	while (count > 0) {
264	if (pfn_valid(pfn))	267	/*
265	ppage = pfn_to_page(pfn);	268	* TODO: ZONE_DEVICE support requires to identify
266	else	269	* memmaps that were actually initialized.
267	ppage = NULL;	270	*/
		271	ppage = pfn_to_online_page(pfn);
268		272
269	if (ppage)	273	if (ppage)
270	ino = page_cgroup_ino(ppage);	274	ino = page_cgroup_ino(ppage);

fs/readdir.c+4−44

@@ -27,53 +27,13 @@ · 26 unmodified lines
27	/*	27	/*
28	* Note the "unsafe_put_user() semantics: we goto a	28	* Note the "unsafe_put_user() semantics: we goto a
29	* label for errors.	29	* label for errors.
30	*
31	* Also note how we use a "while()" loop here, even though
32	* only the biggest size needs to loop. The compiler (well,
33	* at least gcc) is smart enough to turn the smaller sizes
34	* into just if-statements, and this way we don't need to
35	* care whether 'u64' or 'u32' is the biggest size.
36	*/
37	#define unsafe_copy_loop(dst, src, len, type, label) \
38	while (len >= sizeof(type)) { \
39	unsafe_put_user(get_unaligned((type *)src), \
40	(type __user *)dst, label); \
41	dst += sizeof(type); \
42	src += sizeof(type); \
43	len -= sizeof(type); \
44	}
45
46	/*
47	* We avoid doing 64-bit copies on 32-bit architectures. They
48	* might be better, but the component names are mostly small,
49	* and the 64-bit cases can end up being much more complex and
50	* put much more register pressure on the code, so it's likely
51	* not worth the pain of unaligned accesses etc.
52	*
53	* So limit the copies to "unsigned long" size. I did verify
54	* that at least the x86-32 case is ok without this limiting,
55	* but I worry about random other legacy 32-bit cases that
56	* might not do as well.
57	*/
58	#define unsafe_copy_type(dst, src, len, type, label) do { \
59	if (sizeof(type) <= sizeof(unsigned long)) \
60	unsafe_copy_loop(dst, src, len, type, label); \
61	} while (0)
62
63	/*
64	* Copy the dirent name to user space, and NUL-terminate
65	* it. This should not be a function call, since we're doing
66	* the copy inside a "user_access_begin/end()" section.
67	*/	30	*/
68	#define unsafe_copy_dirent_name(_dst, _src, _len, label) do { \	31	#define unsafe_copy_dirent_name(_dst, _src, _len, label) do { \
69	char __user *dst = (_dst); \	32	char __user *dst = (_dst); \
70	const char *src = (_src); \	33	const char *src = (_src); \
71	size_t len = (_len); \	34	size_t len = (_len); \
72	unsafe_copy_type(dst, src, len, u64, label); \	35	unsafe_put_user(0, dst+len, label); \
73	unsafe_copy_type(dst, src, len, u32, label); \	36	unsafe_copy_to_user(dst, src, len, label); \
74	unsafe_copy_type(dst, src, len, u16, label); \
75	unsafe_copy_type(dst, src, len, u8, label); \
76	unsafe_put_user(0, dst, label); \
77	} while (0)	37	} while (0)
78		38
79		39
@@ -145,9 +105,9 @@ EXPORT_SYMBOL(iterate_dir); · 65 unmodified lines
145	*/	105	*/
146	static int verify_dirent_name(const char *name, int len)	106	static int verify_dirent_name(const char *name, int len)
147	{	107	{
148	if (WARN_ON_ONCE(!len))	108	if (!len)
149	return -EIO;	109	return -EIO;
150	if (WARN_ON_ONCE(memchr(name, '/', len)))	110	if (memchr(name, '/', len))
151	return -EIO;	111	return -EIO;
152	return 0;	112	return 0;
153	}	113	}

fs/super.c+4−1

 	mutex_lock(&bdev->bd_fsfreeze_mutex);
 	if (bdev->bd_fsfreeze_count > 0) {
 		mutex_unlock(&bdev->bd_fsfreeze_mutex);
+		blkdev_put(bdev, mode);
 		warnf(fc, "%pg: Can't mount, blockdev is frozen", bdev);
 		return -EBUSY;
 	}
 	fc->sget_key = bdev;
 	s = sget_fc(fc, test_bdev_super_fc, set_bdev_super_fc);
 	mutex_unlock(&bdev->bd_fsfreeze_mutex);
-	if (IS_ERR(s))
+	if (IS_ERR(s)) {
+		blkdev_put(bdev, mode);
 		return PTR_ERR(s);
+	}
 	if (s->s_root) {
 		/* Don't summarily change the RO/RW state. */

fs/tracefs/inode.c+5−41

 #include <linux/namei.h>
 #include <linux/tracefs.h>
 #include <linux/fsnotify.h>
+#include <linux/security.h>
 #include <linux/seq_file.h>
 #include <linux/parser.h>
 #include <linux/magic.h>
 #include <linux/slab.h>
-#include <linux/security.h>
 #define TRACEFS_DEFAULT_MODE	0700
 static int tracefs_mount_count;
 static bool tracefs_registered;
-static int default_open_file(struct inode *inode, struct file *filp)
-{
-	struct dentry *dentry = filp->f_path.dentry;
-	struct file_operations *real_fops;
-	int ret;
-	if (!dentry)
-		return -EINVAL;
-	ret = security_locked_down(LOCKDOWN_TRACEFS);
-	if (ret)
-		return ret;
-	real_fops = dentry->d_fsdata;
-	if (!real_fops->open)
-		return 0;
-	return real_fops->open(inode, filp);
-}
 static ssize_t default_read_file(struct file *file, char __user *buf,
 				 size_t count, loff_t *ppos)
 {
 	return 0;
 }
-static void tracefs_destroy_inode(struct inode *inode)
-{
-	if (S_ISREG(inode->i_mode))
-		kfree(inode->i_fop);
-}
 static int tracefs_remount(struct super_block *sb, int *flags, char *data)
 {
 	int err;
 static const struct super_operations tracefs_super_operations = {
 	.statfs		= simple_statfs,
 	.remount_fs	= tracefs_remount,
-	.destroy_inode  = tracefs_destroy_inode,
 	.show_options	= tracefs_show_options,
 };
 				   struct dentry *parent, void *data,
 				   const struct file_operations *fops)
 {
-	struct file_operations *proxy_fops;
 	struct dentry *dentry;
 	struct inode *inode;
+	if (security_locked_down(LOCKDOWN_TRACEFS))
+		return NULL;
 	if (!(mode & S_IFMT))
 		mode |= S_IFREG;
 	BUG_ON(!S_ISREG(mode));
 	if (unlikely(!inode))
 		return failed_creating(dentry);
-	proxy_fops = kzalloc(sizeof(struct file_operations), GFP_KERNEL);
-	if (unlikely(!proxy_fops)) {
-		iput(inode);
-		return failed_creating(dentry);
-	}
-	if (!fops)
-		fops = &tracefs_file_operations;
-	dentry->d_fsdata = (void *)fops;
-	memcpy(proxy_fops, fops, sizeof(*proxy_fops));
-	proxy_fops->open = default_open_file;
 	inode->i_mode = mode;
-	inode->i_fop = proxy_fops;
+	inode->i_fop = fops ? fops : &tracefs_file_operations;
 	inode->i_private = data;
 	d_instantiate(dentry, inode);
 	fsnotify_create(dentry->d_parent->d_inode, dentry);

fs/xfs/libxfs/xfs_ag.c+2−3

 	struct xfs_mount	*mp,
 	xfs_daddr_t		blkno,
 	size_t			numblks,
-	int			flags,
 	const struct xfs_buf_ops *ops)
 {
 	struct xfs_buf		*bp;
-	bp = xfs_buf_get_uncached(mp->m_ddev_targp, numblks, flags);
+	bp = xfs_buf_get_uncached(mp->m_ddev_targp, numblks, 0);
 	if (!bp)
 		return NULL;
 {
 	struct xfs_buf		*bp;
-	bp = xfs_get_aghdr_buf(mp, id->daddr, id->numblks, 0, ops);
+	bp = xfs_get_aghdr_buf(mp, id->daddr, id->numblks, ops);
 	if (!bp)
 		return -ENOMEM;

fs/xfs/libxfs/xfs_attr_leaf.c+3−18

 	sf = (xfs_attr_shortform_t *)tmpbuffer;
 	xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
-	xfs_bmap_local_to_extents_empty(dp, XFS_ATTR_FORK);
+	xfs_bmap_local_to_extents_empty(args->trans, dp, XFS_ATTR_FORK);
 	bp = NULL;
 	error = xfs_da_grow_inode(args, &blkno);
-	if (error) {
+	if (error)
-		/*
-		 * If we hit an IO error middle of the transaction inside
-		 * grow_inode(), we may have inconsistent data. Bail out.
-		 */
-		if (error == -EIO)
-			goto out;
-		xfs_idata_realloc(dp, size, XFS_ATTR_FORK);	/* try to put */
-		memcpy(ifp->if_u1.if_data, tmpbuffer, size);	/* it back */
 		goto out;
-	}
 	ASSERT(blkno == 0);
 	error = xfs_attr3_leaf_create(args, blkno, &bp);
-	if (error) {
+	if (error)
-		/* xfs_attr3_leaf_create may not have instantiated a block */
-		if (bp && (xfs_da_shrink_inode(args, 0, bp) != 0))
-			goto out;
-		xfs_idata_realloc(dp, size, XFS_ATTR_FORK);	/* try to put */
-		memcpy(ifp->if_u1.if_data, tmpbuffer, size);	/* it back */
 		goto out;
-	}
 	memset((char *)&nargs, 0, sizeof(nargs));
 	nargs.dp = dp;

fs/xfs/libxfs/xfs_bmap.c+4−2

  */
 void
 xfs_bmap_local_to_extents_empty(
+	struct xfs_trans	*tp,
 	struct xfs_inode	*ip,
 	int			whichfork)
 {
 	ifp->if_u1.if_root = NULL;
 	ifp->if_height = 0;
 	XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS);
+	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 }
 	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
 	if (!ifp->if_bytes) {
-		xfs_bmap_local_to_extents_empty(ip, whichfork);
+		xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
 		flags = XFS_ILOG_CORE;
 		goto done;
 	}
 	/* account for the change in fork size */
 	xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);
-	xfs_bmap_local_to_extents_empty(ip, whichfork);
+	xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
 	flags |= XFS_ILOG_CORE;
 	ifp->if_u1.if_root = NULL;

fs/xfs/libxfs/xfs_bmap.h+2−1

 		xfs_filblks_t len);
 int	xfs_bmap_add_attrfork(struct xfs_inode *ip, int size, int rsvd);
 int	xfs_bmap_set_attrforkoff(struct xfs_inode *ip, int size, int *version);
-void	xfs_bmap_local_to_extents_empty(struct xfs_inode *ip, int whichfork);
+void	xfs_bmap_local_to_extents_empty(struct xfs_trans *tp,
+		struct xfs_inode *ip, int whichfork);
 void	__xfs_bmap_add_free(struct xfs_trans *tp, xfs_fsblock_t bno,
 		xfs_filblks_t len, const struct xfs_owner_info *oinfo,
 		bool skip_discard);

fs/xfs/libxfs/xfs_dir2_block.c+1−1

@@ -1096,7 +1096,7 @@ xfs_dir2_sf_to_block( · 1095 unmodified lines
1096	memcpy(sfp, oldsfp, ifp->if_bytes);	1096	memcpy(sfp, oldsfp, ifp->if_bytes);
1097		1097
1098	xfs_idata_realloc(dp, -ifp->if_bytes, XFS_DATA_FORK);	1098	xfs_idata_realloc(dp, -ifp->if_bytes, XFS_DATA_FORK);
1099	xfs_bmap_local_to_extents_empty(dp, XFS_DATA_FORK);	1099	xfs_bmap_local_to_extents_empty(tp, dp, XFS_DATA_FORK);
1100	dp->i_d.di_size = 0;	1100	dp->i_d.di_size = 0;
1101		1101
1102	/*	1102	/*

fs/xfs/libxfs/xfs_fs.h+4−4

@@ -366,11 +366,11 @@ struct xfs_bulkstat { · 365 unmodified lines
366	uint64_t bs_blocks; /* number of blocks */	366	uint64_t bs_blocks; /* number of blocks */
367	uint64_t bs_xflags; /* extended flags */	367	uint64_t bs_xflags; /* extended flags */
368		368
369	uint64_t bs_atime; /* access time, seconds */	369	int64_t bs_atime; /* access time, seconds */
370	uint64_t bs_mtime; /* modify time, seconds */	370	int64_t bs_mtime; /* modify time, seconds */
371		371
372	uint64_t bs_ctime; /* inode change time, seconds */	372	int64_t bs_ctime; /* inode change time, seconds */
373	uint64_t bs_btime; /* creation time, seconds */	373	int64_t bs_btime; /* creation time, seconds */
374		374
375	uint32_t bs_gen; /* generation count */	375	uint32_t bs_gen; /* generation count */
376	uint32_t bs_uid; /* user id */	376	uint32_t bs_uid; /* user id */

fs/xfs/scrub/refcount.c+1−2

 	xfs_extlen_t		len;
 	xfs_nlink_t		refcount;
 	bool			has_cowflag;
-	int			error = 0;
 	bno = be32_to_cpu(rec->refc.rc_startblock);
 	len = be32_to_cpu(rec->refc.rc_blockcount);
 	xchk_refcountbt_xref(bs->sc, bno, len, refcount);
-	return error;
+	return 0;
 }
 /* Make sure we have as many refc blocks as the rmap says. */

fs/xfs/xfs_bmap_util.c+3−1

 	xfs_filblks_t		allocatesize_fsb;
 	xfs_extlen_t		extsz, temp;
 	xfs_fileoff_t		startoffset_fsb;
+	xfs_fileoff_t		endoffset_fsb;
 	int			nimaps;
 	int			quota_flag;
 	int			rt;
 	imapp = &imaps[0];
 	nimaps = 1;
 	startoffset_fsb	= XFS_B_TO_FSBT(mp, offset);
-	allocatesize_fsb = XFS_B_TO_FSB(mp, count);
+	endoffset_fsb = XFS_B_TO_FSB(mp, offset + count);
+	allocatesize_fsb = endoffset_fsb - startoffset_fsb;
 	/*
 	 * Allocate file space until done or until there is an error

fs/xfs/xfs_buf.c+11−1

 	unsigned short		page_count, i;
 	xfs_off_t		start, end;
 	int			error;
+	xfs_km_flags_t		kmflag_mask = 0;
+	/*
+	 * assure zeroed buffer for non-read cases.
+	 */
+	if (!(flags & XBF_READ)) {
+		kmflag_mask |= KM_ZERO;
+		gfp_mask |= __GFP_ZERO;
+	}
 	/*
 	 * for buffers that are contained within a single page, just allocate
 	size = BBTOB(bp->b_length);
 	if (size < PAGE_SIZE) {
 		int align_mask = xfs_buftarg_dma_alignment(bp->b_target);
-		bp->b_addr = kmem_alloc_io(size, align_mask, KM_NOFS);
+		bp->b_addr = kmem_alloc_io(size, align_mask,
+					   KM_NOFS | kmflag_mask);
 		if (!bp->b_addr) {
 			/* low memory - use alloc_page loop instead */
 			goto use_alloc_page;

fs/xfs/xfs_log.c+1−1

@@ -1443,7 +1443,7 @@ xlog_alloc_log( · 1442 unmodified lines
1443	prev_iclog = iclog;	1443	prev_iclog = iclog;
1444		1444
1445	iclog->ic_data = kmem_alloc_io(log->l_iclog_size, align_mask,	1445	iclog->ic_data = kmem_alloc_io(log->l_iclog_size, align_mask,
1446	KM_MAYFAIL);	1446	KM_MAYFAIL \| KM_ZERO);
1447	if (!iclog->ic_data)	1447	if (!iclog->ic_data)
1448	goto out_free_iclog;	1448	goto out_free_iclog;
1449	#ifdef DEBUG	1449	#ifdef DEBUG

fs/xfs/xfs_log_recover.c+1−1

@@ -127,7 +127,7 @@ xlog_alloc_buffer( · 126 unmodified lines
127	if (nbblks > 1 && log->l_sectBBsize > 1)	127	if (nbblks > 1 && log->l_sectBBsize > 1)
128	nbblks += log->l_sectBBsize;	128	nbblks += log->l_sectBBsize;
129	nbblks = round_up(nbblks, log->l_sectBBsize);	129	nbblks = round_up(nbblks, log->l_sectBBsize);
130	return kmem_alloc_io(BBTOB(nbblks), align_mask, KM_MAYFAIL);	130	return kmem_alloc_io(BBTOB(nbblks), align_mask, KM_MAYFAIL \| KM_ZERO);
131	}	131	}
132		132
133	/*	133	/*

include/linux/bitmap.h+2−1

 }
 /**
- * bitmap_or_equal - Check whether the or of two bitnaps is equal to a third
+ * bitmap_or_equal - Check whether the or of two bitmaps is equal to a third
  * @src1:	Pointer to bitmap 1
  * @src2:	Pointer to bitmap 2 will be or'ed with bitmap 1
  * @src3:	Pointer to bitmap 3. Compare to the result of *@src1 | *@src2
+ * @nbits:	number of bits in each of these bitmaps
  *
  * Returns: True if (*@src1 | *@src2) == *@src3, false otherwise
  */

include/linux/compiler_attributes.h+17−0

@@ -40,6 +40,7 @@ · 39 unmodified lines
40	# define __GCC4_has_attribute___noclone__ 1	40	# define __GCC4_has_attribute___noclone__ 1
41	# define __GCC4_has_attribute___nonstring__ 0	41	# define __GCC4_has_attribute___nonstring__ 0
42	# define __GCC4_has_attribute___no_sanitize_address__ (__GNUC_MINOR__ >= 8)	42	# define __GCC4_has_attribute___no_sanitize_address__ (__GNUC_MINOR__ >= 8)
		43	# define __GCC4_has_attribute___fallthrough__ 0
43	#endif	44	#endif
44		45
45	/*	46	/*
@@ -185,6 +186,22 @@ · 139 unmodified lines
185	# define __noclone	186	# define __noclone
186	#endif	187	#endif
187		188
		189	/*
		190	* Add the pseudo keyword 'fallthrough' so case statement blocks
		191	* must end with any of these keywords:
		192	* break;
		193	* fallthrough;
		194	* goto <label>;
		195	* return [expression];
		196	*
		197	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Statement-Attributes.html#Statement-Attributes
		198	*/
		199	#if __has_attribute(__fallthrough__)
		200	# define fallthrough __attribute__((__fallthrough__))
		201	#else
		202	# define fallthrough do {} while (0) /* fallthrough */
		203	#endif
		204
188	/*	205	/*
189	* Note the missing underscores.	206	* Note the missing underscores.
190	*	207	*

include/linux/export.h+5−5

@@ -52,10 +52,10 @@ extern struct module __this_module; · 51 unmodified lines
52	__ADDRESSABLE(sym) \	52	__ADDRESSABLE(sym) \
53	asm(" .section \"___ksymtab" sec "+" #sym "\", \"a\" \n" \	53	asm(" .section \"___ksymtab" sec "+" #sym "\", \"a\" \n" \
54	" .balign 4 \n" \	54	" .balign 4 \n" \
55	"__ksymtab_" #sym NS_SEPARATOR #ns ": \n" \	55	"__ksymtab_" #ns NS_SEPARATOR #sym ": \n" \
56	" .long " #sym "- . \n" \	56	" .long " #sym "- . \n" \
57	" .long __kstrtab_" #sym "- . \n" \	57	" .long __kstrtab_" #sym "- . \n" \
58	" .long __kstrtab_ns_" #sym "- . \n" \	58	" .long __kstrtabns_" #sym "- . \n" \
59	" .previous \n")	59	" .previous \n")
60		60
61	#define __KSYMTAB_ENTRY(sym, sec) \	61	#define __KSYMTAB_ENTRY(sym, sec) \
@@ -76,10 +76,10 @@ struct kernel_symbol { · 14 unmodified lines
76	#else	76	#else
77	#define __KSYMTAB_ENTRY_NS(sym, sec, ns) \	77	#define __KSYMTAB_ENTRY_NS(sym, sec, ns) \
78	static const struct kernel_symbol __ksymtab_##sym##__##ns \	78	static const struct kernel_symbol __ksymtab_##sym##__##ns \
79	asm("__ksymtab_" #sym NS_SEPARATOR #ns) \	79	asm("__ksymtab_" #ns NS_SEPARATOR #sym) \
80	__attribute__((section("___ksymtab" sec "+" #sym), used)) \	80	__attribute__((section("___ksymtab" sec "+" #sym), used)) \
81	__aligned(sizeof(void *)) \	81	__aligned(sizeof(void *)) \
82	= { (unsigned long)&sym, __kstrtab_##sym, __kstrtab_ns_##sym }	82	= { (unsigned long)&sym, __kstrtab_##sym, __kstrtabns_##sym }
83		83
84	#define __KSYMTAB_ENTRY(sym, sec) \	84	#define __KSYMTAB_ENTRY(sym, sec) \
85	static const struct kernel_symbol __ksymtab_##sym \	85	static const struct kernel_symbol __ksymtab_##sym \
@@ -112,7 +112,7 @@ struct kernel_symbol { · 26 unmodified lines
112	/* For every exported symbol, place a struct in the __ksymtab section */	112	/* For every exported symbol, place a struct in the __ksymtab section */
113	#define ___EXPORT_SYMBOL_NS(sym, sec, ns) \	113	#define ___EXPORT_SYMBOL_NS(sym, sec, ns) \
114	___export_symbol_common(sym, sec); \	114	___export_symbol_common(sym, sec); \
115	static const char __kstrtab_ns_##sym[] \	115	static const char __kstrtabns_##sym[] \
116	__attribute__((section("__ksymtab_strings"), used, aligned(1))) \	116	__attribute__((section("__ksymtab_strings"), used, aligned(1))) \
117	= #ns; \	117	= #ns; \
118	__KSYMTAB_ENTRY_NS(sym, sec, ns)	118	__KSYMTAB_ENTRY_NS(sym, sec, ns)

include/linux/gpio/driver.h+8−0

@@ -201,6 +201,14 @@ struct gpio_irq_chip { · 200 unmodified lines
201	*/	201	*/
202	bool threaded;	202	bool threaded;
203		203
		204	/**
		205	* @init_hw: optional routine to initialize hardware before
		206	* an IRQ chip will be added. This is quite useful when
		207	* a particular driver wants to clear IRQ related registers
		208	* in order to avoid undesired events.
		209	*/
		210	int (init_hw)(struct gpio_chip chip);
		211
204	/**	212	/**
205	* @init_valid_mask: optional routine to initialize @valid_mask, to be	213	* @init_valid_mask: optional routine to initialize @valid_mask, to be
206	* used if not all GPIO lines are valid interrupts. Sometimes some	214	* used if not all GPIO lines are valid interrupts. Sometimes some

include/linux/hwmon.h+1−1

@@ -235,7 +235,7 @@ enum hwmon_power_attributes { · 234 unmodified lines
235	#define HWMON_P_LABEL BIT(hwmon_power_label)	235	#define HWMON_P_LABEL BIT(hwmon_power_label)
236	#define HWMON_P_ALARM BIT(hwmon_power_alarm)	236	#define HWMON_P_ALARM BIT(hwmon_power_alarm)
237	#define HWMON_P_CAP_ALARM BIT(hwmon_power_cap_alarm)	237	#define HWMON_P_CAP_ALARM BIT(hwmon_power_cap_alarm)
238	#define HWMON_P_MIN_ALARM BIT(hwmon_power_max_alarm)	238	#define HWMON_P_MIN_ALARM BIT(hwmon_power_min_alarm)
239	#define HWMON_P_MAX_ALARM BIT(hwmon_power_max_alarm)	239	#define HWMON_P_MAX_ALARM BIT(hwmon_power_max_alarm)
240	#define HWMON_P_LCRIT_ALARM BIT(hwmon_power_lcrit_alarm)	240	#define HWMON_P_LCRIT_ALARM BIT(hwmon_power_lcrit_alarm)
241	#define HWMON_P_CRIT_ALARM BIT(hwmon_power_crit_alarm)	241	#define HWMON_P_CRIT_ALARM BIT(hwmon_power_crit_alarm)

include/linux/leds.h+2−3

 /**
  * led_set_brightness_sync - set LED brightness synchronously
  * @led_cdev: the LED to set
- * @brightness: the brightness to set it to
+ * @value: the brightness to set it to
  *
  * Set an LED's brightness immediately. This function will block
  * the caller for the time required for accessing device registers,
 /**
  * led_compose_name - compose LED class device name
  * @dev: LED controller device object
- * @child: child fwnode_handle describing a LED or a group of synchronized LEDs;
+ * @init_data: the LED class device initialization data
- *	   it must be provided only for fwnode based LEDs
  * @led_classdev_name: composed LED class device name
  *
  * Create LED class device name basing on the provided init_data argument.

include/linux/memcontrol.h+29−0

 	return !cgroup_subsys_enabled(memory_cgrp_subsys);
 }
+static inline unsigned long mem_cgroup_protection(struct mem_cgroup *memcg,
+						  bool in_low_reclaim)
+{
+	if (mem_cgroup_disabled())
+		return 0;
+	if (in_low_reclaim)
+		return READ_ONCE(memcg->memory.emin);
+	return max(READ_ONCE(memcg->memory.emin),
+		   READ_ONCE(memcg->memory.elow));
+}
 enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root,
 						struct mem_cgroup *memcg);
 unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg);
+unsigned long mem_cgroup_size(struct mem_cgroup *memcg);
 void mem_cgroup_print_oom_context(struct mem_cgroup *memcg,
 				struct task_struct *p);
 {
 }
+static inline unsigned long mem_cgroup_protection(struct mem_cgroup *memcg,
+						  bool in_low_reclaim)
+{
+	return 0;
+}
 static inline enum mem_cgroup_protection mem_cgroup_protected(
 	struct mem_cgroup *root, struct mem_cgroup *memcg)
 {
 	return 0;
 }
+static inline unsigned long mem_cgroup_size(struct mem_cgroup *memcg)
+{
+	return 0;
+}
 static inline void
 mem_cgroup_print_oom_context(struct mem_cgroup *memcg, struct task_struct *p)
 {
 static inline void mem_cgroup_track_foreign_dirty(struct page *page,
 						  struct bdi_writeback *wb)
 {
+	if (mem_cgroup_disabled())
+		return;
 	if (unlikely(&page->mem_cgroup->css != wb->memcg_css))
 		mem_cgroup_track_foreign_dirty_slowpath(page, wb);
 }

include/linux/micrel_phy.h+1−1

@@ -31,7 +31,7 @@ · 30 unmodified lines
31	#define PHY_ID_KSZ886X 0x00221430	31	#define PHY_ID_KSZ886X 0x00221430
32	#define PHY_ID_KSZ8863 0x00221435	32	#define PHY_ID_KSZ8863 0x00221435
33		33
34	#define PHY_ID_KSZ8795 0x00221550	34	#define PHY_ID_KSZ87XX 0x00221550
35		35
36	#define PHY_ID_KSZ9477 0x00221631	36	#define PHY_ID_KSZ9477 0x00221631
37		37

include/linux/page_ext.h+9−1

 enum page_ext_flags {
 	PAGE_EXT_OWNER,
-	PAGE_EXT_OWNER_ACTIVE,
+	PAGE_EXT_OWNER_ALLOCATED,
 #if defined(CONFIG_IDLE_PAGE_TRACKING) && !defined(CONFIG_64BIT)
 	PAGE_EXT_YOUNG,
 	PAGE_EXT_IDLE,
 	unsigned long flags;
 };
+extern unsigned long page_ext_size;
 extern void pgdat_page_ext_init(struct pglist_data *pgdat);
 #ifdef CONFIG_SPARSEMEM
 struct page_ext *lookup_page_ext(const struct page *page);
+static inline struct page_ext *page_ext_next(struct page_ext *curr)
+{
+	void *next = curr;
+	next += page_ext_size;
+	return next;
+}
 #else /* !CONFIG_PAGE_EXTENSION */
 struct page_ext;

include/linux/platform_device.h+2−0

@@ -64,6 +64,8 @@ extern struct resource platform_get_resource_byname(struct platform_device , · 63 unmodified lines
64	unsigned int,	64	unsigned int,
65	const char *);	65	const char *);
66	extern int platform_get_irq_byname(struct platform_device , const char );	66	extern int platform_get_irq_byname(struct platform_device , const char );
		67	extern int platform_get_irq_byname_optional(struct platform_device *dev,
		68	const char *name);
67	extern int platform_add_devices(struct platform_device **, int);	69	extern int platform_add_devices(struct platform_device **, int);
68		70
69	struct platform_device_info {	71	struct platform_device_info {

include/linux/sched.h+1−0

@@ -223,6 +223,7 @@ extern long schedule_timeout_uninterruptible(long timeout); · 222 unmodified lines
223	extern long schedule_timeout_idle(long timeout);	223	extern long schedule_timeout_idle(long timeout);
224	asmlinkage void schedule(void);	224	asmlinkage void schedule(void);
225	extern void schedule_preempt_disabled(void);	225	extern void schedule_preempt_disabled(void);
		226	asmlinkage void preempt_schedule_irq(void);
226		227
227	extern int __must_check io_schedule_prepare(void);	228	extern int __must_check io_schedule_prepare(void);
228	extern void io_schedule_finish(int token);	229	extern void io_schedule_finish(int token);

include/linux/skbuff.h+3−2

 int __skb_vlan_pop(struct sk_buff *skb, u16 *vlan_tci);
 int skb_vlan_pop(struct sk_buff *skb);
 int skb_vlan_push(struct sk_buff *skb, __be16 vlan_proto, u16 vlan_tci);
-int skb_mpls_push(struct sk_buff *skb, __be32 mpls_lse, __be16 mpls_proto);
+int skb_mpls_push(struct sk_buff *skb, __be32 mpls_lse, __be16 mpls_proto,
-int skb_mpls_pop(struct sk_buff *skb, __be16 next_proto);
+		  int mac_len);
+int skb_mpls_pop(struct sk_buff *skb, __be16 next_proto, int mac_len);
 int skb_mpls_update_lse(struct sk_buff *skb, __be32 mpls_lse);
 int skb_mpls_dec_ttl(struct sk_buff *skb);
 struct sk_buff *pskb_extract(struct sk_buff *skb, int off, int to_copy,

include/linux/slab.h+4−0

  * kmalloc is the normal method of allocating memory
  * for objects smaller than page size in the kernel.
  *
+ * The allocated object address is aligned to at least ARCH_KMALLOC_MINALIGN
+ * bytes. For @size of power of two bytes, the alignment is also guaranteed
+ * to be at least to the size.
+ *
  * The @flags argument may be one of the GFP flags defined at
  * include/linux/gfp.h and described at
  * :ref:`Documentation/core-api/mm-api.rst <mm-api-gfp-flags>`

include/linux/string.h+20−1

@@ -227,7 +227,26 @@ static inline bool strstarts(const char str, const char prefix) · 226 unmodified lines
227	}	227	}
228		228
229	size_t memweight(const void *ptr, size_t bytes);	229	size_t memweight(const void *ptr, size_t bytes);
230	void memzero_explicit(void *s, size_t count);	230
		231	/**
		232	* memzero_explicit - Fill a region of memory (e.g. sensitive
		233	* keying data) with 0s.
		234	* @s: Pointer to the start of the area.
		235	* @count: The size of the area.
		236	*
		237	* Note: usually using memset() is just fine (!), but in cases
		238	* where clearing out _local_ data at the end of a scope is
		239	* necessary, memzero_explicit() should be used instead in
		240	* order to prevent the compiler from optimising away zeroing.
		241	*
		242	* memzero_explicit() doesn't need an arch-specific version as
		243	* it just invokes the one of memset() implicitly.
		244	*/
		245	static inline void memzero_explicit(void *s, size_t count)
		246	{
		247	memset(s, 0, count);
		248	barrier_data(s);
		249	}
231		250
232	/**	251	/**
233	* kbasename - return the last part of a pathname.	252	* kbasename - return the last part of a pathname.

include/linux/sunrpc/xprtsock.h+1−0

@@ -61,6 +61,7 @@ struct sock_xprt { · 60 unmodified lines
61	struct mutex recv_mutex;	61	struct mutex recv_mutex;
62	struct sockaddr_storage srcaddr;	62	struct sockaddr_storage srcaddr;
63	unsigned short srcport;	63	unsigned short srcport;
		64	int xprt_err;
64		65
65	/*	66	/*
66	* UDP socket buffer size parameters	67	* UDP socket buffer size parameters

include/linux/tcp.h+3−3

@@ -393,7 +393,7 @@ struct tcp_sock { · 392 unmodified lines
393	/* fastopen_rsk points to request_sock that resulted in this big	393	/* fastopen_rsk points to request_sock that resulted in this big
394	* socket. Used to retransmit SYNACKs etc.	394	* socket. Used to retransmit SYNACKs etc.
395	*/	395	*/
396	struct request_sock *fastopen_rsk;	396	struct request_sock __rcu *fastopen_rsk;
397	u32 *saved_syn;	397	u32 *saved_syn;
398	};	398	};
399		399
@@ -447,8 +447,8 @@ static inline struct tcp_timewait_sock tcp_twsk(const struct sock sk) · 47 unmodified lines
447		447
448	static inline bool tcp_passive_fastopen(const struct sock *sk)	448	static inline bool tcp_passive_fastopen(const struct sock *sk)
449	{	449	{
450	return (sk->sk_state == TCP_SYN_RECV &&	450	return sk->sk_state == TCP_SYN_RECV &&
451	tcp_sk(sk)->fastopen_rsk != NULL);	451	rcu_access_pointer(tcp_sk(sk)->fastopen_rsk) != NULL;
452	}	452	}
453		453
454	static inline void fastopen_queue_tune(struct sock *sk, int backlog)	454	static inline void fastopen_queue_tune(struct sock *sk, int backlog)

include/linux/tpm_eventlog.h+12−4

  * total. Once we've done this we know the offset of the data length field,
  * and can calculate the total size of the event.
  *
- * Return: size of the event on success, <0 on failure
+ * Return: size of the event on success, 0 on failure
  */
 static inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *event,
 	u16 halg;
 	int i;
 	int j;
+	u32 count, event_type;
 	marker = event;
 	marker_start = marker;
 	}
 	event = (struct tcg_pcr_event2_head *)mapping;
+	/*
+	 * The loop below will unmap these fields if the log is larger than
+	 * one page, so save them here for reference:
+	 */
+	count = READ_ONCE(event->count);
+	event_type = READ_ONCE(event->event_type);
 	efispecid = (struct tcg_efi_specid_event_head *)event_header->event;
 	/* Check if event is malformed. */
-	if (event->count > efispecid->num_algs) {
+	if (count > efispecid->num_algs) {
 		size = 0;
 		goto out;
 	}
-	for (i = 0; i < event->count; i++) {
+	for (i = 0; i < count; i++) {
 		halg_size = sizeof(event->digests[i].alg_id);
 		/* Map the digest's algorithm identifier */
 		+ event_field->event_size;
 	size = marker - marker_start;
-	if ((event->event_type == 0) && (event_field->event_size == 0))
+	if (event_type == 0 && event_field->event_size == 0)
 		size = 0;
 out:
 	if (do_mapping)
 		TPM_MEMUNMAP(mapping, mapping_size);

include/linux/uaccess.h+4−2

 #ifndef user_access_begin
 #define user_access_begin(ptr,len) access_ok(ptr, len)
 #define user_access_end() do { } while (0)
-#define unsafe_get_user(x, ptr, err) do { if (unlikely(__get_user(x, ptr))) goto err; } while (0)
+#define unsafe_op_wrap(op, err) do { if (unlikely(op)) goto err; } while (0)
-#define unsafe_put_user(x, ptr, err) do { if (unlikely(__put_user(x, ptr))) goto err; } while (0)
+#define unsafe_get_user(x,p,e) unsafe_op_wrap(__get_user(x,p),e)
+#define unsafe_put_user(x,p,e) unsafe_op_wrap(__put_user(x,p),e)
+#define unsafe_copy_to_user(d,s,l,e) unsafe_op_wrap(__copy_to_user(d,s,l),e)
 static inline unsigned long user_access_save(void) { return 0UL; }
 static inline void user_access_restore(unsigned long flags) { }
 #endif

include/linux/xarray.h+2−2

@@ -230,8 +230,8 @@ static inline int xa_err(void *entry) · 229 unmodified lines
230	* This structure is used either directly or via the XA_LIMIT() macro	230	* This structure is used either directly or via the XA_LIMIT() macro
231	* to communicate the range of IDs that are valid for allocation.	231	* to communicate the range of IDs that are valid for allocation.
232	* Two common ranges are predefined for you:	232	* Two common ranges are predefined for you:
233	* * xa_limit_32b - [0 - UINT_MAX]	233	* * xa_limit_32b - [0 - UINT_MAX]
234	* * xa_limit_31b - [0 - INT_MAX]	234	* * xa_limit_31b - [0 - INT_MAX]
235	*/	235	*/
236	struct xa_limit {	236	struct xa_limit {
237	u32 max;	237	u32 max;

include/net/cfg80211.h+8−0

@@ -5549,6 +5549,14 @@ const struct ieee80211_reg_rule freq_reg_info(struct wiphy wiphy, · 5548 unmodified lines
5549	*/	5549	*/
5550	const char *reg_initiator_name(enum nl80211_reg_initiator initiator);	5550	const char *reg_initiator_name(enum nl80211_reg_initiator initiator);
5551		5551
		5552	/**
		5553	* regulatory_pre_cac_allowed - check if pre-CAC allowed in the current regdom
		5554	* @wiphy: wiphy for which pre-CAC capability is checked.
		5555	*
		5556	* Pre-CAC is allowed only in some regdomains (notable ETSI).
		5557	*/
		5558	bool regulatory_pre_cac_allowed(struct wiphy *wiphy);
		5559
5552	/**	5560	/**
5553	* DOC: Internal regulatory db functions	5561	* DOC: Internal regulatory db functions
5554	*	5562	*

include/net/llc_conn.h+1−1

@@ -104,7 +104,7 @@ void llc_sk_reset(struct sock *sk); · 103 unmodified lines
104		104
105	/* Access to a connection */	105	/* Access to a connection */
106	int llc_conn_state_process(struct sock sk, struct sk_buff skb);	106	int llc_conn_state_process(struct sock sk, struct sk_buff skb);
107	int llc_conn_send_pdu(struct sock sk, struct sk_buff skb);	107	void llc_conn_send_pdu(struct sock sk, struct sk_buff skb);
108	void llc_conn_rtn_pdu(struct sock sk, struct sk_buff skb);	108	void llc_conn_rtn_pdu(struct sock sk, struct sk_buff skb);
109	void llc_conn_resend_i_pdu_as_cmd(struct sock *sk, u8 nr, u8 first_p_bit);	109	void llc_conn_resend_i_pdu_as_cmd(struct sock *sk, u8 nr, u8 first_p_bit);
110	void llc_conn_resend_i_pdu_as_rsp(struct sock *sk, u8 nr, u8 first_f_bit);	110	void llc_conn_resend_i_pdu_as_rsp(struct sock *sk, u8 nr, u8 first_f_bit);

include/net/net_namespace.h+17−8

 #define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
 struct net {
+	/* First cache line can be often dirtied.
+	 * Do not place here read-mostly fields.
+	 */
 	refcount_t		passive;	/* To decide when the network
 						 * namespace should be freed.
 						 */
 						 */
 	spinlock_t		rules_mod_lock;
-	u32			hash_mix;
+	unsigned int		dev_unreg_count;
+	unsigned int		dev_base_seq;	/* protected by rtnl_mutex */
+	int			ifindex;
+	spinlock_t		nsid_lock;
+	atomic_t		fnhe_genid;
 	struct list_head	list;		/* list of network namespaces */
 	struct list_head	exit_list;	/* To linked to call pernet exit
 #endif
 	struct user_namespace   *user_ns;	/* Owning user namespace */
 	struct ucounts		*ucounts;
-	spinlock_t		nsid_lock;
 	struct idr		netns_ids;
 	struct ns_common	ns;
+	struct list_head 	dev_base_head;
 	struct proc_dir_entry 	*proc_net;
 	struct proc_dir_entry 	*proc_net_stat;
 	struct uevent_sock	*uevent_sock;		/* uevent socket */
-	struct list_head 	dev_base_head;
 	struct hlist_head 	*dev_name_head;
 	struct hlist_head	*dev_index_head;
-	unsigned int		dev_base_seq;	/* protected by rtnl_mutex */
+	/* Note that @hash_mix can be read millions times per second,
-	int			ifindex;
+	 * it is critical that it is on a read_mostly cache line.
-	unsigned int		dev_unreg_count;
+	 */
+	u32			hash_mix;
+	struct net_device       *loopback_dev;          /* The loopback */
 	/* core fib_rules */
 	struct list_head	rules_ops;
-	struct net_device       *loopback_dev;          /* The loopback */
 	struct netns_core	core;
 	struct netns_mib	mib;
 	struct netns_packet	packet;
 	struct sock		*crypto_nlsk;
 #endif
 	struct sock		*diag_nlsk;
-	atomic_t		fnhe_genid;
 } __randomize_layout;
 #include <linux/seq_file_net.h>

include/net/request_sock.h+2−2

@@ -185,7 +185,7 @@ void reqsk_fastopen_remove(struct sock sk, struct request_sock req, · 184 unmodified lines
185		185
186	static inline bool reqsk_queue_empty(const struct request_sock_queue *queue)	186	static inline bool reqsk_queue_empty(const struct request_sock_queue *queue)
187	{	187	{
188	return queue->rskq_accept_head == NULL;	188	return READ_ONCE(queue->rskq_accept_head) == NULL;
189	}	189	}
190		190
191	static inline struct request_sock reqsk_queue_remove(struct request_sock_queue queue,	191	static inline struct request_sock reqsk_queue_remove(struct request_sock_queue queue,
@@ -197,7 +197,7 @@ static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue · 5 unmodified lines
197	req = queue->rskq_accept_head;	197	req = queue->rskq_accept_head;
198	if (req) {	198	if (req) {
199	sk_acceptq_removed(parent);	199	sk_acceptq_removed(parent);
200	queue->rskq_accept_head = req->dl_next;	200	WRITE_ONCE(queue->rskq_accept_head, req->dl_next);
201	if (queue->rskq_accept_head == NULL)	201	if (queue->rskq_accept_head == NULL)
202	queue->rskq_accept_tail = NULL;	202	queue->rskq_accept_tail = NULL;
203	}	203	}

include/net/sctp/sctp.h+5−0

@@ -610,4 +610,9 @@ static inline __u32 sctp_min_frag_point(struct sctp_sock *sp, __u16 datasize) · 609 unmodified lines
610	return sctp_mtu_payload(sp, SCTP_DEFAULT_MINSEGMENT, datasize);	610	return sctp_mtu_payload(sp, SCTP_DEFAULT_MINSEGMENT, datasize);
611	}	611	}
612		612
		613	static inline bool sctp_newsk_ready(const struct sock *sk)
		614	{
		615	return sock_flag(sk, SOCK_DEAD) \|\| sk->sk_socket;
		616	}
		617
613	#endif /* __net_sctp_h__ */	618	#endif /* __net_sctp_h__ */

include/net/sock.h+22−11

@@ -878,12 +878,17 @@ static inline bool sk_acceptq_is_full(const struct sock *sk) · 877 unmodified lines
878	*/	878	*/
879	static inline int sk_stream_min_wspace(const struct sock *sk)	879	static inline int sk_stream_min_wspace(const struct sock *sk)
880	{	880	{
881	return sk->sk_wmem_queued >> 1;	881	return READ_ONCE(sk->sk_wmem_queued) >> 1;
882	}	882	}
883		883
884	static inline int sk_stream_wspace(const struct sock *sk)	884	static inline int sk_stream_wspace(const struct sock *sk)
885	{	885	{
886	return sk->sk_sndbuf - sk->sk_wmem_queued;	886	return READ_ONCE(sk->sk_sndbuf) - READ_ONCE(sk->sk_wmem_queued);
		887	}
		888
		889	static inline void sk_wmem_queued_add(struct sock *sk, int val)
		890	{
		891	WRITE_ONCE(sk->sk_wmem_queued, sk->sk_wmem_queued + val);
887	}	892	}
888		893
889	void sk_stream_write_space(struct sock *sk);	894	void sk_stream_write_space(struct sock *sk);
@@ -1207,7 +1212,7 @@ static inline void sk_refcnt_debug_release(const struct sock *sk) · 317 unmodified lines
1207		1212
1208	static inline bool __sk_stream_memory_free(const struct sock *sk, int wake)	1213	static inline bool __sk_stream_memory_free(const struct sock *sk, int wake)
1209	{	1214	{
1210	if (sk->sk_wmem_queued >= sk->sk_sndbuf)	1215	if (READ_ONCE(sk->sk_wmem_queued) >= READ_ONCE(sk->sk_sndbuf))
1211	return false;	1216	return false;
1212		1217
1213	return sk->sk_prot->stream_memory_free ?	1218	return sk->sk_prot->stream_memory_free ?
@@ -1467,7 +1472,7 @@ DECLARE_STATIC_KEY_FALSE(tcp_tx_skb_cache_key); · 253 unmodified lines
1467	static inline void sk_wmem_free_skb(struct sock sk, struct sk_buff skb)	1472	static inline void sk_wmem_free_skb(struct sock sk, struct sk_buff skb)
1468	{	1473	{
1469	sock_set_flag(sk, SOCK_QUEUE_SHRUNK);	1474	sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
1470	sk->sk_wmem_queued -= skb->truesize;	1475	sk_wmem_queued_add(sk, -skb->truesize);
1471	sk_mem_uncharge(sk, skb->truesize);	1476	sk_mem_uncharge(sk, skb->truesize);
1472	if (static_branch_unlikely(&tcp_tx_skb_cache_key) &&	1477	if (static_branch_unlikely(&tcp_tx_skb_cache_key) &&
1473	!sk->sk_tx_skb_cache && !skb_cloned(skb)) {	1478	!sk->sk_tx_skb_cache && !skb_cloned(skb)) {
@@ -2014,7 +2019,7 @@ static inline int skb_copy_to_page_nocache(struct sock sk, struct iov_iter fro · 540 unmodified lines
2014	skb->len += copy;	2019	skb->len += copy;
2015	skb->data_len += copy;	2020	skb->data_len += copy;
2016	skb->truesize += copy;	2021	skb->truesize += copy;
2017	sk->sk_wmem_queued += copy;	2022	sk_wmem_queued_add(sk, copy);
2018	sk_mem_charge(sk, copy);	2023	sk_mem_charge(sk, copy);
2019	return 0;	2024	return 0;
2020	}	2025	}
@@ -2220,10 +2225,14 @@ static inline void sk_wake_async(const struct sock *sk, int how, int band) · 199 unmodified lines
2220		2225
2221	static inline void sk_stream_moderate_sndbuf(struct sock *sk)	2226	static inline void sk_stream_moderate_sndbuf(struct sock *sk)
2222	{	2227	{
2223	if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {	2228	u32 val;
2224	sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);	2229
2225	sk->sk_sndbuf = max_t(u32, sk->sk_sndbuf, SOCK_MIN_SNDBUF);	2230	if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
2226	}	2231	return;
		2232
		2233	val = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
		2234
		2235	WRITE_ONCE(sk->sk_sndbuf, max_t(u32, val, SOCK_MIN_SNDBUF));
2227	}	2236	}
2228		2237
2229	struct sk_buff sk_stream_alloc_skb(struct sock sk, int size, gfp_t gfp,	2238	struct sk_buff sk_stream_alloc_skb(struct sock sk, int size, gfp_t gfp,
@@ -2251,7 +2260,7 @@ bool sk_page_frag_refill(struct sock sk, struct page_frag pfrag); · 21 unmodified lines
2251	*/	2260	*/
2252	static inline bool sock_writeable(const struct sock *sk)	2261	static inline bool sock_writeable(const struct sock *sk)
2253	{	2262	{
2254	return refcount_read(&sk->sk_wmem_alloc) < (sk->sk_sndbuf >> 1);	2263	return refcount_read(&sk->sk_wmem_alloc) < (READ_ONCE(sk->sk_sndbuf) >> 1);
2255	}	2264	}
2256		2265
2257	static inline gfp_t gfp_any(void)	2266	static inline gfp_t gfp_any(void)
@@ -2271,7 +2280,9 @@ static inline long sock_sndtimeo(const struct sock *sk, bool noblock) · 13 unmodified lines
2271		2280
2272	static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)	2281	static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)
2273	{	2282	{
2274	return (waitall ? len : min_t(int, sk->sk_rcvlowat, len)) ? : 1;	2283	int v = waitall ? len : min_t(int, READ_ONCE(sk->sk_rcvlowat), len);
		2284
		2285	return v ?: 1;
2275	}	2286	}
2276		2287
2277	/* Alas, with timeout socket operations are not restartable.	2288	/* Alas, with timeout socket operations are not restartable.

include/net/tcp.h+6−4

 	    mem_cgroup_under_socket_pressure(sk->sk_memcg))
 		return true;
-	return tcp_memory_pressure;
+	return READ_ONCE(tcp_memory_pressure);
 }
 /*
  * The next routines deal with comparing 32 bit unsigned ints
 /* Note: caller must be prepared to deal with negative returns */
 static inline int tcp_space(const struct sock *sk)
 {
-	return tcp_win_from_space(sk, sk->sk_rcvbuf - sk->sk_backlog.len -
+	return tcp_win_from_space(sk, READ_ONCE(sk->sk_rcvbuf) -
+				  READ_ONCE(sk->sk_backlog.len) -
 				  atomic_read(&sk->sk_rmem_alloc));
 }
 static inline int tcp_full_space(const struct sock *sk)
 {
-	return tcp_win_from_space(sk, sk->sk_rcvbuf);
+	return tcp_win_from_space(sk, READ_ONCE(sk->sk_rcvbuf));
 }
 extern void tcp_openreq_init_rwin(struct request_sock *req,
 static inline bool tcp_stream_memory_free(const struct sock *sk, int wake)
 {
 	const struct tcp_sock *tp = tcp_sk(sk);
-	u32 notsent_bytes = tp->write_seq - tp->snd_nxt;
+	u32 notsent_bytes = READ_ONCE(tp->write_seq) -
+			    READ_ONCE(tp->snd_nxt);
 	return (notsent_bytes << wake) < tcp_notsent_lowat(tp);
 }

include/scsi/scsi_eh.h+1−0

@@ -32,6 +32,7 @@ extern int scsi_ioctl_reset(struct scsi_device , int __user ); · 31 unmodified lines
32	struct scsi_eh_save {	32	struct scsi_eh_save {
33	/* saved state */	33	/* saved state */
34	int result;	34	int result;
		35	unsigned int resid_len;
35	int eh_eflags;	36	int eh_eflags;
36	enum dma_data_direction data_direction;	37	enum dma_data_direction data_direction;
37	unsigned underflow;	38	unsigned underflow;

include/sound/hda_register.h+3−0

@@ -264,6 +264,9 @@ enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 }; · 263 unmodified lines
264	#define AZX_REG_ML_LOUTPAY 0x20	264	#define AZX_REG_ML_LOUTPAY 0x20
265	#define AZX_REG_ML_LINPAY 0x30	265	#define AZX_REG_ML_LINPAY 0x30
266		266
		267	/* bit0 is reserved, with BIT(1) mapping to stream1 */
		268	#define ML_LOSIDV_STREAM_MASK 0xFFFE
		269
267	#define ML_LCTL_SCF_MASK 0xF	270	#define ML_LCTL_SCF_MASK 0xF
268	#define AZX_MLCTL_SPA (0x1 << 16)	271	#define AZX_MLCTL_SPA (0x1 << 16)
269	#define AZX_MLCTL_CPA (0x1 << 23)	272	#define AZX_MLCTL_CPA (0x1 << 23)

include/trace/events/rxrpc.h+9−9

@@ -519,10 +519,10 @@ TRACE_EVENT(rxrpc_local, · 518 unmodified lines
519	);	519	);
520		520
521	TRACE_EVENT(rxrpc_peer,	521	TRACE_EVENT(rxrpc_peer,
522	TP_PROTO(struct rxrpc_peer *peer, enum rxrpc_peer_trace op,	522	TP_PROTO(unsigned int peer_debug_id, enum rxrpc_peer_trace op,
523	int usage, const void *where),	523	int usage, const void *where),
524		524
525	TP_ARGS(peer, op, usage, where),	525	TP_ARGS(peer_debug_id, op, usage, where),
526		526
527	TP_STRUCT__entry(	527	TP_STRUCT__entry(
528	__field(unsigned int, peer )	528	__field(unsigned int, peer )
@@ -532,7 +532,7 @@ TRACE_EVENT(rxrpc_peer, · 3 unmodified lines
532	),	532	),
533		533
534	TP_fast_assign(	534	TP_fast_assign(
535	__entry->peer = peer->debug_id;	535	__entry->peer = peer_debug_id;
536	__entry->op = op;	536	__entry->op = op;
537	__entry->usage = usage;	537	__entry->usage = usage;
538	__entry->where = where;	538	__entry->where = where;
@@ -546,10 +546,10 @@ TRACE_EVENT(rxrpc_peer, · 7 unmodified lines
546	);	546	);
547		547
548	TRACE_EVENT(rxrpc_conn,	548	TRACE_EVENT(rxrpc_conn,
549	TP_PROTO(struct rxrpc_connection *conn, enum rxrpc_conn_trace op,	549	TP_PROTO(unsigned int conn_debug_id, enum rxrpc_conn_trace op,
550	int usage, const void *where),	550	int usage, const void *where),
551		551
552	TP_ARGS(conn, op, usage, where),	552	TP_ARGS(conn_debug_id, op, usage, where),
553		553
554	TP_STRUCT__entry(	554	TP_STRUCT__entry(
555	__field(unsigned int, conn )	555	__field(unsigned int, conn )
@@ -559,7 +559,7 @@ TRACE_EVENT(rxrpc_conn, · 3 unmodified lines
559	),	559	),
560		560
561	TP_fast_assign(	561	TP_fast_assign(
562	__entry->conn = conn->debug_id;	562	__entry->conn = conn_debug_id;
563	__entry->op = op;	563	__entry->op = op;
564	__entry->usage = usage;	564	__entry->usage = usage;
565	__entry->where = where;	565	__entry->where = where;
@@ -606,10 +606,10 @@ TRACE_EVENT(rxrpc_client, · 40 unmodified lines
606	);	606	);
607		607
608	TRACE_EVENT(rxrpc_call,	608	TRACE_EVENT(rxrpc_call,
609	TP_PROTO(struct rxrpc_call *call, enum rxrpc_call_trace op,	609	TP_PROTO(unsigned int call_debug_id, enum rxrpc_call_trace op,
610	int usage, const void where, const void aux),	610	int usage, const void where, const void aux),
611		611
612	TP_ARGS(call, op, usage, where, aux),	612	TP_ARGS(call_debug_id, op, usage, where, aux),
613		613
614	TP_STRUCT__entry(	614	TP_STRUCT__entry(
615	__field(unsigned int, call )	615	__field(unsigned int, call )
@@ -620,7 +620,7 @@ TRACE_EVENT(rxrpc_call, · 4 unmodified lines
620	),	620	),
621		621
622	TP_fast_assign(	622	TP_fast_assign(
623	__entry->call = call->debug_id;	623	__entry->call = call_debug_id;
624	__entry->op = op;	624	__entry->op = op;
625	__entry->usage = usage;	625	__entry->usage = usage;
626	__entry->where = where;	626	__entry->where = where;

include/trace/events/sock.h+2−2

@@ -82,7 +82,7 @@ TRACE_EVENT(sock_rcvqueue_full, · 81 unmodified lines
82	TP_fast_assign(	82	TP_fast_assign(
83	__entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc);	83	__entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc);
84	__entry->truesize = skb->truesize;	84	__entry->truesize = skb->truesize;
85	__entry->sk_rcvbuf = sk->sk_rcvbuf;	85	__entry->sk_rcvbuf = READ_ONCE(sk->sk_rcvbuf);
86	),	86	),
87		87
88	TP_printk("rmem_alloc=%d truesize=%u sk_rcvbuf=%d",	88	TP_printk("rmem_alloc=%d truesize=%u sk_rcvbuf=%d",
@@ -115,7 +115,7 @@ TRACE_EVENT(sock_exceed_buf_limit, · 26 unmodified lines
115	__entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc);	115	__entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc);
116	__entry->sysctl_wmem = sk_get_wmem0(sk, prot);	116	__entry->sysctl_wmem = sk_get_wmem0(sk, prot);
117	__entry->wmem_alloc = refcount_read(&sk->sk_wmem_alloc);	117	__entry->wmem_alloc = refcount_read(&sk->sk_wmem_alloc);
118	__entry->wmem_queued = sk->sk_wmem_queued;	118	__entry->wmem_queued = READ_ONCE(sk->sk_wmem_queued);
119	__entry->kind = kind;	119	__entry->kind = kind;
120	),	120	),
121		121

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

@@ -291,6 +291,6 @@ · 290 unmodified lines
291	#define PORT_SUNIX 121	291	#define PORT_SUNIX 121
292		292
293	/* Freescale Linflex UART */	293	/* Freescale Linflex UART */
294	#define PORT_LINFLEXUART 121	294	#define PORT_LINFLEXUART 122
295		295
296	#endif /* _UAPILINUX_SERIAL_CORE_H */	296	#endif /* _UAPILINUX_SERIAL_CORE_H */

kernel/events/core.c+36−7

@@ -3779,11 +3779,23 @@ static void rotate_ctx(struct perf_event_context ctx, struct perf_event event) · 3778 unmodified lines
3779	perf_event_groups_insert(&ctx->flexible_groups, event);	3779	perf_event_groups_insert(&ctx->flexible_groups, event);
3780	}	3780	}
3781		3781
		3782	/* pick an event from the flexible_groups to rotate */
3782	static inline struct perf_event *	3783	static inline struct perf_event *
3783	ctx_first_active(struct perf_event_context *ctx)	3784	ctx_event_to_rotate(struct perf_event_context *ctx)
3784	{	3785	{
3785	return list_first_entry_or_null(&ctx->flexible_active,	3786	struct perf_event *event;
3786	struct perf_event, active_list);	3787
		3788	/* pick the first active flexible event */
		3789	event = list_first_entry_or_null(&ctx->flexible_active,
		3790	struct perf_event, active_list);
		3791
		3792	/* if no active flexible event, pick the first event */
		3793	if (!event) {
		3794	event = rb_entry_safe(rb_first(&ctx->flexible_groups.tree),
		3795	typeof(*event), group_node);
		3796	}
		3797
		3798	return event;
3787	}	3799	}
3788		3800
3789	static bool perf_rotate_context(struct perf_cpu_context *cpuctx)	3801	static bool perf_rotate_context(struct perf_cpu_context *cpuctx)
@@ -3808,9 +3820,9 @@ static bool perf_rotate_context(struct perf_cpu_context *cpuctx) · 18 unmodified lines
3808	perf_pmu_disable(cpuctx->ctx.pmu);	3820	perf_pmu_disable(cpuctx->ctx.pmu);
3809		3821
3810	if (task_rotate)	3822	if (task_rotate)
3811	task_event = ctx_first_active(task_ctx);	3823	task_event = ctx_event_to_rotate(task_ctx);
3812	if (cpu_rotate)	3824	if (cpu_rotate)
3813	cpu_event = ctx_first_active(&cpuctx->ctx);	3825	cpu_event = ctx_event_to_rotate(&cpuctx->ctx);
3814		3826
3815	/*	3827	/*
3816	* As per the order given at ctx_resched() first 'pop' task flexible	3828	* As per the order given at ctx_resched() first 'pop' task flexible
@@ -5668,7 +5680,8 @@ again: · 1851 unmodified lines
5668	* undo the VM accounting.	5680	* undo the VM accounting.
5669	*/	5681	*/
5670		5682
5671	atomic_long_sub((size >> PAGE_SHIFT) + 1, &mmap_user->locked_vm);	5683	atomic_long_sub((size >> PAGE_SHIFT) + 1 - mmap_locked,
		5684	&mmap_user->locked_vm);
5672	atomic64_sub(mmap_locked, &vma->vm_mm->pinned_vm);	5685	atomic64_sub(mmap_locked, &vma->vm_mm->pinned_vm);
5673	free_uid(mmap_user);	5686	free_uid(mmap_user);
5674		5687
@@ -5812,8 +5825,20 @@ accounting: · 137 unmodified lines
5812		5825
5813	user_locked = atomic_long_read(&user->locked_vm) + user_extra;	5826	user_locked = atomic_long_read(&user->locked_vm) + user_extra;
5814		5827
5815	if (user_locked > user_lock_limit)	5828	if (user_locked <= user_lock_limit) {
		5829	/* charge all to locked_vm */
		5830	} else if (atomic_long_read(&user->locked_vm) >= user_lock_limit) {
		5831	/* charge all to pinned_vm */
		5832	extra = user_extra;
		5833	user_extra = 0;
		5834	} else {
		5835	/*
		5836	* charge locked_vm until it hits user_lock_limit;
		5837	* charge the rest from pinned_vm
		5838	*/
5816	extra = user_locked - user_lock_limit;	5839	extra = user_locked - user_lock_limit;
		5840	user_extra -= extra;
		5841	}
5817		5842
5818	lock_limit = rlimit(RLIMIT_MEMLOCK);	5843	lock_limit = rlimit(RLIMIT_MEMLOCK);
5819	lock_limit >>= PAGE_SHIFT;	5844	lock_limit >>= PAGE_SHIFT;
@@ -11862,6 +11887,10 @@ static int inherit_group(struct perf_event *parent_event, · 6042 unmodified lines
11862	child, leader, child_ctx);	11887	child, leader, child_ctx);
11863	if (IS_ERR(child_ctr))	11888	if (IS_ERR(child_ctr))
11864	return PTR_ERR(child_ctr);	11889	return PTR_ERR(child_ctr);
		11890
		11891	if (sub->aux_event == parent_event &&
		11892	!perf_get_aux_event(child_ctr, leader))
		11893	return -EINVAL;
11865	}	11894	}
11866	return 0;	11895	return 0;
11867	}	11896	}

kernel/events/uprobes.c+11−2

 	struct vm_area_struct *vma;
 	int ret, is_register, ref_ctr_updated = 0;
 	bool orig_page_huge = false;
+	unsigned int gup_flags = FOLL_FORCE;
 	is_register = is_swbp_insn(&opcode);
 	uprobe = container_of(auprobe, struct uprobe, arch);
 retry:
+	if (is_register)
+		gup_flags |= FOLL_SPLIT_PMD;
 	/* Read the page with vaddr into memory */
-	ret = get_user_pages_remote(NULL, mm, vaddr, 1,
+	ret = get_user_pages_remote(NULL, mm, vaddr, 1, gup_flags,
-			FOLL_FORCE | FOLL_SPLIT_PMD, &old_page, &vma, NULL);
+				    &old_page, &vma, NULL);
 	if (ret <= 0)
 		return ret;
 	if (ret <= 0)
 		goto put_old;
+	if (WARN(!is_register && PageCompound(old_page),
+		 "uprobe unregister should never work on compound page\n")) {
+		ret = -EINVAL;
+		goto put_old;
+	}
 	/* We are going to replace instruction, update ref_ctr. */
 	if (!ref_ctr_updated && uprobe->ref_ctr_offset) {
 		ret = update_ref_ctr(uprobe, mm, is_register ? 1 : -1);

kernel/fork.c+2−2

@@ -2925,7 +2925,7 @@ int sysctl_max_threads(struct ctl_table *table, int write, · 2924 unmodified lines
2925	struct ctl_table t;	2925	struct ctl_table t;
2926	int ret;	2926	int ret;
2927	int threads = max_threads;	2927	int threads = max_threads;
2928	int min = MIN_THREADS;	2928	int min = 1;
2929	int max = MAX_THREADS;	2929	int max = MAX_THREADS;
2930		2930
2931	t = *table;	2931	t = *table;
@@ -2937,7 +2937,7 @@ int sysctl_max_threads(struct ctl_table *table, int write, · 5 unmodified lines
2937	if (ret \|\| !write)	2937	if (ret \|\| !write)
2938	return ret;	2938	return ret;
2939		2939
2940	set_max_threads(threads);	2940	max_threads = threads;
2941		2941
2942	return 0;	2942	return 0;
2943	}	2943	}

kernel/freezer.c+0−6

 bool pm_freezing;
 bool pm_nosig_freezing;
-/*
- * Temporary export for the deadlock workaround in ata_scsi_hotplug().
- * Remove once the hack becomes unnecessary.
- */
-EXPORT_SYMBOL_GPL(pm_freezing);
 /* protects freezing and frozen transitions */
 static DEFINE_SPINLOCK(freezer_lock);

kernel/gen_kheaders.sh+7−4

 find $cpio_dir -type f -print0 |
 	xargs -0 -P8 -n1 perl -pi -e 'BEGIN {undef $/;}; s/\/\*((?!SPDX).)*?\*\///smg;'
-# Create archive and try to normalize metadata for reproducibility
+# Create archive and try to normalize metadata for reproducibility.
-tar "${KBUILD_BUILD_TIMESTAMP:+--mtime=$KBUILD_BUILD_TIMESTAMP}" \
+# For compatibility with older versions of tar, files are fed to tar
-    --owner=0 --group=0 --sort=name --numeric-owner \
+# pre-sorted, as --sort=name might not be available.
-    -Jcf $tarfile -C $cpio_dir/ . > /dev/null
+find $cpio_dir -printf "./%P\n" | LC_ALL=C sort | \
+    tar "${KBUILD_BUILD_TIMESTAMP:+--mtime=$KBUILD_BUILD_TIMESTAMP}" \
+    --owner=0 --group=0 --numeric-owner --no-recursion \
+    -Jcf $tarfile -C $cpio_dir/ -T - > /dev/null
 echo "$src_files_md5" >  kernel/kheaders.md5
 echo "$obj_files_md5" >> kernel/kheaders.md5

kernel/kthread.c+3−3

@@ -866,9 +866,9 @@ void kthread_delayed_work_timer_fn(struct timer_list *t) · 865 unmodified lines
866	}	866	}
867	EXPORT_SYMBOL(kthread_delayed_work_timer_fn);	867	EXPORT_SYMBOL(kthread_delayed_work_timer_fn);
868		868
869	void __kthread_queue_delayed_work(struct kthread_worker *worker,	869	static void __kthread_queue_delayed_work(struct kthread_worker *worker,
870	struct kthread_delayed_work *dwork,	870	struct kthread_delayed_work *dwork,
871	unsigned long delay)	871	unsigned long delay)
872	{	872	{
873	struct timer_list *timer = &dwork->timer;	873	struct timer_list *timer = &dwork->timer;
874	struct kthread_work *work = &dwork->work;	874	struct kthread_work *work = &dwork->work;

kernel/panic.c+1−0

@@ -180,6 +180,7 @@ void panic(const char *fmt, ...) · 179 unmodified lines
180	* after setting panic_cpu) from invoking panic() again.	180	* after setting panic_cpu) from invoking panic() again.
181	*/	181	*/
182	local_irq_disable();	182	local_irq_disable();
		183	preempt_disable_notrace();
183		184
184	/*	185	/*
185	* It's possible to come here directly from a panic-assertion and	186	* It's possible to come here directly from a panic-assertion and

kernel/power/main.c+1−0

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	#include <linux/seq_file.h>	15	#include <linux/seq_file.h>
16	#include <linux/suspend.h>	16	#include <linux/suspend.h>
17	#include <linux/syscalls.h>	17	#include <linux/syscalls.h>
		18	#include <linux/pm_runtime.h>
18		19
19	#include "power.h"	20	#include "power.h"
20		21

kernel/sched/cputime.c+3−3

kernel/sched/fair.c+22−14

@@ -4926,20 +4926,28 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer) · 4925 unmodified lines
4926	if (++count > 3) {	4926	if (++count > 3) {
4927	u64 new, old = ktime_to_ns(cfs_b->period);	4927	u64 new, old = ktime_to_ns(cfs_b->period);
4928		4928
4929	new = (old * 147) / 128; /* ~115% */	4929	/*
4930	new = min(new, max_cfs_quota_period);	4930	* Grow period by a factor of 2 to avoid losing precision.
4931		4931	* Precision loss in the quota/period ratio can cause __cfs_schedulable
4932	cfs_b->period = ns_to_ktime(new);	4932	* to fail.
4933		4933	*/
4934	/* since max is 1s, this is limited to 1e9^2, which fits in u64 */	4934	new = old * 2;
4935	cfs_b->quota *= new;	4935	if (new < max_cfs_quota_period) {
4936	cfs_b->quota = div64_u64(cfs_b->quota, old);	4936	cfs_b->period = ns_to_ktime(new);
4937		4937	cfs_b->quota *= 2;
4938	pr_warn_ratelimited(	4938
4939	"cfs_period_timer[cpu%d]: period too short, scaling up (new cfs_period_us %lld, cfs_quota_us = %lld)\n",	4939	pr_warn_ratelimited(
4940	smp_processor_id(),	4940	"cfs_period_timer[cpu%d]: period too short, scaling up (new cfs_period_us = %lld, cfs_quota_us = %lld)\n",
4941	div_u64(new, NSEC_PER_USEC),	4941	smp_processor_id(),
4942	div_u64(cfs_b->quota, NSEC_PER_USEC));	4942	div_u64(new, NSEC_PER_USEC),
		4943	div_u64(cfs_b->quota, NSEC_PER_USEC));
		4944	} else {
		4945	pr_warn_ratelimited(
		4946	"cfs_period_timer[cpu%d]: period too short, but cannot scale up without losing precision (cfs_period_us = %lld, cfs_quota_us = %lld)\n",
		4947	smp_processor_id(),
		4948	div_u64(old, NSEC_PER_USEC),
		4949	div_u64(cfs_b->quota, NSEC_PER_USEC));
		4950	}
4943		4951
4944	/* reset count so we don't come right back in here */	4952	/* reset count so we don't come right back in here */
4945	count = 0;	4953	count = 0;

kernel/stop_machine.c+6−4

  * Copyright (C) 2010		SUSE Linux Products GmbH
  * Copyright (C) 2010		Tejun Heo <tj@kernel.org>
  */
+#include <linux/compiler.h>
 #include <linux/completion.h>
 #include <linux/cpu.h>
 #include <linux/init.h>
 	/* Reset ack counter. */
 	atomic_set(&msdata->thread_ack, msdata->num_threads);
 	smp_wmb();
-	msdata->state = newstate;
+	WRITE_ONCE(msdata->state, newstate);
 }
 /* Last one to ack a state moves to the next state. */
 static int multi_cpu_stop(void *data)
 {
 	struct multi_stop_data *msdata = data;
-	enum multi_stop_state curstate = MULTI_STOP_NONE;
+	enum multi_stop_state newstate, curstate = MULTI_STOP_NONE;
 	int cpu = smp_processor_id(), err = 0;
 	const struct cpumask *cpumask;
 	unsigned long flags;
 	do {
 		/* Chill out and ensure we re-read multi_stop_state. */
 		stop_machine_yield(cpumask);
-		if (msdata->state != curstate) {
+		newstate = READ_ONCE(msdata->state);
-			curstate = msdata->state;
+		if (newstate != curstate) {
+			curstate = newstate;
 			switch (curstate) {
 			case MULTI_STOP_DISABLE_IRQ:
 				local_irq_disable();

kernel/sysctl.c+2−2

@@ -163,7 +163,7 @@ static unsigned long hung_task_timeout_max = (LONG_MAX/HZ); · 162 unmodified lines
163	#ifdef CONFIG_SPARC	163	#ifdef CONFIG_SPARC
164	#endif	164	#endif
165		165
166	#ifdef __hppa__	166	#ifdef CONFIG_PARISC
167	extern int pwrsw_enabled;	167	extern int pwrsw_enabled;
168	#endif	168	#endif
169		169
@@ -620,7 +620,7 @@ static struct ctl_table kern_table[] = { · 450 unmodified lines
620	.proc_handler = proc_dointvec,	620	.proc_handler = proc_dointvec,
621	},	621	},
622	#endif	622	#endif
623	#ifdef __hppa__	623	#ifdef CONFIG_PARISC
624	{	624	{
625	.procname = "soft-power",	625	.procname = "soft-power",
626	.data = &pwrsw_enabled,	626	.data = &pwrsw_enabled,

kernel/time/hrtimer.c+4−4

@@ -164,7 +164,7 @@ struct hrtimer_clock_base lock_hrtimer_base(const struct hrtimer timer, · 163 unmodified lines
164	struct hrtimer_clock_base *base;	164	struct hrtimer_clock_base *base;
165		165
166	for (;;) {	166	for (;;) {
167	base = timer->base;	167	base = READ_ONCE(timer->base);
168	if (likely(base != &migration_base)) {	168	if (likely(base != &migration_base)) {
169	raw_spin_lock_irqsave(&base->cpu_base->lock, *flags);	169	raw_spin_lock_irqsave(&base->cpu_base->lock, *flags);
170	if (likely(base == timer->base))	170	if (likely(base == timer->base))
@@ -244,7 +244,7 @@ again: · 73 unmodified lines
244	return base;	244	return base;
245		245
246	/* See the comment in lock_hrtimer_base() */	246	/* See the comment in lock_hrtimer_base() */
247	timer->base = &migration_base;	247	WRITE_ONCE(timer->base, &migration_base);
248	raw_spin_unlock(&base->cpu_base->lock);	248	raw_spin_unlock(&base->cpu_base->lock);
249	raw_spin_lock(&new_base->cpu_base->lock);	249	raw_spin_lock(&new_base->cpu_base->lock);
250		250
@@ -253,10 +253,10 @@ again: · 2 unmodified lines
253	raw_spin_unlock(&new_base->cpu_base->lock);	253	raw_spin_unlock(&new_base->cpu_base->lock);
254	raw_spin_lock(&base->cpu_base->lock);	254	raw_spin_lock(&base->cpu_base->lock);
255	new_cpu_base = this_cpu_base;	255	new_cpu_base = this_cpu_base;
256	timer->base = base;	256	WRITE_ONCE(timer->base, base);
257	goto again;	257	goto again;
258	}	258	}
259	timer->base = new_base;	259	WRITE_ONCE(timer->base, new_base);
260	} else {	260	} else {
261	if (new_cpu_base != this_cpu_base &&	261	if (new_cpu_base != this_cpu_base &&
262	hrtimer_check_target(timer, new_base)) {	262	hrtimer_check_target(timer, new_base)) {

kernel/trace/ftrace.c+43−12

 #include <linux/clocksource.h>
 #include <linux/sched/task.h>
 #include <linux/kallsyms.h>
+#include <linux/security.h>
 #include <linux/seq_file.h>
 #include <linux/tracefs.h>
 #include <linux/hardirq.h>
 ftrace_avail_open(struct inode *inode, struct file *file)
 {
 	struct ftrace_iterator *iter;
+	int ret;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	if (unlikely(ftrace_disabled))
 		return -ENODEV;
 {
 	struct ftrace_iterator *iter;
+	/*
+	 * This shows us what functions are currently being
+	 * traced and by what. Not sure if we want lockdown
+	 * to hide such critical information for an admin.
+	 * Although, perhaps it can show information we don't
+	 * want people to see, but if something is tracing
+	 * something, we probably want to know about it.
+	 */
 	iter = __seq_open_private(file, &show_ftrace_seq_ops, sizeof(*iter));
 	if (!iter)
 		return -ENOMEM;
 	struct ftrace_hash *hash;
 	struct list_head *mod_head;
 	struct trace_array *tr = ops->private;
-	int ret = 0;
+	int ret = -ENOMEM;
 	ftrace_ops_init(ops);
 	if (unlikely(ftrace_disabled))
 		return -ENODEV;
+	if (tracing_check_open_get_tr(tr))
+		return -ENODEV;
 	iter = kzalloc(sizeof(*iter), GFP_KERNEL);
 	if (!iter)
-		return -ENOMEM;
+		goto out;
-	if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX)) {
+	if (trace_parser_get_init(&iter->parser, FTRACE_BUFF_MAX))
-		kfree(iter);
+		goto out;
-		return -ENOMEM;
-	}
 	iter->ops = ops;
 	iter->flags = flag;
 		if (!iter->hash) {
 			trace_parser_put(&iter->parser);
-			kfree(iter);
-			ret = -ENOMEM;
 			goto out_unlock;
 		}
 	} else
 		iter->hash = hash;
+	ret = 0;
 	if (file->f_mode & FMODE_READ) {
 		iter->pg = ftrace_pages_start;
 			/* Failed */
 			free_ftrace_hash(iter->hash);
 			trace_parser_put(&iter->parser);
-			kfree(iter);
 		}
 	} else
 		file->private_data = iter;
  out_unlock:
 	mutex_unlock(&ops->func_hash->regex_lock);
+ out:
+	if (ret) {
+		kfree(iter);
+		if (tr)
+			trace_array_put(tr);
+	}
 	return ret;
 }
 {
 	struct ftrace_ops *ops = inode->i_private;
+	/* Checks for tracefs lockdown */
 	return ftrace_regex_open(ops,
 			FTRACE_ITER_FILTER | FTRACE_ITER_DO_PROBES,
 			inode, file);
 {
 	struct ftrace_ops *ops = inode->i_private;
+	/* Checks for tracefs lockdown */
 	return ftrace_regex_open(ops, FTRACE_ITER_NOTRACE,
 				 inode, file);
 }
 	mutex_unlock(&iter->ops->func_hash->regex_lock);
 	free_ftrace_hash(iter->hash);
+	if (iter->tr)
+		trace_array_put(iter->tr);
 	kfree(iter);
 	return 0;
 __ftrace_graph_open(struct inode *inode, struct file *file,
 		    struct ftrace_graph_data *fgd)
 {
-	int ret = 0;
+	int ret;
 	struct ftrace_hash *new_hash = NULL;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	if (file->f_mode & FMODE_WRITE) {
 		const int size_bits = FTRACE_HASH_DEFAULT_BITS;
 	struct seq_file *m;
 	int ret = 0;
-	if (trace_array_get(tr) < 0)
+	ret = tracing_check_open_get_tr(tr);
-		return -ENODEV;
+	if (ret)
+		return ret;
 	if ((file->f_mode & FMODE_WRITE) &&
 	    (file->f_flags & O_TRUNC))

kernel/trace/trace.c+87−52

@@ -17,6 +17,7 @@ · 16 unmodified lines
17	#include <linux/stacktrace.h>	17	#include <linux/stacktrace.h>
18	#include <linux/writeback.h>	18	#include <linux/writeback.h>
19	#include <linux/kallsyms.h>	19	#include <linux/kallsyms.h>
		20	#include <linux/security.h>
20	#include <linux/seq_file.h>	21	#include <linux/seq_file.h>
21	#include <linux/notifier.h>	22	#include <linux/notifier.h>
22	#include <linux/irqflags.h>	23	#include <linux/irqflags.h>
@@ -304,6 +305,23 @@ void trace_array_put(struct trace_array *this_tr) · 281 unmodified lines
304	mutex_unlock(&trace_types_lock);	305	mutex_unlock(&trace_types_lock);
305	}	306	}
306		307
		308	int tracing_check_open_get_tr(struct trace_array *tr)
		309	{
		310	int ret;
		311
		312	ret = security_locked_down(LOCKDOWN_TRACEFS);
		313	if (ret)
		314	return ret;
		315
		316	if (tracing_disabled)
		317	return -ENODEV;
		318
		319	if (tr && trace_array_get(tr) < 0)
		320	return -ENODEV;
		321
		322	return 0;
		323	}
		324
307	int call_filter_check_discard(struct trace_event_call call, void rec,	325	int call_filter_check_discard(struct trace_event_call call, void rec,
308	struct ring_buffer *buffer,	326	struct ring_buffer *buffer,
309	struct ring_buffer_event *event)	327	struct ring_buffer_event *event)
@@ -4140,8 +4158,11 @@ release: · 3830 unmodified lines
4140		4158
4141	int tracing_open_generic(struct inode inode, struct file filp)	4159	int tracing_open_generic(struct inode inode, struct file filp)
4142	{	4160	{
4143	if (tracing_disabled)	4161	int ret;
4144	return -ENODEV;	4162
		4163	ret = tracing_check_open_get_tr(NULL);
		4164	if (ret)
		4165	return ret;
4145		4166
4146	filp->private_data = inode->i_private;	4167	filp->private_data = inode->i_private;
4147	return 0;	4168	return 0;
@@ -4156,15 +4177,14 @@ bool tracing_is_disabled(void) · 8 unmodified lines
4156	* Open and update trace_array ref count.	4177	* Open and update trace_array ref count.
4157	* Must have the current trace_array passed to it.	4178	* Must have the current trace_array passed to it.
4158	*/	4179	*/
4159	static int tracing_open_generic_tr(struct inode inode, struct file filp)	4180	int tracing_open_generic_tr(struct inode inode, struct file filp)
4160	{	4181	{
4161	struct trace_array *tr = inode->i_private;	4182	struct trace_array *tr = inode->i_private;
		4183	int ret;
4162		4184
4163	if (tracing_disabled)	4185	ret = tracing_check_open_get_tr(tr);
4164	return -ENODEV;	4186	if (ret)
4165		4187	return ret;
4166	if (trace_array_get(tr) < 0)
4167	return -ENODEV;
4168		4188
4169	filp->private_data = inode->i_private;	4189	filp->private_data = inode->i_private;
4170		4190
@@ -4233,10 +4253,11 @@ static int tracing_open(struct inode inode, struct file file) · 62 unmodified lines
4233	{	4253	{
4234	struct trace_array *tr = inode->i_private;	4254	struct trace_array *tr = inode->i_private;
4235	struct trace_iterator *iter;	4255	struct trace_iterator *iter;
4236	int ret = 0;	4256	int ret;
4237		4257
4238	if (trace_array_get(tr) < 0)	4258	ret = tracing_check_open_get_tr(tr);
4239	return -ENODEV;	4259	if (ret)
		4260	return ret;
4240		4261
4241	/* If this file was open for write, then erase contents */	4262	/* If this file was open for write, then erase contents */
4242	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {	4263	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
@@ -4352,12 +4373,15 @@ static int show_traces_open(struct inode inode, struct file file) · 109 unmodified lines
4352	struct seq_file *m;	4373	struct seq_file *m;
4353	int ret;	4374	int ret;
4354		4375
4355	if (tracing_disabled)	4376	ret = tracing_check_open_get_tr(tr);
4356	return -ENODEV;	4377	if (ret)
		4378	return ret;
4357		4379
4358	ret = seq_open(file, &show_traces_seq_ops);	4380	ret = seq_open(file, &show_traces_seq_ops);
4359	if (ret)	4381	if (ret) {
		4382	trace_array_put(tr);
4360	return ret;	4383	return ret;
		4384	}
4361		4385
4362	m = file->private_data;	4386	m = file->private_data;
4363	m->private = tr;	4387	m->private = tr;
@@ -4365,6 +4389,14 @@ static int show_traces_open(struct inode inode, struct file file) · 1 unmodified line
4365	return 0;	4389	return 0;
4366	}	4390	}
4367		4391
		4392	static int show_traces_release(struct inode inode, struct file file)
		4393	{
		4394	struct trace_array *tr = inode->i_private;
		4395
		4396	trace_array_put(tr);
		4397	return seq_release(inode, file);
		4398	}
		4399
4368	static ssize_t	4400	static ssize_t
4369	tracing_write_stub(struct file filp, const char __user ubuf,	4401	tracing_write_stub(struct file filp, const char __user ubuf,
4370	size_t count, loff_t *ppos)	4402	size_t count, loff_t *ppos)
@@ -4395,8 +4427,8 @@ static const struct file_operations tracing_fops = { · 24 unmodified lines
4395	static const struct file_operations show_traces_fops = {	4427	static const struct file_operations show_traces_fops = {
4396	.open = show_traces_open,	4428	.open = show_traces_open,
4397	.read = seq_read,	4429	.read = seq_read,
4398	.release = seq_release,
4399	.llseek = seq_lseek,	4430	.llseek = seq_lseek,
		4431	.release = show_traces_release,
4400	};	4432	};
4401		4433
4402	static ssize_t	4434	static ssize_t
@@ -4697,11 +4729,9 @@ static int tracing_trace_options_open(struct inode inode, struct file file) · 294 unmodified lines
4697	struct trace_array *tr = inode->i_private;	4729	struct trace_array *tr = inode->i_private;
4698	int ret;	4730	int ret;
4699		4731
4700	if (tracing_disabled)	4732	ret = tracing_check_open_get_tr(tr);
4701	return -ENODEV;	4733	if (ret)
4702		4734	return ret;
4703	if (trace_array_get(tr) < 0)
4704	return -ENODEV;
4705		4735
4706	ret = single_open(file, tracing_trace_options_show, inode->i_private);	4736	ret = single_open(file, tracing_trace_options_show, inode->i_private);
4707	if (ret < 0)	4737	if (ret < 0)
@@ -5038,8 +5068,11 @@ static const struct seq_operations tracing_saved_tgids_seq_ops = { · 330 unmodified lines
5038		5068
5039	static int tracing_saved_tgids_open(struct inode inode, struct file filp)	5069	static int tracing_saved_tgids_open(struct inode inode, struct file filp)
5040	{	5070	{
5041	if (tracing_disabled)	5071	int ret;
5042	return -ENODEV;	5072
		5073	ret = tracing_check_open_get_tr(NULL);
		5074	if (ret)
		5075	return ret;
5043		5076
5044	return seq_open(filp, &tracing_saved_tgids_seq_ops);	5077	return seq_open(filp, &tracing_saved_tgids_seq_ops);
5045	}	5078	}
@@ -5115,8 +5148,11 @@ static const struct seq_operations tracing_saved_cmdlines_seq_ops = { · 69 unmodified lines
5115		5148
5116	static int tracing_saved_cmdlines_open(struct inode inode, struct file filp)	5149	static int tracing_saved_cmdlines_open(struct inode inode, struct file filp)
5117	{	5150	{
5118	if (tracing_disabled)	5151	int ret;
5119	return -ENODEV;	5152
		5153	ret = tracing_check_open_get_tr(NULL);
		5154	if (ret)
		5155	return ret;
5120		5156
5121	return seq_open(filp, &tracing_saved_cmdlines_seq_ops);	5157	return seq_open(filp, &tracing_saved_cmdlines_seq_ops);
5122	}	5158	}
@@ -5280,8 +5316,11 @@ static const struct seq_operations tracing_eval_map_seq_ops = { · 157 unmodified lines
5280		5316
5281	static int tracing_eval_map_open(struct inode inode, struct file filp)	5317	static int tracing_eval_map_open(struct inode inode, struct file filp)
5282	{	5318	{
5283	if (tracing_disabled)	5319	int ret;
5284	return -ENODEV;	5320
		5321	ret = tracing_check_open_get_tr(NULL);
		5322	if (ret)
		5323	return ret;
5285		5324
5286	return seq_open(filp, &tracing_eval_map_seq_ops);	5325	return seq_open(filp, &tracing_eval_map_seq_ops);
5287	}	5326	}
@@ -5804,13 +5843,11 @@ static int tracing_open_pipe(struct inode inode, struct file filp) · 516 unmodified lines
5804	{	5843	{
5805	struct trace_array *tr = inode->i_private;	5844	struct trace_array *tr = inode->i_private;
5806	struct trace_iterator *iter;	5845	struct trace_iterator *iter;
5807	int ret = 0;	5846	int ret;
5808
5809	if (tracing_disabled)
5810	return -ENODEV;
5811		5847
5812	if (trace_array_get(tr) < 0)	5848	ret = tracing_check_open_get_tr(tr);
5813	return -ENODEV;	5849	if (ret)
		5850	return ret;
5814		5851
5815	mutex_lock(&trace_types_lock);	5852	mutex_lock(&trace_types_lock);
5816		5853
@@ -5999,6 +6036,7 @@ waitagain: · 182 unmodified lines
5999	sizeof(struct trace_iterator) -	6036	sizeof(struct trace_iterator) -
6000	offsetof(struct trace_iterator, seq));	6037	offsetof(struct trace_iterator, seq));
6001	cpumask_clear(iter->started);	6038	cpumask_clear(iter->started);
		6039	trace_seq_init(&iter->seq);
6002	iter->pos = -1;	6040	iter->pos = -1;
6003		6041
6004	trace_event_read_lock();	6042	trace_event_read_lock();
@@ -6547,11 +6585,9 @@ static int tracing_clock_open(struct inode inode, struct file file) · 542 unmodified lines
6547	struct trace_array *tr = inode->i_private;	6585	struct trace_array *tr = inode->i_private;
6548	int ret;	6586	int ret;
6549		6587
6550	if (tracing_disabled)	6588	ret = tracing_check_open_get_tr(tr);
6551	return -ENODEV;	6589	if (ret)
6552		6590	return ret;
6553	if (trace_array_get(tr))
6554	return -ENODEV;
6555		6591
6556	ret = single_open(file, tracing_clock_show, inode->i_private);	6592	ret = single_open(file, tracing_clock_show, inode->i_private);
6557	if (ret < 0)	6593	if (ret < 0)
@@ -6581,11 +6617,9 @@ static int tracing_time_stamp_mode_open(struct inode inode, struct file file) · 23 unmodified lines
6581	struct trace_array *tr = inode->i_private;	6617	struct trace_array *tr = inode->i_private;
6582	int ret;	6618	int ret;
6583		6619
6584	if (tracing_disabled)	6620	ret = tracing_check_open_get_tr(tr);
6585	return -ENODEV;	6621	if (ret)
6586		6622	return ret;
6587	if (trace_array_get(tr))
6588	return -ENODEV;
6589		6623
6590	ret = single_open(file, tracing_time_stamp_mode_show, inode->i_private);	6624	ret = single_open(file, tracing_time_stamp_mode_show, inode->i_private);
6591	if (ret < 0)	6625	if (ret < 0)
@@ -6638,10 +6672,11 @@ static int tracing_snapshot_open(struct inode inode, struct file file) · 46 unmodified lines
6638	struct trace_array *tr = inode->i_private;	6672	struct trace_array *tr = inode->i_private;
6639	struct trace_iterator *iter;	6673	struct trace_iterator *iter;
6640	struct seq_file *m;	6674	struct seq_file *m;
6641	int ret = 0;	6675	int ret;
6642		6676
6643	if (trace_array_get(tr) < 0)	6677	ret = tracing_check_open_get_tr(tr);
6644	return -ENODEV;	6678	if (ret)
		6679	return ret;
6645		6680
6646	if (file->f_mode & FMODE_READ) {	6681	if (file->f_mode & FMODE_READ) {
6647	iter = __tracing_open(inode, file, true);	6682	iter = __tracing_open(inode, file, true);
@@ -6786,6 +6821,7 @@ static int snapshot_raw_open(struct inode inode, struct file filp) · 138 unmodified lines
6786	struct ftrace_buffer_info *info;	6821	struct ftrace_buffer_info *info;
6787	int ret;	6822	int ret;
6788		6823
		6824	/* The following checks for tracefs lockdown */
6789	ret = tracing_buffers_open(inode, filp);	6825	ret = tracing_buffers_open(inode, filp);
6790	if (ret < 0)	6826	if (ret < 0)
6791	return ret;	6827	return ret;
@@ -7105,8 +7141,9 @@ static int tracing_err_log_open(struct inode inode, struct file file) · 313 unmodified lines
7105	struct trace_array *tr = inode->i_private;	7141	struct trace_array *tr = inode->i_private;
7106	int ret = 0;	7142	int ret = 0;
7107		7143
7108	if (trace_array_get(tr) < 0)	7144	ret = tracing_check_open_get_tr(tr);
7109	return -ENODEV;	7145	if (ret)
		7146	return ret;
7110		7147
7111	/* If this file was opened for write, then erase contents */	7148	/* If this file was opened for write, then erase contents */
7112	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC))	7149	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC))
@@ -7157,11 +7194,9 @@ static int tracing_buffers_open(struct inode inode, struct file filp) · 44 unmodified lines
7157	struct ftrace_buffer_info *info;	7194	struct ftrace_buffer_info *info;
7158	int ret;	7195	int ret;
7159		7196
7160	if (tracing_disabled)	7197	ret = tracing_check_open_get_tr(tr);
7161	return -ENODEV;	7198	if (ret)
7162		7199	return ret;
7163	if (trace_array_get(tr) < 0)
7164	return -ENODEV;
7165		7200
7166	info = kzalloc(sizeof(*info), GFP_KERNEL);	7201	info = kzalloc(sizeof(*info), GFP_KERNEL);
7167	if (!info) {	7202	if (!info) {

kernel/trace/trace.h+2−0

 extern int trace_array_get(struct trace_array *tr);
 extern void trace_array_put(struct trace_array *tr);
+extern int tracing_check_open_get_tr(struct trace_array *tr);
 extern int tracing_set_time_stamp_abs(struct trace_array *tr, bool abs);
 extern int tracing_set_clock(struct trace_array *tr, const char *clockstr);
 void tracing_reset_current(int cpu);
 void tracing_reset_all_online_cpus(void);
 int tracing_open_generic(struct inode *inode, struct file *filp);
+int tracing_open_generic_tr(struct inode *inode, struct file *filp);
 bool tracing_is_disabled(void);
 bool tracer_tracing_is_on(struct trace_array *tr);
 void tracer_tracing_on(struct trace_array *tr);

kernel/trace/trace_dynevent.c+4−0

 {
 	int ret;
+	ret = tracing_check_open_get_tr(NULL);
+	if (ret)
+		return ret;
 	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
 		ret = dyn_events_release_all(NULL);
 		if (ret < 0)

kernel/trace/trace_events.c+17−18

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#define pr_fmt(fmt) fmt	12	#define pr_fmt(fmt) fmt
13		13
14	#include <linux/workqueue.h>	14	#include <linux/workqueue.h>
		15	#include <linux/security.h>
15	#include <linux/spinlock.h>	16	#include <linux/spinlock.h>
16	#include <linux/kthread.h>	17	#include <linux/kthread.h>
17	#include <linux/tracefs.h>	18	#include <linux/tracefs.h>
@@ -1294,6 +1295,8 @@ static int trace_format_open(struct inode inode, struct file file) · 1276 unmodified lines
1294	struct seq_file *m;	1295	struct seq_file *m;
1295	int ret;	1296	int ret;
1296		1297
		1298	/* Do we want to hide event format files on tracefs lockdown? */
		1299
1297	ret = seq_open(file, &trace_format_seq_ops);	1300	ret = seq_open(file, &trace_format_seq_ops);
1298	if (ret < 0)	1301	if (ret < 0)
1299	return ret;	1302	return ret;
@@ -1440,28 +1443,17 @@ static int system_tr_open(struct inode inode, struct file filp) · 140 unmodified lines
1440	struct trace_array *tr = inode->i_private;	1443	struct trace_array *tr = inode->i_private;
1441	int ret;	1444	int ret;
1442		1445
1443	if (tracing_is_disabled())
1444	return -ENODEV;
1445
1446	if (trace_array_get(tr) < 0)
1447	return -ENODEV;
1448
1449	/* Make a temporary dir that has no system but points to tr */	1446	/* Make a temporary dir that has no system but points to tr */
1450	dir = kzalloc(sizeof(*dir), GFP_KERNEL);	1447	dir = kzalloc(sizeof(*dir), GFP_KERNEL);
1451	if (!dir) {	1448	if (!dir)
1452	trace_array_put(tr);
1453	return -ENOMEM;	1449	return -ENOMEM;
1454	}
1455		1450
1456	dir->tr = tr;	1451	ret = tracing_open_generic_tr(inode, filp);
1457
1458	ret = tracing_open_generic(inode, filp);
1459	if (ret < 0) {	1452	if (ret < 0) {
1460	trace_array_put(tr);
1461	kfree(dir);	1453	kfree(dir);
1462	return ret;	1454	return ret;
1463	}	1455	}
1464		1456	dir->tr = tr;
1465	filp->private_data = dir;	1457	filp->private_data = dir;
1466		1458
1467	return 0;	1459	return 0;
@@ -1771,6 +1763,10 @@ ftrace_event_open(struct inode inode, struct file file, · 303 unmodified lines
1771	struct seq_file *m;	1763	struct seq_file *m;
1772	int ret;	1764	int ret;
1773		1765
		1766	ret = security_locked_down(LOCKDOWN_TRACEFS);
		1767	if (ret)
		1768	return ret;
		1769
1774	ret = seq_open(file, seq_ops);	1770	ret = seq_open(file, seq_ops);
1775	if (ret < 0)	1771	if (ret < 0)
1776	return ret;	1772	return ret;
@@ -1795,6 +1791,7 @@ ftrace_event_avail_open(struct inode inode, struct file file) · 18 unmodified lines
1795	{	1791	{
1796	const struct seq_operations *seq_ops = &show_event_seq_ops;	1792	const struct seq_operations *seq_ops = &show_event_seq_ops;
1797		1793
		1794	/* Checks for tracefs lockdown */
1798	return ftrace_event_open(inode, file, seq_ops);	1795	return ftrace_event_open(inode, file, seq_ops);
1799	}	1796	}
1800		1797
@@ -1805,8 +1802,9 @@ ftrace_event_set_open(struct inode inode, struct file file) · 4 unmodified lines
1805	struct trace_array *tr = inode->i_private;	1802	struct trace_array *tr = inode->i_private;
1806	int ret;	1803	int ret;
1807		1804
1808	if (trace_array_get(tr) < 0)	1805	ret = tracing_check_open_get_tr(tr);
1809	return -ENODEV;	1806	if (ret)
		1807	return ret;
1810		1808
1811	if ((file->f_mode & FMODE_WRITE) &&	1809	if ((file->f_mode & FMODE_WRITE) &&
1812	(file->f_flags & O_TRUNC))	1810	(file->f_flags & O_TRUNC))
@@ -1825,8 +1823,9 @@ ftrace_event_set_pid_open(struct inode inode, struct file file) · 12 unmodified lines
1825	struct trace_array *tr = inode->i_private;	1823	struct trace_array *tr = inode->i_private;
1826	int ret;	1824	int ret;
1827		1825
1828	if (trace_array_get(tr) < 0)	1826	ret = tracing_check_open_get_tr(tr);
1829	return -ENODEV;	1827	if (ret)
		1828	return ret;
1830		1829
1831	if ((file->f_mode & FMODE_WRITE) &&	1830	if ((file->f_mode & FMODE_WRITE) &&
1832	(file->f_flags & O_TRUNC))	1831	(file->f_flags & O_TRUNC))

kernel/trace/trace_events_hist.c+12−1

 #include <linux/module.h>
 #include <linux/kallsyms.h>
+#include <linux/security.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <linux/stacktrace.h>
 {
 	int ret;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
 		ret = dyn_events_release_all(&synth_event_ops);
 		if (ret < 0)
 	if (var_data)
 		return 0;
-	if (trace_array_get(tr) < 0)
+	if (tracing_check_open_get_tr(tr))
 		return -ENODEV;
 	var_data = kzalloc(sizeof(*var_data), GFP_KERNEL);
 static int event_hist_open(struct inode *inode, struct file *file)
 {
+	int ret;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	return single_open(file, hist_show, file);
 }

kernel/trace/trace_events_trigger.c+7−1

  * Copyright (C) 2013 Tom Zanussi <tom.zanussi@linux.intel.com>
  */
+#include <linux/security.h>
 #include <linux/module.h>
 #include <linux/ctype.h>
 #include <linux/mutex.h>
 static int event_trigger_regex_open(struct inode *inode, struct file *file)
 {
-	int ret = 0;
+	int ret;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	mutex_lock(&event_mutex);
 static int
 event_trigger_open(struct inode *inode, struct file *filp)
 {
+	/* Checks for tracefs lockdown */
 	return event_trigger_regex_open(inode, filp);
 }

kernel/trace/trace_hwlat.c+3−1

 		if (enter)
 			nmi_ts_start = time_get();
 		else
-			nmi_total_ts = time_get() - nmi_ts_start;
+			nmi_total_ts += time_get() - nmi_ts_start;
 	}
 	if (enter)
 		/* Keep a running maximum ever recorded hardware latency */
 		if (sample > tr->max_latency)
 			tr->max_latency = sample;
+		if (outer_sample > tr->max_latency)
+			tr->max_latency = outer_sample;
 	}
 out:

kernel/trace/trace_kprobe.c+11−1

  */
 #define pr_fmt(fmt)	"trace_kprobe: " fmt
+#include <linux/security.h>
 #include <linux/module.h>
 #include <linux/uaccess.h>
 #include <linux/rculist.h>
 #include <linux/error-injection.h>
-#include <linux/security.h>
 #include <asm/setup.h>  /* for COMMAND_LINE_SIZE */
 {
 	int ret;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
 		ret = dyn_events_release_all(&trace_kprobe_ops);
 		if (ret < 0)
 static int profile_open(struct inode *inode, struct file *file)
 {
+	int ret;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	return seq_open(file, &profile_seq_op);
 }

kernel/trace/trace_printk.c+7−0

  *
  */
 #include <linux/seq_file.h>
+#include <linux/security.h>
 #include <linux/uaccess.h>
 #include <linux/kernel.h>
 #include <linux/ftrace.h>
 static int
 ftrace_formats_open(struct inode *inode, struct file *file)
 {
+	int ret;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	return seq_open(file, &show_format_seq_ops);
 }

kernel/trace/trace_stack.c+8−0

  */
 #include <linux/sched/task_stack.h>
 #include <linux/stacktrace.h>
+#include <linux/security.h>
 #include <linux/kallsyms.h>
 #include <linux/seq_file.h>
 #include <linux/spinlock.h>
 static int stack_trace_open(struct inode *inode, struct file *file)
 {
+	int ret;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	return seq_open(file, &stack_trace_seq_ops);
 }
 {
 	struct ftrace_ops *ops = inode->i_private;
+	/* Checks for tracefs lockdown */
 	return ftrace_regex_open(ops, FTRACE_ITER_FILTER,
 				 inode, file);
 }

kernel/trace/trace_stat.c+5−1

@@ -9,7 +9,7 @@ · 8 unmodified lines
9	*	9	*
10	*/	10	*/
11		11
12		12	#include <linux/security.h>
13	#include <linux/list.h>	13	#include <linux/list.h>
14	#include <linux/slab.h>	14	#include <linux/slab.h>
15	#include <linux/rbtree.h>	15	#include <linux/rbtree.h>
@@ -238,6 +238,10 @@ static int tracing_stat_open(struct inode inode, struct file file) · 222 unmodified lines
238	struct seq_file *m;	238	struct seq_file *m;
239	struct stat_session *session = inode->i_private;	239	struct stat_session *session = inode->i_private;
240		240
		241	ret = security_locked_down(LOCKDOWN_TRACEFS);
		242	if (ret)
		243	return ret;
		244
241	ret = stat_seq_init(session);	245	ret = stat_seq_init(session);
242	if (ret)	246	if (ret)
243	return ret;	247	return ret;

kernel/trace/trace_uprobe.c+11−0

  */
 #define pr_fmt(fmt)	"trace_uprobe: " fmt
+#include <linux/security.h>
 #include <linux/ctype.h>
 #include <linux/module.h>
 #include <linux/uaccess.h>
 {
 	int ret;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
 		ret = dyn_events_release_all(&trace_uprobe_ops);
 		if (ret)
 static int profile_open(struct inode *inode, struct file *file)
 {
+	int ret;
+	ret = security_locked_down(LOCKDOWN_TRACEFS);
+	if (ret)
+		return ret;
 	return seq_open(file, &profile_seq_op);
 }

lib/generic-radix-tree.c+26−6

 #include <linux/export.h>
 #include <linux/generic-radix-tree.h>
 #include <linux/gfp.h>
+#include <linux/kmemleak.h>
 #define GENRADIX_ARY		(PAGE_SIZE / sizeof(struct genradix_node *))
 #define GENRADIX_ARY_SHIFT	ilog2(GENRADIX_ARY)
 }
 EXPORT_SYMBOL(__genradix_ptr);
+static inline struct genradix_node *genradix_alloc_node(gfp_t gfp_mask)
+{
+	struct genradix_node *node;
+	node = (struct genradix_node *)__get_free_page(gfp_mask|__GFP_ZERO);
+	/*
+	 * We're using pages (not slab allocations) directly for kernel data
+	 * structures, so we need to explicitly inform kmemleak of them in order
+	 * to avoid false positive memory leak reports.
+	 */
+	kmemleak_alloc(node, PAGE_SIZE, 1, gfp_mask);
+	return node;
+}
+static inline void genradix_free_node(struct genradix_node *node)
+{
+	kmemleak_free(node);
+	free_page((unsigned long)node);
+}
 /*
  * Returns pointer to the specified byte @offset within @radix, allocating it if
  * necessary - newly allocated slots are always zeroed out:
 			break;
 		if (!new_node) {
-			new_node = (void *)
+			new_node = genradix_alloc_node(gfp_mask);
-				__get_free_page(gfp_mask|__GFP_ZERO);
 			if (!new_node)
 				return NULL;
 		}
 		n = READ_ONCE(*p);
 		if (!n) {
 			if (!new_node) {
-				new_node = (void *)
+				new_node = genradix_alloc_node(gfp_mask);
-					__get_free_page(gfp_mask|__GFP_ZERO);
 				if (!new_node)
 					return NULL;
 			}
 	}
 	if (new_node)
-		free_page((unsigned long) new_node);
+		genradix_free_node(new_node);
 	return &n->data[offset];
 }
 				genradix_free_recurse(n->children[i], level - 1);
 	}
-	free_page((unsigned long) n);
+	genradix_free_node(n);
 }
 int __genradix_prealloc(struct __genradix *radix, size_t size,

lib/string.c+0−21

@@ -748,27 +748,6 @@ void memset(void s, int c, size_t count) · 747 unmodified lines
748	EXPORT_SYMBOL(memset);	748	EXPORT_SYMBOL(memset);
749	#endif	749	#endif
750		750
751	/**
752	* memzero_explicit - Fill a region of memory (e.g. sensitive
753	* keying data) with 0s.
754	* @s: Pointer to the start of the area.
755	* @count: The size of the area.
756	*
757	* Note: usually using memset() is just fine (!), but in cases
758	* where clearing out _local_ data at the end of a scope is
759	* necessary, memzero_explicit() should be used instead in
760	* order to prevent the compiler from optimising away zeroing.
761	*
762	* memzero_explicit() doesn't need an arch-specific version as
763	* it just invokes the one of memset() implicitly.
764	*/
765	void memzero_explicit(void *s, size_t count)
766	{
767	memset(s, 0, count);
768	barrier_data(s);
769	}
770	EXPORT_SYMBOL(memzero_explicit);
771
772	#ifndef __HAVE_ARCH_MEMSET16	751	#ifndef __HAVE_ARCH_MEMSET16
773	/**	752	/**
774	* memset16() - Fill a memory area with a uint16_t	753	* memset16() - Fill a memory area with a uint16_t

lib/test_meminit.c+27−0

@@ -297,6 +297,32 @@ out: · 296 unmodified lines
297	return 1;	297	return 1;
298	}	298	}
299		299
		300	static int __init do_kmem_cache_size_bulk(int size, int *total_failures)
		301	{
		302	struct kmem_cache *c;
		303	int i, iter, maxiter = 1024;
		304	int num, bytes;
		305	bool fail = false;
		306	void *objects[10];
		307
		308	c = kmem_cache_create("test_cache", size, size, 0, NULL);
		309	for (iter = 0; (iter < maxiter) && !fail; iter++) {
		310	num = kmem_cache_alloc_bulk(c, GFP_KERNEL, ARRAY_SIZE(objects),
		311	objects);
		312	for (i = 0; i < num; i++) {
		313	bytes = count_nonzero_bytes(objects[i], size);
		314	if (bytes)
		315	fail = true;
		316	fill_with_garbage(objects[i], size);
		317	}
		318
		319	if (num)
		320	kmem_cache_free_bulk(c, num, objects);
		321	}
		322	*total_failures += fail;
		323	return 1;
		324	}
		325
300	/*	326	/*
301	* Test kmem_cache allocation by creating caches of different sizes, with and	327	* Test kmem_cache allocation by creating caches of different sizes, with and
302	* without constructors, with and without SLAB_TYPESAFE_BY_RCU.	328	* without constructors, with and without SLAB_TYPESAFE_BY_RCU.
@@ -318,6 +344,7 @@ static int __init test_kmemcache(int *total_failures) · 15 unmodified lines
318	num_tests += do_kmem_cache_size(size, ctor, rcu, zero,	344	num_tests += do_kmem_cache_size(size, ctor, rcu, zero,
319	&failures);	345	&failures);
320	}	346	}
		347	num_tests += do_kmem_cache_size_bulk(size, &failures);
321	}	348	}
322	REPORT_FAILURES_IN_FN();	349	REPORT_FAILURES_IN_FN();
323	*total_failures += failures;	350	*total_failures += failures;

lib/test_user_copy.c+28−9

@@ -47,18 +47,35 @@ static bool is_zeroed(void *from, size_t size) · 46 unmodified lines
47	static int test_check_nonzero_user(char kmem, char __user umem, size_t size)	47	static int test_check_nonzero_user(char kmem, char __user umem, size_t size)
48	{	48	{
49	int ret = 0;	49	int ret = 0;
50	size_t start, end, i;	50	size_t start, end, i, zero_start, zero_end;
51	size_t zero_start = size / 4;	51
52	size_t zero_end = size - zero_start;	52	if (test(size < 2 * PAGE_SIZE, "buffer too small"))
		53	return -EINVAL;
		54
		55	/*
		56	* We want to cross a page boundary to exercise the code more
		57	* effectively. We also don't want to make the size we scan too large,
		58	* otherwise the test can take a long time and cause soft lockups. So
		59	* scan a 1024 byte region across the page boundary.
		60	*/
		61	size = 1024;
		62	start = PAGE_SIZE - (size / 2);
		63
		64	kmem += start;
		65	umem += start;
		66
		67	zero_start = size / 4;
		68	zero_end = size - zero_start;
53		69
54	/*	70	/*
55	* We conduct a series of check_nonzero_user() tests on a block of memory	71	* We conduct a series of check_nonzero_user() tests on a block of
56	* with the following byte-pattern (trying every possible [start,end]	72	* memory with the following byte-pattern (trying every possible
57	* pair):	73	* [start,end] pair):
58	*	74	*
59	* [ 00 ff 00 ff ... 00 00 00 00 ... ff 00 ff 00 ]	75	* [ 00 ff 00 ff ... 00 00 00 00 ... ff 00 ff 00 ]
60	*	76	*
61	* And we verify that check_nonzero_user() acts identically to memchr_inv().	77	* And we verify that check_nonzero_user() acts identically to
		78	* memchr_inv().
62	*/	79	*/
63		80
64	memset(kmem, 0x0, size);	81	memset(kmem, 0x0, size);

16 more lines aren’t shown here.

lib/vdso/Kconfig+0−9

This diff is large: its 14 lines aren’t shown here.

mm/backing-dev.c+2−2

This diff is large: its 11 lines aren’t shown here.

mm/compaction.c+4−3

This diff is large: its 27 lines aren’t shown here.

mm/filemap.c+1−0

This diff is large: its 8 lines aren’t shown here.

mm/gup.c+8−6

This diff is large: its 56 lines aren’t shown here.

mm/huge_memory.c+7−2

This diff is large: its 16 lines aren’t shown here.

mm/hugetlb.c+2−3

This diff is large: its 14 lines aren’t shown here.

mm/init-mm.c+1−0

This diff is large: its 8 lines aren’t shown here.

mm/kmemleak.c+21−9

This diff is large: its 52 lines aren’t shown here.

mm/memblock.c+3−3

This diff is large: its 20 lines aren’t shown here.

mm/memcontrol.c+17−6

This diff is large: its 58 lines aren’t shown here.

mm/memory-failure.c+21−15

This diff is large: its 78 lines aren’t shown here.

mm/memory_hotplug.c+15−57

This diff is large: its 91 lines aren’t shown here.

mm/memremap.c+7−6

This diff is large: its 38 lines aren’t shown here.

mm/page_alloc.c+11−3

This diff is large: its 36 lines aren’t shown here.

mm/page_ext.c+9−14

This diff is large: its 75 lines aren’t shown here.

mm/page_owner.c+23−37

This diff is large: its 182 lines aren’t shown here.

mm/rmap.c+1−0

This diff is large: its 8 lines aren’t shown here.

mm/shmem.c+6−0

This diff is large: its 13 lines aren’t shown here.

mm/shuffle.c+1−1

This diff is large: its 9 lines aren’t shown here.

mm/slab.c+3−0

This diff is large: its 13 lines aren’t shown here.

mm/slab_common.c+21−7

This diff is large: its 65 lines aren’t shown here.

mm/slob.c+47−15

This diff is large: its 163 lines aren’t shown here.

mm/slub.c+38−11

This diff is large: its 107 lines aren’t shown here.

mm/sparse.c+1−1

This diff is large: its 9 lines aren’t shown here.

mm/truncate.c+12−0

This diff is large: its 26 lines aren’t shown here.

mm/vmpressure.c+11−9

This diff is large: its 54 lines aren’t shown here.

mm/vmscan.c+72−14

This diff is large: its 137 lines aren’t shown here.

mm/z3fold.c+8−2

This diff is large: its 51 lines aren’t shown here.

net/bridge/netfilter/nf_conntrack_bridge.c+3−0

This diff is large: its 24 lines aren’t shown here.

net/core/datagram.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/core/filter.c+5−3

This diff is large: its 26 lines aren’t shown here.

net/core/net_namespace.c+11−6

This diff is large: its 61 lines aren’t shown here.

net/core/request_sock.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/core/skbuff.c+13−10

This diff is large: its 80 lines aren’t shown here.

net/core/sock.c+18−14

This diff is large: its 106 lines aren’t shown here.

net/dsa/dsa2.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/ipv4/inet_connection_sock.c+3−3

This diff is large: its 27 lines aren’t shown here.

net/ipv4/inet_diag.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/ipv4/ip_output.c+3−0

This diff is large: its 24 lines aren’t shown here.

net/ipv4/route.c+7−4

This diff is large: its 30 lines aren’t shown here.

net/ipv4/tcp.c+45−30

This diff is large: its 249 lines aren’t shown here.

net/ipv4/tcp_diag.c+3−2

This diff is large: its 12 lines aren’t shown here.

net/ipv4/tcp_fastopen.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/ipv4/tcp_input.c+22−15

This diff is large: its 135 lines aren’t shown here.

net/ipv4/tcp_ipv4.c+17−13

This diff is large: its 83 lines aren’t shown here.

net/ipv4/tcp_minisocks.c+11−6

This diff is large: its 47 lines aren’t shown here.

net/ipv4/tcp_output.c+16−16

This diff is large: its 128 lines aren’t shown here.

net/ipv4/tcp_timer.c+6−5

This diff is large: its 34 lines aren’t shown here.

net/ipv6/ip6_gre.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/ipv6/ip6_output.c+3−0

This diff is large: its 24 lines aren’t shown here.

net/ipv6/netfilter.c+3−0

This diff is large: its 24 lines aren’t shown here.

net/ipv6/tcp_ipv6.c+10−8

This diff is large: its 53 lines aren’t shown here.

net/llc/af_llc.c+20−14

This diff is large: its 113 lines aren’t shown here.

net/llc/llc_c_ac.c+6−2

This diff is large: its 36 lines aren’t shown here.

net/llc/llc_conn.c+18−51

This diff is large: its 186 lines aren’t shown here.

net/llc/llc_if.c+8−4

This diff is large: its 36 lines aren’t shown here.

net/llc/llc_s_ac.c+9−3

This diff is large: its 36 lines aren’t shown here.

net/llc/llc_sap.c+8−15

This diff is large: its 38 lines aren’t shown here.

net/mac80211/mlme.c+3−2

This diff is large: its 19 lines aren’t shown here.

net/mac80211/rx.c+10−1

This diff is large: its 20 lines aren’t shown here.

net/mac80211/scan.c+28−2

This diff is large: its 47 lines aren’t shown here.

net/netfilter/nf_conntrack_core.c+2−2

This diff is large: its 11 lines aren’t shown here.

net/openvswitch/actions.c+3−2

This diff is large: its 19 lines aren’t shown here.

net/rxrpc/ar-internal.h+1−0

This diff is large: its 8 lines aren’t shown here.

net/rxrpc/call_accept.c+3−2

This diff is large: its 26 lines aren’t shown here.

net/rxrpc/call_object.c+20−14

This diff is large: its 110 lines aren’t shown here.

net/rxrpc/conn_client.c+7−2

This diff is large: its 48 lines aren’t shown here.

net/rxrpc/conn_object.c+7−6

This diff is large: its 58 lines aren’t shown here.

net/rxrpc/conn_service.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/rxrpc/peer_event.c+9−2

This diff is large: its 39 lines aren’t shown here.

net/rxrpc/peer_object.c+10−6

This diff is large: its 75 lines aren’t shown here.

net/rxrpc/recvmsg.c+3−3

This diff is large: its 20 lines aren’t shown here.

net/rxrpc/sendmsg.c+2−1

This diff is large: its 17 lines aren’t shown here.

net/sched/act_api.c+13−10

This diff is large: its 55 lines aren’t shown here.

net/sched/act_mirred.c+5−1

This diff is large: its 13 lines aren’t shown here.

net/sched/act_mpls.c+8−4

This diff is large: its 38 lines aren’t shown here.

net/sched/cls_api.c+33−3

This diff is large: its 107 lines aren’t shown here.

net/sched/em_meta.c+2−2

This diff is large: its 18 lines aren’t shown here.

net/sched/sch_api.c+1−2

This diff is large: its 10 lines aren’t shown here.

net/sched/sch_etf.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/sched/sch_netem.c+8−3

This diff is large: its 33 lines aren’t shown here.

net/sched/sch_taprio.c+4−0

This diff is large: its 11 lines aren’t shown here.

net/sctp/diag.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/sctp/input.c+11−5

This diff is large: its 44 lines aren’t shown here.

net/sctp/sm_make_chunk.c+6−6

This diff is large: its 50 lines aren’t shown here.

net/sctp/socket.c+2−2

This diff is large: its 18 lines aren’t shown here.

net/smc/smc_core.c+4−1

This diff is large: its 19 lines aren’t shown here.

net/smc/smc_rx.c+21−8

This diff is large: its 54 lines aren’t shown here.

net/sunrpc/xprtsock.c+8−9

This diff is large: its 46 lines aren’t shown here.

net/tipc/socket.c+4−4

This diff is large: its 26 lines aren’t shown here.

net/vmw_vsock/virtio_transport_common.c+14−3

This diff is large: its 47 lines aren’t shown here.

net/wireless/nl80211.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/wireless/reg.c+1−0

This diff is large: its 8 lines aren’t shown here.

net/wireless/reg.h+0−8

This diff is large: its 15 lines aren’t shown here.

net/wireless/scan.c+13−10

This diff is large: its 69 lines aren’t shown here.

net/wireless/wext-sme.c+6−2

This diff is large: its 29 lines aren’t shown here.

net/x25/x25_dev.c+1−1

This diff is large: its 9 lines aren’t shown here.

net/xdp/xsk.c+27−15

This diff is large: its 88 lines aren’t shown here.

samples/bpf/asm_goto_workaround.h+12−1

This diff is large: its 26 lines aren’t shown here.

samples/bpf/task_fd_query_user.c+1−0

This diff is large: its 8 lines aren’t shown here.

scripts/coccinelle/api/devm_platform_ioremap_resource.cocci+0−60

This diff is large: its 61 lines aren’t shown here.

scripts/coccinelle/misc/add_namespace.cocci+2−0

This diff is large: its 9 lines aren’t shown here.

scripts/gdb/linux/dmesg.py+12−4

This diff is large: its 40 lines aren’t shown here.

scripts/gdb/linux/symbols.py+7−1

This diff is large: its 22 lines aren’t shown here.

scripts/gdb/linux/utils.py+13−12

This diff is large: its 48 lines aren’t shown here.

scripts/mod/modpost.c+15−14

This diff is large: its 82 lines aren’t shown here.

scripts/nsdeps+2−2

This diff is large: its 15 lines aren’t shown here.

scripts/recordmcount.h+1−4

This diff is large: its 13 lines aren’t shown here.

scripts/setlocalversion+1−1

This diff is large: its 9 lines aren’t shown here.

security/selinux/ss/services.c+8−1

This diff is large: its 16 lines aren’t shown here.

sound/hda/ext/hdac_ext_controller.c+5−0

This diff is large: its 12 lines aren’t shown here.

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

This diff is large: its 9 lines aren’t shown here.

sound/pci/hda/patch_realtek.c+32−3

This diff is large: its 92 lines aren’t shown here.

sound/usb/pcm.c+3−0

This diff is large: its 10 lines aren’t shown here.

tools/arch/arm/include/uapi/asm/kvm.h+3−1

This diff is large: its 12 lines aren’t shown here.

tools/arch/arm64/include/uapi/asm/kvm.h+3−1

This diff is large: its 12 lines aren’t shown here.

tools/arch/s390/include/uapi/asm/kvm.h+6−0

This diff is large: its 13 lines aren’t shown here.

tools/arch/x86/include/uapi/asm/vmx.h+2−0

This diff is large: its 16 lines aren’t shown here.

tools/bpf/Makefile+5−1

This diff is large: its 13 lines aren’t shown here.

tools/include/uapi/asm-generic/mman-common.h+3−0

This diff is large: its 10 lines aren’t shown here.

tools/include/uapi/drm/i915_drm.h+1−0

This diff is large: its 8 lines aren’t shown here.

tools/include/uapi/linux/fs.h+4−51

This diff is large: its 76 lines aren’t shown here.

tools/include/uapi/linux/fscrypt.h+181−0

This diff is large: its 182 lines aren’t shown here.

tools/include/uapi/linux/kvm.h+3−0

This diff is large: its 17 lines aren’t shown here.

tools/include/uapi/linux/usbdevice_fs.h+4−0

This diff is large: its 17 lines aren’t shown here.

tools/lib/bpf/Makefile+23−10

This diff is large: its 97 lines aren’t shown here.

tools/lib/bpf/libbpf_internal.h+16−0

This diff is large: its 23 lines aren’t shown here.

tools/lib/bpf/xsk.c+2−2

This diff is large: its 11 lines aren’t shown here.

tools/lib/subcmd/Makefile+7−1

This diff is large: its 15 lines aren’t shown here.

tools/perf/Documentation/asciidoc.conf+3−0

This diff is large: its 10 lines aren’t shown here.

tools/perf/Documentation/jitdump-specification.txt+2−2

This diff is large: its 11 lines aren’t shown here.

tools/perf/arch/arm/annotate/instructions.c+2−2

This diff is large: its 16 lines aren’t shown here.

tools/perf/arch/arm64/annotate/instructions.c+2−2

This diff is large: its 16 lines aren’t shown here.

tools/perf/arch/powerpc/util/header.c+2−1

This diff is large: its 16 lines aren’t shown here.

tools/perf/arch/s390/annotate/instructions.c+4−2

This diff is large: its 13 lines aren’t shown here.

tools/perf/arch/s390/util/header.c+5−4

This diff is large: its 43 lines aren’t shown here.

tools/perf/arch/x86/annotate/instructions.c+4−2

This diff is large: its 13 lines aren’t shown here.

tools/perf/arch/x86/util/header.c+2−1

This diff is large: its 16 lines aren’t shown here.

tools/perf/builtin-kvm.c+4−3

This diff is large: its 19 lines aren’t shown here.

tools/perf/builtin-script.c+5−1

This diff is large: its 34 lines aren’t shown here.

tools/perf/check-headers.sh+1−0

This diff is large: its 8 lines aren’t shown here.

tools/perf/pmu-events/arch/s390/cf_z15/basic.jsonrenamed from tools/perf/pmu-events/arch/s390/cf_m8561/basic.json+0−0

File renamed without changes.

tools/perf/pmu-events/arch/s390/cf_z15/crypto.jsonrenamed from tools/perf/pmu-events/arch/s390/cf_m8561/crypto.json+0−0

File renamed without changes.

tools/perf/pmu-events/arch/s390/cf_z15/crypto6.jsonrenamed from tools/perf/pmu-events/arch/s390/cf_m8561/crypto6.json+0−0

File renamed without changes.

tools/perf/pmu-events/arch/s390/cf_z15/extended.jsonrenamed from tools/perf/pmu-events/arch/s390/cf_m8561/extended.json+0−0

File renamed without changes.

tools/perf/pmu-events/arch/s390/cf_z15/transaction.json+7−0

This diff is large: its 8 lines aren’t shown here.

tools/perf/pmu-events/arch/s390/mapfile.csv+1−1

This diff is large: its 6 lines aren’t shown here.

tools/perf/pmu-events/jevents.c+6−6

This diff is large: its 19 lines aren’t shown here.

tools/perf/tests/perf-hooks.c+1−2

This diff is large: its 14 lines aren’t shown here.

tools/perf/util/annotate.c+26−9

This diff is large: its 101 lines aren’t shown here.

tools/perf/util/annotate.h+4−0

This diff is large: its 11 lines aren’t shown here.

tools/perf/util/evsel.c+2−1

This diff is large: its 17 lines aren’t shown here.

tools/perf/util/jitdump.c+3−3

This diff is large: its 27 lines aren’t shown here.

tools/perf/util/llvm-utils.c+3−3

This diff is large: its 18 lines aren’t shown here.

tools/perf/util/map.c+3−0

This diff is large: its 16 lines aren’t shown here.

tools/perf/util/python.c+6−0

This diff is large: its 20 lines aren’t shown here.

tools/testing/selftests/Makefile+17−2

This diff is large: its 46 lines aren’t shown here.

tools/testing/selftests/bpf/prog_tests/sockopt_inherit.c+1−1

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/bpf/prog_tests/tcp_rtt.c+2−1

This diff is large: its 16 lines aren’t shown here.

tools/testing/selftests/bpf/test_flow_dissector.sh+3−0

This diff is large: its 10 lines aren’t shown here.

tools/testing/selftests/bpf/test_lwt_ip_encap.sh+3−3

This diff is large: its 19 lines aren’t shown here.

tools/testing/selftests/kselftest/runner.sh+33−3

This diff is large: its 72 lines aren’t shown here.

tools/testing/selftests/kselftest_install.sh+2−2

This diff is large: its 15 lines aren’t shown here.

tools/testing/selftests/powerpc/mm/tlbie_test.c+1−1

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/rtc/settings+1−0

This diff is large: its 2 lines aren’t shown here.

tools/testing/selftests/vm/gup_benchmark.c+1−1

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/watchdog/watchdog-test.c+26−1

This diff is large: its 69 lines aren’t shown here.

tools/virtio/crypto/hash.hrenamed from arch/arm64/kernel/vdso/gettimeofday.S+0−0

File renamed without changes.

tools/virtio/linux/dma-mapping.h+2−0

This diff is large: its 7 lines aren’t shown here.

tools/virtio/xen/xen.h+6−0

This diff is large: its 7 lines aren’t shown here.

Merge v5.4-rc4 into drm-next

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -12,7 +12,7 @@ · 11 unmodified lines
12	static const struct snd_pcm_hardware snd_bcm2835_playback_hw = {	12	static const struct snd_pcm_hardware snd_bcm2835_playback_hw = {
13	.info = (SNDRV_PCM_INFO_INTERLEAVED \| SNDRV_PCM_INFO_BLOCK_TRANSFER \|	13	.info = (SNDRV_PCM_INFO_INTERLEAVED \| SNDRV_PCM_INFO_BLOCK_TRANSFER \|
14	SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_MMAP_VALID \|	14	SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_MMAP_VALID \|
15	SNDRV_PCM_INFO_DRAIN_TRIGGER \| SNDRV_PCM_INFO_SYNC_APPLPTR),	15	SNDRV_PCM_INFO_SYNC_APPLPTR),
16	.formats = SNDRV_PCM_FMTBIT_U8 \| SNDRV_PCM_FMTBIT_S16_LE,	16	.formats = SNDRV_PCM_FMTBIT_U8 \| SNDRV_PCM_FMTBIT_S16_LE,
17	.rates = SNDRV_PCM_RATE_CONTINUOUS \| SNDRV_PCM_RATE_8000_48000,	17	.rates = SNDRV_PCM_RATE_CONTINUOUS \| SNDRV_PCM_RATE_8000_48000,
18	.rate_min = 8000,	18	.rate_min = 8000,
@@ -29,7 +29,7 @@ static const struct snd_pcm_hardware snd_bcm2835_playback_hw = { · 10 unmodified lines
29	static const struct snd_pcm_hardware snd_bcm2835_playback_spdif_hw = {	29	static const struct snd_pcm_hardware snd_bcm2835_playback_spdif_hw = {
30	.info = (SNDRV_PCM_INFO_INTERLEAVED \| SNDRV_PCM_INFO_BLOCK_TRANSFER \|	30	.info = (SNDRV_PCM_INFO_INTERLEAVED \| SNDRV_PCM_INFO_BLOCK_TRANSFER \|
31	SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_MMAP_VALID \|	31	SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_MMAP_VALID \|
32	SNDRV_PCM_INFO_DRAIN_TRIGGER \| SNDRV_PCM_INFO_SYNC_APPLPTR),	32	SNDRV_PCM_INFO_SYNC_APPLPTR),
33	.formats = SNDRV_PCM_FMTBIT_S16_LE,	33	.formats = SNDRV_PCM_FMTBIT_S16_LE,
34	.rates = SNDRV_PCM_RATE_CONTINUOUS \| SNDRV_PCM_RATE_44100 \|	34	.rates = SNDRV_PCM_RATE_CONTINUOUS \| SNDRV_PCM_RATE_44100 \|
35	SNDRV_PCM_RATE_48000,	35	SNDRV_PCM_RATE_48000,

@@ -740,7 +740,7 @@ void vtime_account_system(struct task_struct *tsk) · 739 unmodified lines
740		740
741	write_seqcount_begin(&vtime->seqcount);	741	write_seqcount_begin(&vtime->seqcount);
742	/* We might have scheduled out from guest path */	742	/* We might have scheduled out from guest path */
743	if (current->flags & PF_VCPU)	743	if (tsk->flags & PF_VCPU)
744	vtime_account_guest(tsk, vtime);	744	vtime_account_guest(tsk, vtime);
745	else	745	else
746	__vtime_account_system(tsk, vtime);	746	__vtime_account_system(tsk, vtime);
@@ -783,7 +783,7 @@ void vtime_guest_enter(struct task_struct *tsk) · 36 unmodified lines
783	*/	783	*/
784	write_seqcount_begin(&vtime->seqcount);	784	write_seqcount_begin(&vtime->seqcount);
785	__vtime_account_system(tsk, vtime);	785	__vtime_account_system(tsk, vtime);
786	current->flags \|= PF_VCPU;	786	tsk->flags \|= PF_VCPU;
787	write_seqcount_end(&vtime->seqcount);	787	write_seqcount_end(&vtime->seqcount);
788	}	788	}
789	EXPORT_SYMBOL_GPL(vtime_guest_enter);	789	EXPORT_SYMBOL_GPL(vtime_guest_enter);
@@ -794,7 +794,7 @@ void vtime_guest_exit(struct task_struct *tsk) · 4 unmodified lines
794		794
795	write_seqcount_begin(&vtime->seqcount);	795	write_seqcount_begin(&vtime->seqcount);
796	vtime_account_guest(tsk, vtime);	796	vtime_account_guest(tsk, vtime);
797	current->flags &= ~PF_VCPU;	797	tsk->flags &= ~PF_VCPU;
798	write_seqcount_end(&vtime->seqcount);	798	write_seqcount_end(&vtime->seqcount);
799	}	799	}
800	EXPORT_SYMBOL_GPL(vtime_guest_exit);	800	EXPORT_SYMBOL_GPL(vtime_guest_exit);