lael-labs/linux

Documentation/devicetree/bindings/iommu/arm,smmu-v3.txt+3−0

@@ -35,3 +35,6 @@ the PCIe specification. · 34 unmodified lines
35		35
36	NOTE: this only applies to the SMMU itself, not	36	NOTE: this only applies to the SMMU itself, not
37	masters connected upstream of the SMMU.	37	masters connected upstream of the SMMU.
		38
		39	- hisilicon,broken-prefetch-cmd
		40	: Avoid sending CMD_PREFETCH_* commands to the SMMU.

Documentation/devicetree/bindings/mmc/fsl-imx-esdhc.txt+0−2

 	       "fsl,imx6sx-usdhc"
 Optional properties:
-- fsl,cd-controller : Indicate to use controller internal card detection
 - fsl,wp-controller : Indicate to use controller internal write protection
 - fsl,delay-line : Specify the number of delay cells for override mode.
   This is used to set the clock delay for DLL(Delay Line) on override mode
 	compatible = "fsl,imx51-esdhc";
 	reg = <0x70004000 0x4000>;
 	interrupts = <1>;
-	fsl,cd-controller;
 	fsl,wp-controller;
 };

MAINTAINERS+15−1

 F:	Documentation/s390/kvm.txt
 F:	arch/s390/include/asm/kvm*
 F:	arch/s390/kvm/
-F:	drivers/s390/kvm/
 KERNEL VIRTUAL MACHINE (KVM) FOR ARM
 M:	Christoffer Dall <christoffer.dall@linaro.org>
 S:	Maintained
 F:	drivers/media/usb/msi2500/
+MSYSTEMS DISKONCHIP G3 MTD DRIVER
+M:	Robert Jarzmik <robert.jarzmik@free.fr>
+L:	linux-mtd@lists.infradead.org
+S:	Maintained
+F:	drivers/mtd/devices/docg3*
 MT9M032 APTINA SENSOR DRIVER
 M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
 L:	linux-media@vger.kernel.org
 F:	include/linux/virtio_*.h
 F:	include/uapi/linux/virtio_*.h
+VIRTIO DRIVERS FOR S390
+M:	Christian Borntraeger <borntraeger@de.ibm.com>
+M:	Cornelia Huck <cornelia.huck@de.ibm.com>
+L:	linux-s390@vger.kernel.org
+L:	virtualization@lists.linux-foundation.org
+L:	kvm@vger.kernel.org
+S:	Supported
+F:	drivers/s390/virtio/
 VIRTIO GPU DRIVER
 M:	David Airlie <airlied@linux.ie>
 M:	Gerd Hoffmann <kraxel@redhat.com>

Makefile+1−1

@@ -1,7 +1,7 @@
1	VERSION = 4	1	VERSION = 4
2	PATCHLEVEL = 2	2	PATCHLEVEL = 2
3	SUBLEVEL = 0	3	SUBLEVEL = 0
4	EXTRAVERSION = -rc3	4	EXTRAVERSION = -rc4
5	NAME = Hurr durr I'ma sheep	5	NAME = Hurr durr I'ma sheep
6		6
7	# DOCUMENTATION	7	# DOCUMENTATION

arch/arm/boot/dts/imx25-pdk.dts+3−2

  */
 /dts-v1/;
+#include <dt-bindings/gpio/gpio.h>
 #include <dt-bindings/input/input.h>
 #include "imx25.dtsi"
 &esdhc1 {
 	pinctrl-names = "default";
 	pinctrl-0 = <&pinctrl_esdhc1>;
-	cd-gpios = <&gpio2 1 0>;
+	cd-gpios = <&gpio2 1 GPIO_ACTIVE_LOW>;
-	wp-gpios = <&gpio2 0 0>;
+	wp-gpios = <&gpio2 0 GPIO_ACTIVE_HIGH>;
 	status = "okay";
 };

arch/arm/boot/dts/imx51-apf51dev.dts+1−1

@@ -98,7 +98,7 @@ · 97 unmodified lines
98	&esdhc1 {	98	&esdhc1 {
99	pinctrl-names = "default";	99	pinctrl-names = "default";
100	pinctrl-0 = <&pinctrl_esdhc1>;	100	pinctrl-0 = <&pinctrl_esdhc1>;
101	cd-gpios = <&gpio2 29 GPIO_ACTIVE_HIGH>;	101	cd-gpios = <&gpio2 29 GPIO_ACTIVE_LOW>;
102	bus-width = <4>;	102	bus-width = <4>;
103	status = "okay";	103	status = "okay";
104	};	104	};

arch/arm/boot/dts/imx53-ard.dts+2−2

@@ -103,8 +103,8 @@ · 102 unmodified lines
103	&esdhc1 {	103	&esdhc1 {
104	pinctrl-names = "default";	104	pinctrl-names = "default";
105	pinctrl-0 = <&pinctrl_esdhc1>;	105	pinctrl-0 = <&pinctrl_esdhc1>;
106	cd-gpios = <&gpio1 1 0>;	106	cd-gpios = <&gpio1 1 GPIO_ACTIVE_LOW>;
107	wp-gpios = <&gpio1 9 0>;	107	wp-gpios = <&gpio1 9 GPIO_ACTIVE_HIGH>;
108	status = "okay";	108	status = "okay";
109	};	109	};
110		110

arch/arm/boot/dts/imx53-m53evk.dts+2−2

@@ -124,8 +124,8 @@ · 123 unmodified lines
124	&esdhc1 {	124	&esdhc1 {
125	pinctrl-names = "default";	125	pinctrl-names = "default";
126	pinctrl-0 = <&pinctrl_esdhc1>;	126	pinctrl-0 = <&pinctrl_esdhc1>;
127	cd-gpios = <&gpio1 1 0>;	127	cd-gpios = <&gpio1 1 GPIO_ACTIVE_LOW>;
128	wp-gpios = <&gpio1 9 0>;	128	wp-gpios = <&gpio1 9 GPIO_ACTIVE_HIGH>;
129	status = "okay";	129	status = "okay";
130	};	130	};
131		131

arch/arm/boot/dts/imx53-qsb-common.dtsi+2−2

@@ -147,8 +147,8 @@ · 146 unmodified lines
147	&esdhc3 {	147	&esdhc3 {
148	pinctrl-names = "default";	148	pinctrl-names = "default";
149	pinctrl-0 = <&pinctrl_esdhc3>;	149	pinctrl-0 = <&pinctrl_esdhc3>;
150	cd-gpios = <&gpio3 11 0>;	150	cd-gpios = <&gpio3 11 GPIO_ACTIVE_LOW>;
151	wp-gpios = <&gpio3 12 0>;	151	wp-gpios = <&gpio3 12 GPIO_ACTIVE_HIGH>;
152	bus-width = <8>;	152	bus-width = <8>;
153	status = "okay";	153	status = "okay";
154	};	154	};

arch/arm/boot/dts/imx53-smd.dts+2−2

@@ -41,8 +41,8 @@ · 40 unmodified lines
41	&esdhc1 {	41	&esdhc1 {
42	pinctrl-names = "default";	42	pinctrl-names = "default";
43	pinctrl-0 = <&pinctrl_esdhc1>;	43	pinctrl-0 = <&pinctrl_esdhc1>;
44	cd-gpios = <&gpio3 13 0>;	44	cd-gpios = <&gpio3 13 GPIO_ACTIVE_LOW>;
45	wp-gpios = <&gpio4 11 0>;	45	wp-gpios = <&gpio4 11 GPIO_ACTIVE_HIGH>;
46	status = "okay";	46	status = "okay";
47	};	47	};
48		48

arch/arm/boot/dts/imx53-tqma53.dtsi+2−2

@@ -41,8 +41,8 @@ · 40 unmodified lines
41	pinctrl-0 = <&pinctrl_esdhc2>,	41	pinctrl-0 = <&pinctrl_esdhc2>,
42	<&pinctrl_esdhc2_cdwp>;	42	<&pinctrl_esdhc2_cdwp>;
43	vmmc-supply = <&reg_3p3v>;	43	vmmc-supply = <&reg_3p3v>;
44	wp-gpios = <&gpio1 2 0>;	44	wp-gpios = <&gpio1 2 GPIO_ACTIVE_HIGH>;
45	cd-gpios = <&gpio1 4 0>;	45	cd-gpios = <&gpio1 4 GPIO_ACTIVE_LOW>;
46	status = "disabled";	46	status = "disabled";
47	};	47	};
48		48

arch/arm/boot/dts/imx53-tx53.dtsi+2−2

@@ -183,7 +183,7 @@ · 182 unmodified lines
183	};	183	};
184		184
185	&esdhc1 {	185	&esdhc1 {
186	cd-gpios = <&gpio3 24 GPIO_ACTIVE_HIGH>;	186	cd-gpios = <&gpio3 24 GPIO_ACTIVE_LOW>;
187	fsl,wp-controller;	187	fsl,wp-controller;
188	pinctrl-names = "default";	188	pinctrl-names = "default";
189	pinctrl-0 = <&pinctrl_esdhc1>;	189	pinctrl-0 = <&pinctrl_esdhc1>;
@@ -191,7 +191,7 @@ · 1 unmodified line
191	};	191	};
192		192
193	&esdhc2 {	193	&esdhc2 {
194	cd-gpios = <&gpio3 25 GPIO_ACTIVE_HIGH>;	194	cd-gpios = <&gpio3 25 GPIO_ACTIVE_LOW>;
195	fsl,wp-controller;	195	fsl,wp-controller;
196	pinctrl-names = "default";	196	pinctrl-names = "default";
197	pinctrl-0 = <&pinctrl_esdhc2>;	197	pinctrl-0 = <&pinctrl_esdhc2>;

arch/arm/boot/dts/imx53-voipac-bsb.dts+2−2

@@ -119,8 +119,8 @@ · 118 unmodified lines
119	&esdhc2 {	119	&esdhc2 {
120	pinctrl-names = "default";	120	pinctrl-names = "default";
121	pinctrl-0 = <&pinctrl_esdhc2>;	121	pinctrl-0 = <&pinctrl_esdhc2>;
122	cd-gpios = <&gpio3 25 0>;	122	cd-gpios = <&gpio3 25 GPIO_ACTIVE_LOW>;
123	wp-gpios = <&gpio2 19 0>;	123	wp-gpios = <&gpio2 19 GPIO_ACTIVE_HIGH>;
124	vmmc-supply = <&reg_3p3v>;	124	vmmc-supply = <&reg_3p3v>;
125	status = "okay";	125	status = "okay";
126	};	126	};

arch/arm/boot/dts/imx6dl-riotboard.dts+4−4

@@ -305,8 +305,8 @@ · 304 unmodified lines
305	&usdhc2 {	305	&usdhc2 {
306	pinctrl-names = "default";	306	pinctrl-names = "default";
307	pinctrl-0 = <&pinctrl_usdhc2>;	307	pinctrl-0 = <&pinctrl_usdhc2>;
308	cd-gpios = <&gpio1 4 0>;	308	cd-gpios = <&gpio1 4 GPIO_ACTIVE_LOW>;
309	wp-gpios = <&gpio1 2 0>;	309	wp-gpios = <&gpio1 2 GPIO_ACTIVE_HIGH>;
310	vmmc-supply = <&reg_3p3v>;	310	vmmc-supply = <&reg_3p3v>;
311	status = "okay";	311	status = "okay";
312	};	312	};
@@ -314,8 +314,8 @@ · 1 unmodified line
314	&usdhc3 {	314	&usdhc3 {
315	pinctrl-names = "default";	315	pinctrl-names = "default";
316	pinctrl-0 = <&pinctrl_usdhc3>;	316	pinctrl-0 = <&pinctrl_usdhc3>;
317	cd-gpios = <&gpio7 0 0>;	317	cd-gpios = <&gpio7 0 GPIO_ACTIVE_LOW>;
318	wp-gpios = <&gpio7 1 0>;	318	wp-gpios = <&gpio7 1 GPIO_ACTIVE_HIGH>;
319	vmmc-supply = <&reg_3p3v>;	319	vmmc-supply = <&reg_3p3v>;
320	status = "okay";	320	status = "okay";
321	};	321	};

arch/arm/boot/dts/imx6q-arm2.dts+3−2

  */
 /dts-v1/;
+#include <dt-bindings/gpio/gpio.h>
 #include "imx6q.dtsi"
 / {
 };
 &usdhc3 {
-	cd-gpios = <&gpio6 11 0>;
+	cd-gpios = <&gpio6 11 GPIO_ACTIVE_LOW>;
-	wp-gpios = <&gpio6 14 0>;
+	wp-gpios = <&gpio6 14 GPIO_ACTIVE_HIGH>;
 	vmmc-supply = <&reg_3p3v>;
 	pinctrl-names = "default";
 	pinctrl-0 = <&pinctrl_usdhc3

arch/arm/boot/dts/imx6q-gk802.dts+2−1

  */
 /dts-v1/;
+#include <dt-bindings/gpio/gpio.h>
 #include "imx6q.dtsi"
 / {
 	pinctrl-names = "default";
 	pinctrl-0 = <&pinctrl_usdhc3>;
 	bus-width = <4>;
-	cd-gpios = <&gpio6 11 0>;
+	cd-gpios = <&gpio6 11 GPIO_ACTIVE_LOW>;
 	vmmc-supply = <&reg_3p3v>;
 	status = "okay";
 };

arch/arm/boot/dts/imx6q-tbs2910.dts+2−2

@@ -251,7 +251,7 @@ · 250 unmodified lines
251	pinctrl-names = "default";	251	pinctrl-names = "default";
252	pinctrl-0 = <&pinctrl_usdhc2>;	252	pinctrl-0 = <&pinctrl_usdhc2>;
253	bus-width = <4>;	253	bus-width = <4>;
254	cd-gpios = <&gpio2 2 GPIO_ACTIVE_HIGH>;	254	cd-gpios = <&gpio2 2 GPIO_ACTIVE_LOW>;
255	vmmc-supply = <&reg_3p3v>;	255	vmmc-supply = <&reg_3p3v>;
256	status = "okay";	256	status = "okay";
257	};	257	};
@@ -260,7 +260,7 @@ · 2 unmodified lines
260	pinctrl-names = "default";	260	pinctrl-names = "default";
261	pinctrl-0 = <&pinctrl_usdhc3>;	261	pinctrl-0 = <&pinctrl_usdhc3>;
262	bus-width = <4>;	262	bus-width = <4>;
263	cd-gpios = <&gpio2 0 GPIO_ACTIVE_HIGH>;	263	cd-gpios = <&gpio2 0 GPIO_ACTIVE_LOW>;
264	wp-gpios = <&gpio2 1 GPIO_ACTIVE_HIGH>;	264	wp-gpios = <&gpio2 1 GPIO_ACTIVE_HIGH>;
265	vmmc-supply = <&reg_3p3v>;	265	vmmc-supply = <&reg_3p3v>;
266	status = "okay";	266	status = "okay";

arch/arm/boot/dts/imx6qdl-aristainetos.dtsi+2−2

@@ -173,7 +173,7 @@ · 172 unmodified lines
173	pinctrl-names = "default";	173	pinctrl-names = "default";
174	pinctrl-0 = <&pinctrl_usdhc1>;	174	pinctrl-0 = <&pinctrl_usdhc1>;
175	vmmc-supply = <&reg_3p3v>;	175	vmmc-supply = <&reg_3p3v>;
176	cd-gpios = <&gpio4 7 GPIO_ACTIVE_HIGH>;	176	cd-gpios = <&gpio4 7 GPIO_ACTIVE_LOW>;
177	status = "okay";	177	status = "okay";
178	};	178	};
179		179
@@ -181,7 +181,7 @@ · 1 unmodified line
181	pinctrl-names = "default";	181	pinctrl-names = "default";
182	pinctrl-0 = <&pinctrl_usdhc2>;	182	pinctrl-0 = <&pinctrl_usdhc2>;
183	vmmc-supply = <&reg_3p3v>;	183	vmmc-supply = <&reg_3p3v>;
184	cd-gpios = <&gpio4 8 GPIO_ACTIVE_HIGH>;	184	cd-gpios = <&gpio4 8 GPIO_ACTIVE_LOW>;
185	status = "okay";	185	status = "okay";
186	};	186	};
187		187

arch/arm/boot/dts/imx6qdl-aristainetos2.dtsi+2−2

@@ -392,7 +392,7 @@ · 391 unmodified lines
392	&usdhc1 {	392	&usdhc1 {
393	pinctrl-names = "default";	393	pinctrl-names = "default";
394	pinctrl-0 = <&pinctrl_usdhc1>;	394	pinctrl-0 = <&pinctrl_usdhc1>;
395	cd-gpios = <&gpio1 27 GPIO_ACTIVE_HIGH>;	395	cd-gpios = <&gpio1 27 GPIO_ACTIVE_LOW>;
396	no-1-8-v;	396	no-1-8-v;
397	status = "okay";	397	status = "okay";
398	};	398	};
@@ -400,7 +400,7 @@ · 1 unmodified line
400	&usdhc2 {	400	&usdhc2 {
401	pinctrl-names = "default";	401	pinctrl-names = "default";
402	pinctrl-0 = <&pinctrl_usdhc2>;	402	pinctrl-0 = <&pinctrl_usdhc2>;
403	cd-gpios = <&gpio4 5 GPIO_ACTIVE_HIGH>;	403	cd-gpios = <&gpio4 5 GPIO_ACTIVE_LOW>;
404	wp-gpios = <&gpio2 10 GPIO_ACTIVE_HIGH>;	404	wp-gpios = <&gpio2 10 GPIO_ACTIVE_HIGH>;
405	no-1-8-v;	405	no-1-8-v;
406	status = "okay";	406	status = "okay";

arch/arm/boot/dts/imx6qdl-cubox-i.dtsi+1−1

@@ -258,6 +258,6 @@ · 257 unmodified lines
258	pinctrl-names = "default";	258	pinctrl-names = "default";
259	pinctrl-0 = <&pinctrl_cubox_i_usdhc2_aux &pinctrl_cubox_i_usdhc2>;	259	pinctrl-0 = <&pinctrl_cubox_i_usdhc2_aux &pinctrl_cubox_i_usdhc2>;
260	vmmc-supply = <&reg_3p3v>;	260	vmmc-supply = <&reg_3p3v>;
261	cd-gpios = <&gpio1 4 0>;	261	cd-gpios = <&gpio1 4 GPIO_ACTIVE_LOW>;
262	status = "okay";	262	status = "okay";
263	};	263	};

arch/arm/boot/dts/imx6qdl-dfi-fs700-m60.dtsi+3−1

+#include <dt-bindings/gpio/gpio.h>
 / {
 	regulators {
 		compatible = "simple-bus";
 &usdhc2 { /* module slot */
 	pinctrl-names = "default";
 	pinctrl-0 = <&pinctrl_usdhc2>;
-	cd-gpios = <&gpio2 2 0>;
+	cd-gpios = <&gpio2 2 GPIO_ACTIVE_LOW>;
 	status = "okay";
 };

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

@@ -318,7 +318,7 @@ · 317 unmodified lines
318	&usdhc3 {	318	&usdhc3 {
319	pinctrl-names = "default";	319	pinctrl-names = "default";
320	pinctrl-0 = <&pinctrl_usdhc3>;	320	pinctrl-0 = <&pinctrl_usdhc3>;
321	cd-gpios = <&gpio7 0 GPIO_ACTIVE_HIGH>;	321	cd-gpios = <&gpio7 0 GPIO_ACTIVE_LOW>;
322	vmmc-supply = <&reg_3p3v>;	322	vmmc-supply = <&reg_3p3v>;
323	status = "okay";	323	status = "okay";
324	};	324	};

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

@@ -324,7 +324,7 @@ · 323 unmodified lines
324	&usdhc3 {	324	&usdhc3 {
325	pinctrl-names = "default";	325	pinctrl-names = "default";
326	pinctrl-0 = <&pinctrl_usdhc3>;	326	pinctrl-0 = <&pinctrl_usdhc3>;
327	cd-gpios = <&gpio7 0 GPIO_ACTIVE_HIGH>;	327	cd-gpios = <&gpio7 0 GPIO_ACTIVE_LOW>;
328	vmmc-supply = <&reg_3p3v>;	328	vmmc-supply = <&reg_3p3v>;
329	status = "okay";	329	status = "okay";
330	};	330	};

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

@@ -417,7 +417,7 @@ · 416 unmodified lines
417	&usdhc3 {	417	&usdhc3 {
418	pinctrl-names = "default";	418	pinctrl-names = "default";
419	pinctrl-0 = <&pinctrl_usdhc3>;	419	pinctrl-0 = <&pinctrl_usdhc3>;
420	cd-gpios = <&gpio7 0 GPIO_ACTIVE_HIGH>;	420	cd-gpios = <&gpio7 0 GPIO_ACTIVE_LOW>;
421	vmmc-supply = <&reg_3p3v>;	421	vmmc-supply = <&reg_3p3v>;
422	status = "okay";	422	status = "okay";
423	};	423	};

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

@@ -299,6 +299,6 @@ · 298 unmodified lines
299	&pinctrl_hummingboard_usdhc2	299	&pinctrl_hummingboard_usdhc2
300	>;	300	>;
301	vmmc-supply = <&reg_3p3v>;	301	vmmc-supply = <&reg_3p3v>;
302	cd-gpios = <&gpio1 4 0>;	302	cd-gpios = <&gpio1 4 GPIO_ACTIVE_LOW>;
303	status = "okay";	303	status = "okay";
304	};	304	};

arch/arm/boot/dts/imx6qdl-nitrogen6x.dtsi+2−2

@@ -453,7 +453,7 @@ · 452 unmodified lines
453	&usdhc3 {	453	&usdhc3 {
454	pinctrl-names = "default";	454	pinctrl-names = "default";
455	pinctrl-0 = <&pinctrl_usdhc3>;	455	pinctrl-0 = <&pinctrl_usdhc3>;
456	cd-gpios = <&gpio7 0 0>;	456	cd-gpios = <&gpio7 0 GPIO_ACTIVE_LOW>;
457	vmmc-supply = <&reg_3p3v>;	457	vmmc-supply = <&reg_3p3v>;
458	status = "okay";	458	status = "okay";
459	};	459	};
@@ -461,7 +461,7 @@ · 1 unmodified line
461	&usdhc4 {	461	&usdhc4 {
462	pinctrl-names = "default";	462	pinctrl-names = "default";
463	pinctrl-0 = <&pinctrl_usdhc4>;	463	pinctrl-0 = <&pinctrl_usdhc4>;
464	cd-gpios = <&gpio2 6 0>;	464	cd-gpios = <&gpio2 6 GPIO_ACTIVE_LOW>;
465	vmmc-supply = <&reg_3p3v>;	465	vmmc-supply = <&reg_3p3v>;
466	status = "okay";	466	status = "okay";
467	};	467	};

arch/arm/boot/dts/imx6qdl-phytec-pfla02.dtsi+4−4

@@ -409,8 +409,8 @@ · 408 unmodified lines
409	&usdhc2 {	409	&usdhc2 {
410	pinctrl-names = "default";	410	pinctrl-names = "default";
411	pinctrl-0 = <&pinctrl_usdhc2>;	411	pinctrl-0 = <&pinctrl_usdhc2>;
412	cd-gpios = <&gpio1 4 0>;	412	cd-gpios = <&gpio1 4 GPIO_ACTIVE_LOW>;
413	wp-gpios = <&gpio1 2 0>;	413	wp-gpios = <&gpio1 2 GPIO_ACTIVE_HIGH>;
414	status = "disabled";	414	status = "disabled";
415	};	415	};
416		416
@@ -418,7 +418,7 @@ · 1 unmodified line
418	pinctrl-names = "default";	418	pinctrl-names = "default";
419	pinctrl-0 = <&pinctrl_usdhc3	419	pinctrl-0 = <&pinctrl_usdhc3
420	&pinctrl_usdhc3_cdwp>;	420	&pinctrl_usdhc3_cdwp>;
421	cd-gpios = <&gpio1 27 0>;	421	cd-gpios = <&gpio1 27 GPIO_ACTIVE_LOW>;
422	wp-gpios = <&gpio1 29 0>;	422	wp-gpios = <&gpio1 29 GPIO_ACTIVE_HIGH>;
423	status = "disabled";	423	status = "disabled";
424	};	424	};

arch/arm/boot/dts/imx6qdl-rex.dtsi+2−2

@@ -342,7 +342,7 @@ · 341 unmodified lines
342	pinctrl-0 = <&pinctrl_usdhc2>;	342	pinctrl-0 = <&pinctrl_usdhc2>;
343	bus-width = <4>;	343	bus-width = <4>;
344	cd-gpios = <&gpio2 2 GPIO_ACTIVE_LOW>;	344	cd-gpios = <&gpio2 2 GPIO_ACTIVE_LOW>;
345	wp-gpios = <&gpio2 3 GPIO_ACTIVE_LOW>;	345	wp-gpios = <&gpio2 3 GPIO_ACTIVE_HIGH>;
346	status = "okay";	346	status = "okay";
347	};	347	};
348		348
@@ -351,6 +351,6 @@ · 2 unmodified lines
351	pinctrl-0 = <&pinctrl_usdhc3>;	351	pinctrl-0 = <&pinctrl_usdhc3>;
352	bus-width = <4>;	352	bus-width = <4>;
353	cd-gpios = <&gpio2 0 GPIO_ACTIVE_LOW>;	353	cd-gpios = <&gpio2 0 GPIO_ACTIVE_LOW>;
354	wp-gpios = <&gpio2 1 GPIO_ACTIVE_LOW>;	354	wp-gpios = <&gpio2 1 GPIO_ACTIVE_HIGH>;
355	status = "okay";	355	status = "okay";
356	};	356	};

arch/arm/boot/dts/imx6qdl-sabreauto.dtsi+2−2

@@ -467,8 +467,8 @@ · 466 unmodified lines
467	pinctrl-0 = <&pinctrl_usdhc3>;	467	pinctrl-0 = <&pinctrl_usdhc3>;
468	pinctrl-1 = <&pinctrl_usdhc3_100mhz>;	468	pinctrl-1 = <&pinctrl_usdhc3_100mhz>;
469	pinctrl-2 = <&pinctrl_usdhc3_200mhz>;	469	pinctrl-2 = <&pinctrl_usdhc3_200mhz>;
470	cd-gpios = <&gpio6 15 0>;	470	cd-gpios = <&gpio6 15 GPIO_ACTIVE_LOW>;
471	wp-gpios = <&gpio1 13 0>;	471	wp-gpios = <&gpio1 13 GPIO_ACTIVE_HIGH>;
472	status = "okay";	472	status = "okay";
473	};	473	};
474		474

arch/arm/boot/dts/imx6qdl-sabrelite.dtsi+3−3

@@ -448,8 +448,8 @@ · 447 unmodified lines
448	&usdhc3 {	448	&usdhc3 {
449	pinctrl-names = "default";	449	pinctrl-names = "default";
450	pinctrl-0 = <&pinctrl_usdhc3>;	450	pinctrl-0 = <&pinctrl_usdhc3>;
451	cd-gpios = <&gpio7 0 0>;	451	cd-gpios = <&gpio7 0 GPIO_ACTIVE_LOW>;
452	wp-gpios = <&gpio7 1 0>;	452	wp-gpios = <&gpio7 1 GPIO_ACTIVE_HIGH>;
453	vmmc-supply = <&reg_3p3v>;	453	vmmc-supply = <&reg_3p3v>;
454	status = "okay";	454	status = "okay";
455	};	455	};
@@ -457,7 +457,7 @@ · 1 unmodified line
457	&usdhc4 {	457	&usdhc4 {
458	pinctrl-names = "default";	458	pinctrl-names = "default";
459	pinctrl-0 = <&pinctrl_usdhc4>;	459	pinctrl-0 = <&pinctrl_usdhc4>;
460	cd-gpios = <&gpio2 6 0>;	460	cd-gpios = <&gpio2 6 GPIO_ACTIVE_LOW>;
461	vmmc-supply = <&reg_3p3v>;	461	vmmc-supply = <&reg_3p3v>;
462	status = "okay";	462	status = "okay";
463	};	463	};

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

@@ -562,8 +562,8 @@ · 561 unmodified lines
562	pinctrl-names = "default";	562	pinctrl-names = "default";
563	pinctrl-0 = <&pinctrl_usdhc2>;	563	pinctrl-0 = <&pinctrl_usdhc2>;
564	bus-width = <8>;	564	bus-width = <8>;
565	cd-gpios = <&gpio2 2 0>;	565	cd-gpios = <&gpio2 2 GPIO_ACTIVE_LOW>;
566	wp-gpios = <&gpio2 3 0>;	566	wp-gpios = <&gpio2 3 GPIO_ACTIVE_HIGH>;
567	status = "okay";	567	status = "okay";
568	};	568	};
569		569
@@ -571,8 +571,8 @@ · 1 unmodified line
571	pinctrl-names = "default";	571	pinctrl-names = "default";
572	pinctrl-0 = <&pinctrl_usdhc3>;	572	pinctrl-0 = <&pinctrl_usdhc3>;
573	bus-width = <8>;	573	bus-width = <8>;
574	cd-gpios = <&gpio2 0 0>;	574	cd-gpios = <&gpio2 0 GPIO_ACTIVE_LOW>;
575	wp-gpios = <&gpio2 1 0>;	575	wp-gpios = <&gpio2 1 GPIO_ACTIVE_HIGH>;
576	status = "okay";	576	status = "okay";
577	};	577	};
578		578

arch/arm/boot/dts/imx6qdl-tx6.dtsi+2−2

@@ -680,7 +680,7 @@ · 679 unmodified lines
680	pinctrl-0 = <&pinctrl_usdhc1>;	680	pinctrl-0 = <&pinctrl_usdhc1>;
681	bus-width = <4>;	681	bus-width = <4>;
682	no-1-8-v;	682	no-1-8-v;
683	cd-gpios = <&gpio7 2 0>;	683	cd-gpios = <&gpio7 2 GPIO_ACTIVE_LOW>;
684	fsl,wp-controller;	684	fsl,wp-controller;
685	status = "okay";	685	status = "okay";
686	};	686	};
@@ -690,7 +690,7 @@ · 3 unmodified lines
690	pinctrl-0 = <&pinctrl_usdhc2>;	690	pinctrl-0 = <&pinctrl_usdhc2>;
691	bus-width = <4>;	691	bus-width = <4>;
692	no-1-8-v;	692	no-1-8-v;
693	cd-gpios = <&gpio7 3 0>;	693	cd-gpios = <&gpio7 3 GPIO_ACTIVE_LOW>;
694	fsl,wp-controller;	694	fsl,wp-controller;
695	status = "okay";	695	status = "okay";
696	};	696	};

arch/arm/boot/dts/imx6qdl-wandboard.dtsi+4−2

  *
  */
+#include <dt-bindings/gpio/gpio.h>
 / {
 	regulators {
 		compatible = "simple-bus";
 &usdhc1 {
 	pinctrl-names = "default";
 	pinctrl-0 = <&pinctrl_usdhc1>;
-	cd-gpios = <&gpio1 2 0>;
+	cd-gpios = <&gpio1 2 GPIO_ACTIVE_LOW>;
 	status = "okay";
 };
 &usdhc3 {
 	pinctrl-names = "default";
 	pinctrl-0 = <&pinctrl_usdhc3>;
-	cd-gpios = <&gpio3 9 0>;
+	cd-gpios = <&gpio3 9 GPIO_ACTIVE_LOW>;
 	status = "okay";
 };

arch/arm/boot/dts/imx6sl-evk.dts+5−5

@@ -617,8 +617,8 @@ · 616 unmodified lines
617	pinctrl-1 = <&pinctrl_usdhc1_100mhz>;	617	pinctrl-1 = <&pinctrl_usdhc1_100mhz>;
618	pinctrl-2 = <&pinctrl_usdhc1_200mhz>;	618	pinctrl-2 = <&pinctrl_usdhc1_200mhz>;
619	bus-width = <8>;	619	bus-width = <8>;
620	cd-gpios = <&gpio4 7 0>;	620	cd-gpios = <&gpio4 7 GPIO_ACTIVE_LOW>;
621	wp-gpios = <&gpio4 6 0>;	621	wp-gpios = <&gpio4 6 GPIO_ACTIVE_HIGH>;
622	status = "okay";	622	status = "okay";
623	};	623	};
624		624
@@ -627,8 +627,8 @@ · 2 unmodified lines
627	pinctrl-0 = <&pinctrl_usdhc2>;	627	pinctrl-0 = <&pinctrl_usdhc2>;
628	pinctrl-1 = <&pinctrl_usdhc2_100mhz>;	628	pinctrl-1 = <&pinctrl_usdhc2_100mhz>;
629	pinctrl-2 = <&pinctrl_usdhc2_200mhz>;	629	pinctrl-2 = <&pinctrl_usdhc2_200mhz>;
630	cd-gpios = <&gpio5 0 0>;	630	cd-gpios = <&gpio5 0 GPIO_ACTIVE_LOW>;
631	wp-gpios = <&gpio4 29 0>;	631	wp-gpios = <&gpio4 29 GPIO_ACTIVE_HIGH>;
632	status = "okay";	632	status = "okay";
633	};	633	};
634		634
@@ -637,6 +637,6 @@ · 2 unmodified lines
637	pinctrl-0 = <&pinctrl_usdhc3>;	637	pinctrl-0 = <&pinctrl_usdhc3>;
638	pinctrl-1 = <&pinctrl_usdhc3_100mhz>;	638	pinctrl-1 = <&pinctrl_usdhc3_100mhz>;
639	pinctrl-2 = <&pinctrl_usdhc3_200mhz>;	639	pinctrl-2 = <&pinctrl_usdhc3_200mhz>;
640	cd-gpios = <&gpio3 22 0>;	640	cd-gpios = <&gpio3 22 GPIO_ACTIVE_LOW>;
641	status = "okay";	641	status = "okay";
642	};	642	};

arch/arm/boot/dts/imx6sx-sabreauto.dts+2−2

@@ -49,7 +49,7 @@ · 48 unmodified lines
49	pinctrl-1 = <&pinctrl_usdhc3_100mhz>;	49	pinctrl-1 = <&pinctrl_usdhc3_100mhz>;
50	pinctrl-2 = <&pinctrl_usdhc3_200mhz>;	50	pinctrl-2 = <&pinctrl_usdhc3_200mhz>;
51	bus-width = <8>;	51	bus-width = <8>;
52	cd-gpios = <&gpio7 10 GPIO_ACTIVE_HIGH>;	52	cd-gpios = <&gpio7 10 GPIO_ACTIVE_LOW>;
53	wp-gpios = <&gpio3 19 GPIO_ACTIVE_HIGH>;	53	wp-gpios = <&gpio3 19 GPIO_ACTIVE_HIGH>;
54	keep-power-in-suspend;	54	keep-power-in-suspend;
55	enable-sdio-wakeup;	55	enable-sdio-wakeup;
@@ -61,7 +61,7 @@ · 5 unmodified lines
61	pinctrl-names = "default";	61	pinctrl-names = "default";
62	pinctrl-0 = <&pinctrl_usdhc4>;	62	pinctrl-0 = <&pinctrl_usdhc4>;
63	bus-width = <8>;	63	bus-width = <8>;
64	cd-gpios = <&gpio7 11 GPIO_ACTIVE_HIGH>;	64	cd-gpios = <&gpio7 11 GPIO_ACTIVE_LOW>;
65	no-1-8-v;	65	no-1-8-v;
66	keep-power-in-suspend;	66	keep-power-in-suspend;
67	enable-sdio-wakup;	67	enable-sdio-wakup;

arch/arm/boot/dts/imx6sx-sdb.dtsi+2−2

@@ -293,7 +293,7 @@ · 292 unmodified lines
293	pinctrl-1 = <&pinctrl_usdhc3_100mhz>;	293	pinctrl-1 = <&pinctrl_usdhc3_100mhz>;
294	pinctrl-2 = <&pinctrl_usdhc3_200mhz>;	294	pinctrl-2 = <&pinctrl_usdhc3_200mhz>;
295	bus-width = <8>;	295	bus-width = <8>;
296	cd-gpios = <&gpio2 10 GPIO_ACTIVE_HIGH>;	296	cd-gpios = <&gpio2 10 GPIO_ACTIVE_LOW>;
297	wp-gpios = <&gpio2 15 GPIO_ACTIVE_HIGH>;	297	wp-gpios = <&gpio2 15 GPIO_ACTIVE_HIGH>;
298	keep-power-in-suspend;	298	keep-power-in-suspend;
299	enable-sdio-wakeup;	299	enable-sdio-wakeup;
@@ -304,7 +304,7 @@ · 4 unmodified lines
304	&usdhc4 {	304	&usdhc4 {
305	pinctrl-names = "default";	305	pinctrl-names = "default";
306	pinctrl-0 = <&pinctrl_usdhc4>;	306	pinctrl-0 = <&pinctrl_usdhc4>;
307	cd-gpios = <&gpio6 21 GPIO_ACTIVE_HIGH>;	307	cd-gpios = <&gpio6 21 GPIO_ACTIVE_LOW>;
308	wp-gpios = <&gpio6 20 GPIO_ACTIVE_HIGH>;	308	wp-gpios = <&gpio6 20 GPIO_ACTIVE_HIGH>;
309	status = "okay";	309	status = "okay";
310	};	310	};

arch/arm/boot/dts/imx7d-sdb.dts+2−2

@@ -234,8 +234,8 @@ · 233 unmodified lines
234	&usdhc1 {	234	&usdhc1 {
235	pinctrl-names = "default";	235	pinctrl-names = "default";
236	pinctrl-0 = <&pinctrl_usdhc1>;	236	pinctrl-0 = <&pinctrl_usdhc1>;
237	cd-gpios = <&gpio5 0 0>;	237	cd-gpios = <&gpio5 0 GPIO_ACTIVE_LOW>;
238	wp-gpios = <&gpio5 1 0>;	238	wp-gpios = <&gpio5 1 GPIO_ACTIVE_HIGH>;
239	enable-sdio-wakeup;	239	enable-sdio-wakeup;
240	keep-power-in-suspend;	240	keep-power-in-suspend;
241	status = "okay";	241	status = "okay";

arch/arm/net/bpf_jit_32.c+44−13

 int bpf_jit_enable __read_mostly;
-static u64 jit_get_skb_b(struct sk_buff *skb, unsigned offset)
+static inline int call_neg_helper(struct sk_buff *skb, int offset, void *ret,
+		      unsigned int size)
+{
+	void *ptr = bpf_internal_load_pointer_neg_helper(skb, offset, size);
+	if (!ptr)
+		return -EFAULT;
+	memcpy(ret, ptr, size);
+	return 0;
+}
+static u64 jit_get_skb_b(struct sk_buff *skb, int offset)
 {
 	u8 ret;
 	int err;
-	err = skb_copy_bits(skb, offset, &ret, 1);
+	if (offset < 0)
+		err = call_neg_helper(skb, offset, &ret, 1);
+	else
+		err = skb_copy_bits(skb, offset, &ret, 1);
 	return (u64)err << 32 | ret;
 }
-static u64 jit_get_skb_h(struct sk_buff *skb, unsigned offset)
+static u64 jit_get_skb_h(struct sk_buff *skb, int offset)
 {
 	u16 ret;
 	int err;
-	err = skb_copy_bits(skb, offset, &ret, 2);
+	if (offset < 0)
+		err = call_neg_helper(skb, offset, &ret, 2);
+	else
+		err = skb_copy_bits(skb, offset, &ret, 2);
 	return (u64)err << 32 | ntohs(ret);
 }
-static u64 jit_get_skb_w(struct sk_buff *skb, unsigned offset)
+static u64 jit_get_skb_w(struct sk_buff *skb, int offset)
 {
 	u32 ret;
 	int err;
-	err = skb_copy_bits(skb, offset, &ret, 4);
+	if (offset < 0)
+		err = call_neg_helper(skb, offset, &ret, 4);
+	else
+		err = skb_copy_bits(skb, offset, &ret, 4);
 	return (u64)err << 32 | ntohl(ret);
 }
 		case BPF_LD | BPF_B | BPF_ABS:
 			load_order = 0;
 load:
-			/* the interpreter will deal with the negative K */
-			if ((int)k < 0)
-				return -ENOTSUPP;
 			emit_mov_i(r_off, k, ctx);
 load_common:
 			ctx->seen |= SEEN_DATA | SEEN_CALL;
 				emit(ARM_SUB_I(r_scratch, r_skb_hl,
 					       1 << load_order), ctx);
 				emit(ARM_CMP_R(r_scratch, r_off), ctx);
-				condt = ARM_COND_HS;
+				condt = ARM_COND_GE;
 			} else {
 				emit(ARM_CMP_R(r_skb_hl, r_off), ctx);
 				condt = ARM_COND_HI;
 			}
+			/*
+			 * test for negative offset, only if we are
+			 * currently scheduled to take the fast
+			 * path. this will update the flags so that
+			 * the slowpath instruction are ignored if the
+			 * offset is negative.
+			 *
+			 * for loard_order == 0 the HI condition will
+			 * make loads at offset 0 take the slow path too.
+			 */
+			_emit(condt, ARM_CMP_I(r_off, 0), ctx);
 			_emit(condt, ARM_ADD_R(r_scratch, r_off, r_skb_data),
 			      ctx);
 			off = offsetof(struct sk_buff, vlan_tci);
 			emit(ARM_LDRH_I(r_A, r_skb, off), ctx);
 			if (code == (BPF_ANC | SKF_AD_VLAN_TAG))
-				OP_IMM3(ARM_AND, r_A, r_A, VLAN_VID_MASK, ctx);
+				OP_IMM3(ARM_AND, r_A, r_A, ~VLAN_TAG_PRESENT, ctx);
-			else
+			else {
-				OP_IMM3(ARM_AND, r_A, r_A, VLAN_TAG_PRESENT, ctx);
+				OP_IMM3(ARM_LSR, r_A, r_A, 12, ctx);
+				OP_IMM3(ARM_AND, r_A, r_A, 0x1, ctx);
+			}
 			break;
 		case BPF_ANC | SKF_AD_QUEUE:
 			ctx->seen |= SEEN_SKB;

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

  *
  */
 ENTRY(cpu_switch_to)
-	add	x8, x0, #THREAD_CPU_CONTEXT
+	mov	x10, #THREAD_CPU_CONTEXT
+	add	x8, x0, x10
 	mov	x9, sp
 	stp	x19, x20, [x8], #16		// store callee-saved registers
 	stp	x21, x22, [x8], #16
 	stp	x27, x28, [x8], #16
 	stp	x29, x9, [x8], #16
 	str	lr, [x8]
-	add	x8, x1, #THREAD_CPU_CONTEXT
+	add	x8, x1, x10
 	ldp	x19, x20, [x8], #16		// restore callee-saved registers
 	ldp	x21, x22, [x8], #16
 	ldp	x23, x24, [x8], #16

arch/arm64/kernel/irq.c+2−2

@@ -61,7 +61,7 @@ void __init init_IRQ(void) · 60 unmodified lines
61	static bool migrate_one_irq(struct irq_desc *desc)	61	static bool migrate_one_irq(struct irq_desc *desc)
62	{	62	{
63	struct irq_data *d = irq_desc_get_irq_data(desc);	63	struct irq_data *d = irq_desc_get_irq_data(desc);
64	const struct cpumask *affinity = d->affinity;	64	const struct cpumask *affinity = irq_data_get_affinity_mask(d);
65	struct irq_chip *c;	65	struct irq_chip *c;
66	bool ret = false;	66	bool ret = false;
67		67
@@ -81,7 +81,7 @@ static bool migrate_one_irq(struct irq_desc *desc) · 13 unmodified lines
81	if (!c->irq_set_affinity)	81	if (!c->irq_set_affinity)
82	pr_debug("IRQ%u: unable to set affinity\n", d->irq);	82	pr_debug("IRQ%u: unable to set affinity\n", d->irq);
83	else if (c->irq_set_affinity(d, affinity, false) == IRQ_SET_MASK_OK && ret)	83	else if (c->irq_set_affinity(d, affinity, false) == IRQ_SET_MASK_OK && ret)
84	cpumask_copy(d->affinity, affinity);	84	cpumask_copy(irq_data_get_affinity_mask(d), affinity);
85		85
86	return ret;	86	return ret;
87	}	87	}

arch/avr32/kernel/time.c+33−32

@@ -18,6 +18,7 @@ · 17 unmodified lines
18		18
19	#include <mach/pm.h>	19	#include <mach/pm.h>
20		20
		21	static bool disable_cpu_idle_poll;
21		22
22	static cycle_t read_cycle_count(struct clocksource *cs)	23	static cycle_t read_cycle_count(struct clocksource *cs)
23	{	24	{
@@ -80,45 +81,45 @@ static int comparator_next_event(unsigned long delta, · 56 unmodified lines
80	return 0;	81	return 0;
81	}	82	}
82		83
83	static void comparator_mode(enum clock_event_mode mode,	84	static int comparator_shutdown(struct clock_event_device *evdev)
84	struct clock_event_device *evdev)
85	{	85	{
86	switch (mode) {	86	pr_debug("%s: %s\n", __func__, evdev->name);
87	case CLOCK_EVT_MODE_ONESHOT:	87	sysreg_write(COMPARE, 0);
88	pr_debug("%s: start\n", evdev->name);	88
89	/* FALLTHROUGH */	89	if (disable_cpu_idle_poll) {
90	case CLOCK_EVT_MODE_RESUME:	90	disable_cpu_idle_poll = false;
91	/*	91	/*
92	* If we're using the COUNT and COMPARE registers we	92	* Only disable idle poll if we have forced that
93	* need to force idle poll.	93	* in a previous call.
94	*/	94	*/
95	cpu_idle_poll_ctrl(true);	95	cpu_idle_poll_ctrl(false);
96	break;
97	case CLOCK_EVT_MODE_UNUSED:
98	case CLOCK_EVT_MODE_SHUTDOWN:
99	sysreg_write(COMPARE, 0);
100	pr_debug("%s: stop\n", evdev->name);
101	if (evdev->mode == CLOCK_EVT_MODE_ONESHOT \|\|
102	evdev->mode == CLOCK_EVT_MODE_RESUME) {
103	/*
104	* Only disable idle poll if we have forced that
105	* in a previous call.
106	*/
107	cpu_idle_poll_ctrl(false);
108	}
109	break;
110	default:
111	BUG();
112	}	96	}
		97	return 0;
		98	}
		99
		100	static int comparator_set_oneshot(struct clock_event_device *evdev)
		101	{
		102	pr_debug("%s: %s\n", __func__, evdev->name);
		103
		104	disable_cpu_idle_poll = true;
		105	/*
		106	* If we're using the COUNT and COMPARE registers we
		107	* need to force idle poll.
		108	*/
		109	cpu_idle_poll_ctrl(true);
		110
		111	return 0;
113	}	112	}
114		113
115	static struct clock_event_device comparator = {	114	static struct clock_event_device comparator = {
116	.name = "avr32_comparator",	115	.name = "avr32_comparator",
117	.features = CLOCK_EVT_FEAT_ONESHOT,	116	.features = CLOCK_EVT_FEAT_ONESHOT,
118	.shift = 16,	117	.shift = 16,
119	.rating = 50,	118	.rating = 50,
120	.set_next_event = comparator_next_event,	119	.set_next_event = comparator_next_event,
121	.set_mode = comparator_mode,	120	.set_state_shutdown = comparator_shutdown,
		121	.set_state_oneshot = comparator_set_oneshot,
		122	.tick_resume = comparator_set_oneshot,
122	};	123	};
123		124
124	void read_persistent_clock(struct timespec *ts)	125	void read_persistent_clock(struct timespec *ts)

arch/m32r/include/asm/io.h+5−0

 #define iowrite16 writew
 #define iowrite32 writel
+#define ioread16be(addr)	be16_to_cpu(readw(addr))
+#define ioread32be(addr)	be32_to_cpu(readl(addr))
+#define iowrite16be(v, addr)	writew(cpu_to_be16(v), (addr))
+#define iowrite32be(v, addr)	writel(cpu_to_be32(v), (addr))
 #define mmiowb()
 #define flush_write_buffers() do { } while (0)  /* M32R_FIXME */

arch/s390/kernel/asm-offsets.c+7−8

 int main(void)
 {
-	DEFINE(__THREAD_info, offsetof(struct task_struct, stack));
+	DEFINE(__TASK_thread_info, offsetof(struct task_struct, stack));
-	DEFINE(__THREAD_ksp, offsetof(struct task_struct, thread.ksp));
+	DEFINE(__TASK_thread, offsetof(struct task_struct, thread));
-	DEFINE(__THREAD_mm_segment, offsetof(struct task_struct, thread.mm_segment));
-	BLANK();
 	DEFINE(__TASK_pid, offsetof(struct task_struct, pid));
 	BLANK();
-	DEFINE(__THREAD_per_cause, offsetof(struct task_struct, thread.per_event.cause));
+	DEFINE(__THREAD_ksp, offsetof(struct thread_struct, ksp));
-	DEFINE(__THREAD_per_address, offsetof(struct task_struct, thread.per_event.address));
+	DEFINE(__THREAD_per_cause, offsetof(struct thread_struct, per_event.cause));
-	DEFINE(__THREAD_per_paid, offsetof(struct task_struct, thread.per_event.paid));
+	DEFINE(__THREAD_per_address, offsetof(struct thread_struct, per_event.address));
+	DEFINE(__THREAD_per_paid, offsetof(struct thread_struct, per_event.paid));
+	DEFINE(__THREAD_trap_tdb, offsetof(struct thread_struct, trap_tdb));
 	BLANK();
 	DEFINE(__TI_task, offsetof(struct thread_info, task));
 	DEFINE(__TI_flags, offsetof(struct thread_info, flags));
 	DEFINE(__LC_VDSO_PER_CPU, offsetof(struct _lowcore, vdso_per_cpu_data));
 	DEFINE(__LC_GMAP, offsetof(struct _lowcore, gmap));
 	DEFINE(__LC_PGM_TDB, offsetof(struct _lowcore, pgm_tdb));
-	DEFINE(__THREAD_trap_tdb, offsetof(struct task_struct, thread.trap_tdb));
 	DEFINE(__GMAP_ASCE, offsetof(struct gmap, asce));
 	DEFINE(__SIE_PROG0C, offsetof(struct kvm_s390_sie_block, prog0c));
 	DEFINE(__SIE_PROG20, offsetof(struct kvm_s390_sie_block, prog20));

arch/s390/kernel/entry.S+9−4

  */
 ENTRY(__switch_to)
 	stmg	%r6,%r15,__SF_GPRS(%r15)	# store gprs of prev task
-	stg	%r15,__THREAD_ksp(%r2)		# store kernel stack of prev
+	lgr	%r1,%r2
-	lg	%r4,__THREAD_info(%r2)		# get thread_info of prev
+	aghi	%r1,__TASK_thread		# thread_struct of prev task
-	lg	%r5,__THREAD_info(%r3)		# get thread_info of next
+	lg	%r4,__TASK_thread_info(%r2)	# get thread_info of prev
+	lg	%r5,__TASK_thread_info(%r3)	# get thread_info of next
+	stg	%r15,__THREAD_ksp(%r1)		# store kernel stack of prev
+	lgr	%r1,%r3
+	aghi	%r1,__TASK_thread		# thread_struct of next task
 	lgr	%r15,%r5
 	aghi	%r15,STACK_INIT			# end of kernel stack of next
 	stg	%r3,__LC_CURRENT		# store task struct of next
 	stg	%r5,__LC_THREAD_INFO		# store thread info of next
 	stg	%r15,__LC_KERNEL_STACK		# store end of kernel stack
+	lg	%r15,__THREAD_ksp(%r1)		# load kernel stack of next
 	lctl	%c4,%c4,__TASK_pid(%r3)		# load pid to control reg. 4
 	mvc	__LC_CURRENT_PID+4(4,%r0),__TASK_pid(%r3) # store pid of next
-	lg	%r15,__THREAD_ksp(%r3)		# load kernel stack of next
 	lmg	%r6,%r15,__SF_GPRS(%r15)	# load gprs of next task
 	br	%r14
 	LAST_BREAK %r14
 	lg	%r15,__LC_KERNEL_STACK
 	lg	%r14,__TI_task(%r12)
+	aghi	%r14,__TASK_thread	# pointer to thread_struct
 	lghi	%r13,__LC_PGM_TDB
 	tm	__LC_PGM_ILC+2,0x02	# check for transaction abort
 	jz	2f

arch/s390/kernel/traps.c+2−2

@@ -259,7 +259,7 @@ void vector_exception(struct pt_regs *regs) · 258 unmodified lines
259	}	259	}
260		260
261	/* get vector interrupt code from fpc */	261	/* get vector interrupt code from fpc */
262	asm volatile("stfpc %0" : "=m" (current->thread.fp_regs.fpc));	262	asm volatile("stfpc %0" : "=Q" (current->thread.fp_regs.fpc));
263	vic = (current->thread.fp_regs.fpc & 0xf00) >> 8;	263	vic = (current->thread.fp_regs.fpc & 0xf00) >> 8;
264	switch (vic) {	264	switch (vic) {
265	case 1: /* invalid vector operation */	265	case 1: /* invalid vector operation */
@@ -297,7 +297,7 @@ void data_exception(struct pt_regs *regs) · 31 unmodified lines
297		297
298	location = get_trap_ip(regs);	298	location = get_trap_ip(regs);
299		299
300	asm volatile("stfpc %0" : "=m" (current->thread.fp_regs.fpc));	300	asm volatile("stfpc %0" : "=Q" (current->thread.fp_regs.fpc));
301	/* Check for vector register enablement */	301	/* Check for vector register enablement */
302	if (MACHINE_HAS_VX && !current->thread.vxrs &&	302	if (MACHINE_HAS_VX && !current->thread.vxrs &&
303	(current->thread.fp_regs.fpc & FPC_DXC_MASK) == 0xfe00) {	303	(current->thread.fp_regs.fpc & FPC_DXC_MASK) == 0xfe00) {

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

@@ -1139,7 +1139,7 @@ static void __init load_hv_initrd(void) · 1138 unmodified lines
1139		1139
1140	void __init free_initrd_mem(unsigned long begin, unsigned long end)	1140	void __init free_initrd_mem(unsigned long begin, unsigned long end)
1141	{	1141	{
1142	free_bootmem(__pa(begin), end - begin);	1142	free_bootmem_late(__pa(begin), end - begin);
1143	}	1143	}
1144		1144
1145	static int __init setup_initrd(char *str)	1145	static int __init setup_initrd(char *str)

arch/x86/entry/entry_64_compat.S+9−5

 	movl	RDX(%rsp), %edx		/* arg3 */
 	movl	RSI(%rsp), %ecx		/* arg4 */
 	movl	RDI(%rsp), %r8d		/* arg5 */
-	movl	%ebp, %r9d		/* arg6 */
 	.endm
 	.macro auditsys_exit exit
 sysenter_auditsys:
 	auditsys_entry_common
+	movl	%ebp, %r9d		/* reload 6th syscall arg */
 	jmp	sysenter_dispatch
 sysexit_audit:
 	 * 32-bit zero extended:
 	 */
 	ASM_STAC
-1:	movl	(%r8), %ebp
+1:	movl	(%r8), %r9d
 	_ASM_EXTABLE(1b, ia32_badarg)
 	ASM_CLAC
 	orl	$TS_COMPAT, ASM_THREAD_INFO(TI_status, %rsp, SIZEOF_PTREGS)
 cstar_do_call:
 	/* 32-bit syscall -> 64-bit C ABI argument conversion */
 	movl	%edi, %r8d		/* arg5 */
-	movl	%ebp, %r9d		/* arg6 */
+	/* r9 already loaded */		/* arg6 */
 	xchg	%ecx, %esi		/* rsi:arg2, rcx:arg4 */
 	movl	%ebx, %edi		/* arg1 */
 	movl	%edx, %edx		/* arg3 (zero extension) */
 	call	*ia32_sys_call_table(, %rax, 8)
 	movq	%rax, RAX(%rsp)
 1:
-	movl	RCX(%rsp), %ebp
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	testl	$_TIF_ALLWORK_MASK, ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 #ifdef CONFIG_AUDITSYSCALL
 cstar_auditsys:
+	movl	%r9d, R9(%rsp)		/* register to be clobbered by call */
 	auditsys_entry_common
+	movl	R9(%rsp), %r9d		/* reload 6th syscall arg */
 	jmp	cstar_dispatch
 sysretl_audit:
 	testl	$(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT), ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 	jz	cstar_auditsys
 #endif
+	xchgl	%r9d, %ebp
 	SAVE_EXTRA_REGS
 	xorl	%eax, %eax		/* Do not leak kernel information */
 	movq	%rax, R11(%rsp)
 	movq	%rax, R10(%rsp)
-	movq	%rax, R9(%rsp)
+	movq	%r9, R9(%rsp)
 	movq	%rax, R8(%rsp)
 	movq	%rsp, %rdi		/* &pt_regs -> arg1 */
 	call	syscall_trace_enter
+	movl	R9(%rsp), %r9d
 	/* Reload arg registers from stack. (see sysenter_tracesys) */
 	movl	RCX(%rsp), %ecx
 	movl	%eax, %eax		/* zero extension */
 	RESTORE_EXTRA_REGS
+	xchgl	%ebp, %r9d
 	jmp	cstar_do_call
 END(entry_SYSCALL_compat)

arch/x86/include/uapi/asm/kvm.h+2−2

@@ -354,7 +354,7 @@ struct kvm_xcrs { · 353 unmodified lines
354	struct kvm_sync_regs {	354	struct kvm_sync_regs {
355	};	355	};
356		356
357	#define KVM_QUIRK_LINT0_REENABLED (1 << 0)	357	#define KVM_X86_QUIRK_LINT0_REENABLED (1 << 0)
358	#define KVM_QUIRK_CD_NW_CLEARED (1 << 1)	358	#define KVM_X86_QUIRK_CD_NW_CLEARED (1 << 1)
359		359
360	#endif /* _ASM_X86_KVM_H */	360	#endif /* _ASM_X86_KVM_H */

arch/x86/kernel/cpu/perf_event_intel_cqm.c+8−0

@@ -951,6 +951,14 @@ static u64 intel_cqm_event_count(struct perf_event *event) · 950 unmodified lines
951	if (!cqm_group_leader(event))	951	if (!cqm_group_leader(event))
952	return 0;	952	return 0;
953		953
		954	/*
		955	* Getting up-to-date values requires an SMP IPI which is not
		956	* possible if we're being called in interrupt context. Return
		957	* the cached values instead.
		958	*/
		959	if (unlikely(in_interrupt()))
		960	goto out;
		961
954	/*	962	/*
955	* Notice that we don't perform the reading of an RMID	963	* Notice that we don't perform the reading of an RMID
956	* atomically, because we can't hold a spin lock across the	964	* atomically, because we can't hold a spin lock across the

arch/x86/kernel/fpu/init.c+6−0

 	setup_clear_cpu_cap(X86_FEATURE_XSAVE);
 	setup_clear_cpu_cap(X86_FEATURE_XSAVEOPT);
+	setup_clear_cpu_cap(X86_FEATURE_XSAVEC);
 	setup_clear_cpu_cap(X86_FEATURE_XSAVES);
 	setup_clear_cpu_cap(X86_FEATURE_AVX);
 	setup_clear_cpu_cap(X86_FEATURE_AVX2);
+	setup_clear_cpu_cap(X86_FEATURE_AVX512F);
+	setup_clear_cpu_cap(X86_FEATURE_AVX512PF);
+	setup_clear_cpu_cap(X86_FEATURE_AVX512ER);
+	setup_clear_cpu_cap(X86_FEATURE_AVX512CD);
+	setup_clear_cpu_cap(X86_FEATURE_MPX);
 	return 1;
 }

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

@@ -1595,7 +1595,7 @@ void kvm_lapic_reset(struct kvm_vcpu *vcpu, bool init_event) · 1594 unmodified lines
1595	for (i = 0; i < APIC_LVT_NUM; i++)	1595	for (i = 0; i < APIC_LVT_NUM; i++)
1596	apic_set_reg(apic, APIC_LVTT + 0x10 * i, APIC_LVT_MASKED);	1596	apic_set_reg(apic, APIC_LVTT + 0x10 * i, APIC_LVT_MASKED);
1597	apic_update_lvtt(apic);	1597	apic_update_lvtt(apic);
1598	if (!(vcpu->kvm->arch.disabled_quirks & KVM_QUIRK_LINT0_REENABLED))	1598	if (kvm_check_has_quirk(vcpu->kvm, KVM_X86_QUIRK_LINT0_REENABLED))
1599	apic_set_reg(apic, APIC_LVT0,	1599	apic_set_reg(apic, APIC_LVT0,
1600	SET_APIC_DELIVERY_MODE(0, APIC_MODE_EXTINT));	1600	SET_APIC_DELIVERY_MODE(0, APIC_MODE_EXTINT));
1601	apic_manage_nmi_watchdog(apic, kvm_apic_get_reg(apic, APIC_LVT0));	1601	apic_manage_nmi_watchdog(apic, kvm_apic_get_reg(apic, APIC_LVT0));

arch/x86/kvm/mtrr.c+30−10

@@ -120,6 +120,16 @@ static u8 mtrr_default_type(struct kvm_mtrr *mtrr_state) · 119 unmodified lines
120	return mtrr_state->deftype & IA32_MTRR_DEF_TYPE_TYPE_MASK;	120	return mtrr_state->deftype & IA32_MTRR_DEF_TYPE_TYPE_MASK;
121	}	121	}
122		122
		123	static u8 mtrr_disabled_type(void)
		124	{
		125	/*
		126	* Intel SDM 11.11.2.2: all MTRRs are disabled when
		127	* IA32_MTRR_DEF_TYPE.E bit is cleared, and the UC
		128	* memory type is applied to all of physical memory.
		129	*/
		130	return MTRR_TYPE_UNCACHABLE;
		131	}
		132
123	/*	133	/*
124	* Three terms are used in the following code:	134	* Three terms are used in the following code:
125	* - segment, it indicates the address segments covered by fixed MTRRs.	135	* - segment, it indicates the address segments covered by fixed MTRRs.
@@ -434,6 +444,8 @@ struct mtrr_iter { · 308 unmodified lines
434		444
435	/* output fields. */	445	/* output fields. */
436	int mem_type;	446	int mem_type;
		447	/* mtrr is completely disabled? */
		448	bool mtrr_disabled;
437	/* [start, end) is not fully covered in MTRRs? */	449	/* [start, end) is not fully covered in MTRRs? */
438	bool partial_map;	450	bool partial_map;
439		451
@@ -549,7 +561,7 @@ static void mtrr_lookup_var_next(struct mtrr_iter *iter) · 109 unmodified lines
549	static void mtrr_lookup_start(struct mtrr_iter *iter)	561	static void mtrr_lookup_start(struct mtrr_iter *iter)
550	{	562	{
551	if (!mtrr_is_enabled(iter->mtrr_state)) {	563	if (!mtrr_is_enabled(iter->mtrr_state)) {
552	iter->partial_map = true;	564	iter->mtrr_disabled = true;
553	return;	565	return;
554	}	566	}
555		567
@@ -563,6 +575,7 @@ static void mtrr_lookup_init(struct mtrr_iter *iter, · 7 unmodified lines
563	iter->mtrr_state = mtrr_state;	575	iter->mtrr_state = mtrr_state;
564	iter->start = start;	576	iter->start = start;
565	iter->end = end;	577	iter->end = end;
		578	iter->mtrr_disabled = false;
566	iter->partial_map = false;	579	iter->partial_map = false;
567	iter->fixed = false;	580	iter->fixed = false;
568	iter->range = NULL;	581	iter->range = NULL;
@@ -656,15 +669,19 @@ u8 kvm_mtrr_get_guest_memory_type(struct kvm_vcpu *vcpu, gfn_t gfn) · 87 unmodified lines
656	return MTRR_TYPE_WRBACK;	669	return MTRR_TYPE_WRBACK;
657	}	670	}
658		671
659	/* It is not covered by MTRRs. */	672	if (iter.mtrr_disabled)
660	if (iter.partial_map) {	673	return mtrr_disabled_type();
661	/*	674
662	* We just check one page, partially covered by MTRRs is	675	/*
663	* impossible.	676	* We just check one page, partially covered by MTRRs is
664	*/	677	* impossible.
665	WARN_ON(type != -1);	678	*/
666	type = mtrr_default_type(mtrr_state);	679	WARN_ON(iter.partial_map);
667	}	680
		681	/* not contained in any MTRRs. */
		682	if (type == -1)
		683	return mtrr_default_type(mtrr_state);
		684
668	return type;	685	return type;
669	}	686	}
670	EXPORT_SYMBOL_GPL(kvm_mtrr_get_guest_memory_type);	687	EXPORT_SYMBOL_GPL(kvm_mtrr_get_guest_memory_type);
@@ -689,6 +706,9 @@ bool kvm_mtrr_check_gfn_range_consistency(struct kvm_vcpu *vcpu, gfn_t gfn, · 18 unmodified lines
689	return false;	706	return false;
690	}	707	}
691		708
		709	if (iter.mtrr_disabled)
		710	return true;
		711
692	if (!iter.partial_map)	712	if (!iter.partial_map)
693	return true;	713	return true;
694		714

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

@@ -1672,7 +1672,7 @@ static void svm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0) · 1671 unmodified lines
1672	* does not do it - this results in some delay at	1672	* does not do it - this results in some delay at
1673	* reboot	1673	* reboot
1674	*/	1674	*/
1675	if (!(vcpu->kvm->arch.disabled_quirks & KVM_QUIRK_CD_NW_CLEARED))	1675	if (kvm_check_has_quirk(vcpu->kvm, KVM_X86_QUIRK_CD_NW_CLEARED))
1676	cr0 &= ~(X86_CR0_CD \| X86_CR0_NW);	1676	cr0 &= ~(X86_CR0_CD \| X86_CR0_NW);
1677	svm->vmcb->save.cr0 = cr0;	1677	svm->vmcb->save.cr0 = cr0;
1678	mark_dirty(svm->vmcb, VMCB_CR);	1678	mark_dirty(svm->vmcb, VMCB_CR);

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

 	if (kvm_read_cr0(vcpu) & X86_CR0_CD) {
 		ipat = VMX_EPT_IPAT_BIT;
-		cache = MTRR_TYPE_UNCACHABLE;
+		if (kvm_check_has_quirk(vcpu->kvm, KVM_X86_QUIRK_CD_NW_CLEARED))
+			cache = MTRR_TYPE_WRBACK;
+		else
+			cache = MTRR_TYPE_UNCACHABLE;
 		goto exit;
 	}

arch/x86/kvm/x86.h+5−0

 	return kvm_register_write(vcpu, reg, val);
 }
+static inline bool kvm_check_has_quirk(struct kvm *kvm, u64 quirk)
+{
+	return !(kvm->arch.disabled_quirks & quirk);
+}
 void kvm_before_handle_nmi(struct kvm_vcpu *vcpu);
 void kvm_after_handle_nmi(struct kvm_vcpu *vcpu);
 void kvm_set_pending_timer(struct kvm_vcpu *vcpu);

arch/x86/mm/ioremap.c+6−17

 		    !PageReserved(pfn_to_page(start_pfn + i)))
 			return 1;
-	WARN_ONCE(1, "ioremap on RAM pfn 0x%lx\n", start_pfn);
 	return 0;
 }
 	pgprot_t prot;
 	int retval;
 	void __iomem *ret_addr;
-	int ram_region;
 	/* Don't allow wraparound or zero size */
 	last_addr = phys_addr + size - 1;
 	/*
 	 * Don't allow anybody to remap normal RAM that we're using..
 	 */
-	/* First check if whole region can be identified as RAM or not */
+	pfn      = phys_addr >> PAGE_SHIFT;
-	ram_region = region_is_ram(phys_addr, size);
+	last_pfn = last_addr >> PAGE_SHIFT;
-	if (ram_region > 0) {
+	if (walk_system_ram_range(pfn, last_pfn - pfn + 1, NULL,
-		WARN_ONCE(1, "ioremap on RAM at 0x%lx - 0x%lx\n",
+					  __ioremap_check_ram) == 1) {
-				(unsigned long int)phys_addr,
+		WARN_ONCE(1, "ioremap on RAM at %pa - %pa\n",
-				(unsigned long int)last_addr);
+			  &phys_addr, &last_addr);
 		return NULL;
 	}
-	/* If could not be identified(-1), check page by page */
-	if (ram_region < 0) {
-		pfn      = phys_addr >> PAGE_SHIFT;
-		last_pfn = last_addr >> PAGE_SHIFT;
-		if (walk_system_ram_range(pfn, last_pfn - pfn + 1, NULL,
-					  __ioremap_check_ram) == 1)
-			return NULL;
-	}
 	/*
 	 * Mappings have to be page-aligned
 	 */

arch/x86/mm/mmap.c+7−0

@@ -126,3 +126,10 @@ void arch_pick_mmap_layout(struct mm_struct *mm) · 125 unmodified lines
126	mm->get_unmapped_area = arch_get_unmapped_area_topdown;	126	mm->get_unmapped_area = arch_get_unmapped_area_topdown;
127	}	127	}
128	}	128	}
		129
		130	const char arch_vma_name(struct vm_area_struct vma)
		131	{
		132	if (vma->vm_flags & VM_MPX)
		133	return "[mpx]";
		134	return NULL;
		135	}

arch/x86/mm/mpx.c+3−21

 #define CREATE_TRACE_POINTS
 #include <asm/trace/mpx.h>
-static const char *mpx_mapping_name(struct vm_area_struct *vma)
-{
-	return "[mpx]";
-}
-static struct vm_operations_struct mpx_vma_ops = {
-	.name = mpx_mapping_name,
-};
-static int is_mpx_vma(struct vm_area_struct *vma)
-{
-	return (vma->vm_ops == &mpx_vma_ops);
-}
 static inline unsigned long mpx_bd_size_bytes(struct mm_struct *mm)
 {
 	if (is_64bit_mm(mm))
 /*
  * This is really a simplified "vm_mmap". it only handles MPX
  * bounds tables (the bounds directory is user-allocated).
- *
- * Later on, we use the vma->vm_ops to uniquely identify these
- * VMAs.
  */
 static unsigned long mpx_mmap(unsigned long len)
 {
 		ret = -ENOMEM;
 		goto out;
 	}
-	vma->vm_ops = &mpx_vma_ops;
 	if (vm_flags & VM_LOCKED) {
 		up_write(&mm->mmap_sem);
 		 * so stop immediately and return an error.  This
 		 * probably results in a SIGSEGV.
 		 */
-		if (!is_mpx_vma(vma))
+		if (!(vma->vm_flags & VM_MPX))
 			return -EINVAL;
 		len = min(vma->vm_end, end) - addr;
 	 * lots of tables even though we have no actual table
 	 * entries in use.
 	 */
-	while (next && is_mpx_vma(next))
+	while (next && (next->vm_flags & VM_MPX))
 		next = next->vm_next;
-	while (prev && is_mpx_vma(prev))
+	while (prev && (prev->vm_flags & VM_MPX))
 		prev = prev->vm_prev;
 	/*
 	 * We know 'start' and 'end' lie within an area controlled

arch/x86/mm/tlb.c+1−1

@@ -117,7 +117,7 @@ static void flush_tlb_func(void *info) · 116 unmodified lines
117	} else {	117	} else {
118	unsigned long addr;	118	unsigned long addr;
119	unsigned long nr_pages =	119	unsigned long nr_pages =
120	f->flush_end - f->flush_start / PAGE_SIZE;	120	(f->flush_end - f->flush_start) / PAGE_SIZE;
121	addr = f->flush_start;	121	addr = f->flush_start;
122	while (addr < f->flush_end) {	122	while (addr < f->flush_end) {
123	__flush_tlb_single(addr);	123	__flush_tlb_single(addr);

block/bio.c+14−3

  * Allocates and returns a new bio which represents @sectors from the start of
  * @bio, and updates @bio to represent the remaining sectors.
  *
- * The newly allocated bio will point to @bio's bi_io_vec; it is the caller's
+ * Unless this is a discard request the newly allocated bio will point
- * responsibility to ensure that @bio is not freed before the split.
+ * to @bio's bi_io_vec; it is the caller's responsibility to ensure that
+ * @bio is not freed before the split.
  */
 struct bio *bio_split(struct bio *bio, int sectors,
 		      gfp_t gfp, struct bio_set *bs)
 	BUG_ON(sectors <= 0);
 	BUG_ON(sectors >= bio_sectors(bio));
-	split = bio_clone_fast(bio, gfp, bs);
+	/*
+	 * Discards need a mutable bio_vec to accommodate the payload
+	 * required by the DSM TRIM and UNMAP commands.
+	 */
+	if (bio->bi_rw & REQ_DISCARD)
+		split = bio_clone_bioset(bio, gfp, bs);
+	else
+		split = bio_clone_fast(bio, gfp, bs);
 	if (!split)
 		return NULL;
 	bio->bi_css = blkcg_css;
 	return 0;
 }
+EXPORT_SYMBOL_GPL(bio_associate_blkcg);
 /**
  * bio_associate_current - associate a bio with %current
 	bio->bi_css = task_get_css(current, blkio_cgrp_id);
 	return 0;
 }
+EXPORT_SYMBOL_GPL(bio_associate_current);
 /**
  * bio_disassociate_task - undo bio_associate_current()

block/blk-cgroup.c+5−1

 		return -EINVAL;
 	disk = get_gendisk(MKDEV(major, minor), &part);
-	if (!disk || part)
+	if (!disk)
 		return -EINVAL;
+	if (part) {
+		put_disk(disk);
+		return -EINVAL;
+	}
 	rcu_read_lock();
 	spin_lock_irq(disk->queue->queue_lock);

drivers/ata/libata-core.c+18−3

 		dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
 					 dev->max_sectors);
+	if (dev->horkage & ATA_HORKAGE_MAX_SEC_1024)
+		dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_1024,
+					 dev->max_sectors);
 	if (dev->horkage & ATA_HORKAGE_MAX_SEC_LBA48)
 		dev->max_sectors = ATA_MAX_SECTORS_LBA48;
 	{ "Slimtype DVD A  DS8A8SH", NULL,	ATA_HORKAGE_MAX_SEC_LBA48 },
 	{ "Slimtype DVD A  DS8A9SH", NULL,	ATA_HORKAGE_MAX_SEC_LBA48 },
+	/*
+	 * Causes silent data corruption with higher max sects.
+	 * http://lkml.kernel.org/g/x49wpy40ysk.fsf@segfault.boston.devel.redhat.com
+	 */
+	{ "ST380013AS",		"3.20",		ATA_HORKAGE_MAX_SEC_1024 },
 	/* Devices we expect to fail diagnostics */
 	/* Devices where NCQ should be avoided */
 	{ "ST3320[68]13AS",	"SD1[5-9]",	ATA_HORKAGE_NONCQ |
 						ATA_HORKAGE_FIRMWARE_WARN },
-	/* Seagate Momentus SpinPoint M8 seem to have FPMDA_AA issues */
+	/* drives which fail FPDMA_AA activation (some may freeze afterwards) */
 	{ "ST1000LM024 HN-M101MBB", "2AR10001",	ATA_HORKAGE_BROKEN_FPDMA_AA },
 	{ "ST1000LM024 HN-M101MBB", "2BA30001",	ATA_HORKAGE_BROKEN_FPDMA_AA },
+	{ "VB0250EAVER",	"HPG7",		ATA_HORKAGE_BROKEN_FPDMA_AA },
 	/* Blacklist entries taken from Silicon Image 3124/3132
 	   Windows driver .inf file - also several Linux problem reports */
 						ATA_HORKAGE_ZERO_AFTER_TRIM, },
 	{ "Crucial_CT*M500*",		NULL,	ATA_HORKAGE_NO_NCQ_TRIM |
 						ATA_HORKAGE_ZERO_AFTER_TRIM, },
-	{ "Micron_M5[15]0*",		"MU01",	ATA_HORKAGE_NO_NCQ_TRIM |
+	{ "Micron_M5[15]0_*",		"MU01",	ATA_HORKAGE_NO_NCQ_TRIM |
 						ATA_HORKAGE_ZERO_AFTER_TRIM, },
 	{ "Crucial_CT*M550*",		"MU01",	ATA_HORKAGE_NO_NCQ_TRIM |
 						ATA_HORKAGE_ZERO_AFTER_TRIM, },
 	{ "Samsung SSD 8*",		NULL,	ATA_HORKAGE_NO_NCQ_TRIM |
 						ATA_HORKAGE_ZERO_AFTER_TRIM, },
+	/* devices that don't properly handle TRIM commands */
+	{ "SuperSSpeed S238*",		NULL,	ATA_HORKAGE_NOTRIM, },
 	/*
 	 * As defined, the DRAT (Deterministic Read After Trim) and RZAT
 	 * (Return Zero After Trim) flags in the ATA Command Set are
 	else /* In the ancient relic department - skip all of this */
 		return 0;
-	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
+	/* On some disks, this command causes spin-up, so we need longer timeout */
+	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 15000);
 	DPRINTK("EXIT, err_mask=%x\n", err_mask);
 	return err_mask;

drivers/ata/libata-pmp.c+7−0

@@ -460,6 +460,13 @@ static void sata_pmp_quirks(struct ata_port *ap) · 459 unmodified lines
460	ATA_LFLAG_NO_SRST \|	460	ATA_LFLAG_NO_SRST \|
461	ATA_LFLAG_ASSUME_ATA;	461	ATA_LFLAG_ASSUME_ATA;
462	}	462	}
		463	} else if (vendor == 0x11ab && devid == 0x4140) {
		464	/* Marvell 4140 quirks */
		465	ata_for_each_link(link, ap, EDGE) {
		466	/* port 4 is for SEMB device and it doesn't like SRST */
		467	if (link->pmp == 4)
		468	link->flags \|= ATA_LFLAG_DISABLED;
		469	}
463	}	470	}
464	}	471	}
465		472

drivers/ata/libata-scsi.c+2−1

@@ -2568,7 +2568,8 @@ static unsigned int ata_scsiop_read_cap(struct ata_scsi_args args, u8 rbuf) · 2567 unmodified lines
2568	rbuf[14] = (lowest_aligned >> 8) & 0x3f;	2568	rbuf[14] = (lowest_aligned >> 8) & 0x3f;
2569	rbuf[15] = lowest_aligned;	2569	rbuf[15] = lowest_aligned;
2570		2570
2571	if (ata_id_has_trim(args->id)) {	2571	if (ata_id_has_trim(args->id) &&
		2572	!(dev->horkage & ATA_HORKAGE_NOTRIM)) {
2572	rbuf[14] \|= 0x80; /* LBPME */	2573	rbuf[14] \|= 0x80; /* LBPME */
2573		2574
2574	if (ata_id_has_zero_after_trim(args->id) &&	2575	if (ata_id_has_zero_after_trim(args->id) &&

drivers/ata/libata-transport.c+2−0

@@ -569,6 +569,8 @@ show_ata_dev_trim(struct device *dev, · 568 unmodified lines
569		569
570	if (!ata_id_has_trim(ata_dev->id))	570	if (!ata_id_has_trim(ata_dev->id))
571	mode = "unsupported";	571	mode = "unsupported";
		572	else if (ata_dev->horkage & ATA_HORKAGE_NOTRIM)
		573	mode = "forced_unsupported";
572	else if (ata_dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM)	574	else if (ata_dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM)
573	mode = "forced_unqueued";	575	mode = "forced_unqueued";
574	else if (ata_fpdma_dsm_supported(ata_dev))	576	else if (ata_fpdma_dsm_supported(ata_dev))

drivers/block/null_blk.c+9−9

@@ -240,19 +240,19 @@ static enum hrtimer_restart null_cmd_timer_expired(struct hrtimer *timer) · 239 unmodified lines
240	while ((entry = llist_del_all(&cq->list)) != NULL) {	240	while ((entry = llist_del_all(&cq->list)) != NULL) {
241	entry = llist_reverse_order(entry);	241	entry = llist_reverse_order(entry);
242	do {	242	do {
		243	struct request_queue *q = NULL;
		244
243	cmd = container_of(entry, struct nullb_cmd, ll_list);	245	cmd = container_of(entry, struct nullb_cmd, ll_list);
244	entry = entry->next;	246	entry = entry->next;
		247	if (cmd->rq)
		248	q = cmd->rq->q;
245	end_cmd(cmd);	249	end_cmd(cmd);
246		250
247	if (cmd->rq) {	251	if (q && !q->mq_ops && blk_queue_stopped(q)) {
248	struct request_queue *q = cmd->rq->q;	252	spin_lock(q->queue_lock);
249		253	if (blk_queue_stopped(q))
250	if (!q->mq_ops && blk_queue_stopped(q)) {	254	blk_start_queue(q);
251	spin_lock(q->queue_lock);	255	spin_unlock(q->queue_lock);
252	if (blk_queue_stopped(q))
253	blk_start_queue(q);
254	spin_unlock(q->queue_lock);
255	}
256	}	256	}
257	} while (entry);	257	} while (entry);
258	}	258	}

drivers/bluetooth/btbcm.c+5−6

@@ -472,12 +472,11 @@ int btbcm_setup_apple(struct hci_dev *hdev) · 471 unmodified lines
472		472
473	/* Read Verbose Config Version Info */	473	/* Read Verbose Config Version Info */
474	skb = btbcm_read_verbose_config(hdev);	474	skb = btbcm_read_verbose_config(hdev);
475	if (IS_ERR(skb))	475	if (!IS_ERR(skb)) {
476	return PTR_ERR(skb);	476	BT_INFO("%s: BCM: chip id %u build %4.4u", hdev->name, skb->data[1],
477		477	get_unaligned_le16(skb->data + 5));
478	BT_INFO("%s: BCM: chip id %u build %4.4u", hdev->name, skb->data[1],	478	kfree_skb(skb);
479	get_unaligned_le16(skb->data + 5));	479	}
480	kfree_skb(skb);
481		480
482	set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);	481	set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
483		482

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

 	return ret;
 }
-static void cper_print_mem(const char *pfx, const struct cper_sec_mem_err *mem)
+static void cper_print_mem(const char *pfx, const struct cper_sec_mem_err *mem,
+	int len)
 {
 	struct cper_mem_err_compact cmem;
+	/* Don't trust UEFI 2.1/2.2 structure with bad validation bits */
+	if (len == sizeof(struct cper_sec_mem_err_old) &&
+	    (mem->validation_bits & ~(CPER_MEM_VALID_RANK_NUMBER - 1))) {
+		pr_err(FW_WARN "valid bits set for fields beyond structure\n");
+		return;
+	}
 	if (mem->validation_bits & CPER_MEM_VALID_ERROR_STATUS)
 		printk("%s""error_status: 0x%016llx\n", pfx, mem->error_status);
 	if (mem->validation_bits & CPER_MEM_VALID_PA)
 	} else if (!uuid_le_cmp(*sec_type, CPER_SEC_PLATFORM_MEM)) {
 		struct cper_sec_mem_err *mem_err = (void *)(gdata + 1);
 		printk("%s""section_type: memory error\n", newpfx);
-		if (gdata->error_data_length >= sizeof(*mem_err))
+		if (gdata->error_data_length >=
-			cper_print_mem(newpfx, mem_err);
+		    sizeof(struct cper_sec_mem_err_old))
+			cper_print_mem(newpfx, mem_err,
+				       gdata->error_data_length);
 		else
 			goto err_section_too_small;
 	} else if (!uuid_le_cmp(*sec_type, CPER_SEC_PCIE)) {

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

 #define AMDGPU_MAX_VCE_HANDLES	16
 #define AMDGPU_VCE_FIRMWARE_OFFSET 256
+#define AMDGPU_VCE_HARVEST_VCE0 (1 << 0)
+#define AMDGPU_VCE_HARVEST_VCE1 (1 << 1)
 struct amdgpu_vce {
 	struct amdgpu_bo	*vcpu_bo;
 	uint64_t		gpu_addr;
 	const struct firmware	*fw;	/* VCE firmware */
 	struct amdgpu_ring	ring[AMDGPU_MAX_VCE_RINGS];
 	struct amdgpu_irq_src	irq;
+	unsigned		harvest_config;
 };
 /*

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

@@ -459,6 +459,7 @@ static int amdgpu_info_ioctl(struct drm_device dev, void data, struct drm_file · 458 unmodified lines
459	memcpy(&dev_info.cu_bitmap[0], &cu_info.bitmap[0], sizeof(cu_info.bitmap));	459	memcpy(&dev_info.cu_bitmap[0], &cu_info.bitmap[0], sizeof(cu_info.bitmap));
460	dev_info.vram_type = adev->mc.vram_type;	460	dev_info.vram_type = adev->mc.vram_type;
461	dev_info.vram_bit_width = adev->mc.vram_width;	461	dev_info.vram_bit_width = adev->mc.vram_width;
		462	dev_info.vce_harvest_config = adev->vce.harvest_config;
462		463
463	return copy_to_user(out, &dev_info,	464	return copy_to_user(out, &dev_info,
464	min((size_t)size, sizeof(dev_info))) ? -EFAULT : 0;	465	min((size_t)size, sizeof(dev_info))) ? -EFAULT : 0;

drivers/gpu/drm/amd/amdgpu/cz_dpm.c+54−16

@@ -494,29 +494,67 @@ static void cz_dpm_fini(struct amdgpu_device *adev) · 493 unmodified lines
494	amdgpu_free_extended_power_table(adev);	494	amdgpu_free_extended_power_table(adev);
495	}	495	}
496		496
		497	#define ixSMUSVI_NB_CURRENTVID 0xD8230044
		498	#define CURRENT_NB_VID_MASK 0xff000000
		499	#define CURRENT_NB_VID__SHIFT 24
		500	#define ixSMUSVI_GFX_CURRENTVID 0xD8230048
		501	#define CURRENT_GFX_VID_MASK 0xff000000
		502	#define CURRENT_GFX_VID__SHIFT 24
		503
497	static void	504	static void
498	cz_dpm_debugfs_print_current_performance_level(struct amdgpu_device *adev,	505	cz_dpm_debugfs_print_current_performance_level(struct amdgpu_device *adev,
499	struct seq_file *m)	506	struct seq_file *m)
500	{	507	{
		508	struct cz_power_info *pi = cz_get_pi(adev);
501	struct amdgpu_clock_voltage_dependency_table *table =	509	struct amdgpu_clock_voltage_dependency_table *table =
502	&adev->pm.dpm.dyn_state.vddc_dependency_on_sclk;	510	&adev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
503	u32 current_index =	511	struct amdgpu_uvd_clock_voltage_dependency_table *uvd_table =
504	(RREG32_SMC(ixTARGET_AND_CURRENT_PROFILE_INDEX) &	512	&adev->pm.dpm.dyn_state.uvd_clock_voltage_dependency_table;
505	TARGET_AND_CURRENT_PROFILE_INDEX__CURR_SCLK_INDEX_MASK) >>	513	struct amdgpu_vce_clock_voltage_dependency_table *vce_table =
506	TARGET_AND_CURRENT_PROFILE_INDEX__CURR_SCLK_INDEX__SHIFT;	514	&adev->pm.dpm.dyn_state.vce_clock_voltage_dependency_table;
507	u32 sclk, tmp;	515	u32 sclk_index = REG_GET_FIELD(RREG32_SMC(ixTARGET_AND_CURRENT_PROFILE_INDEX),
508	u16 vddc;	516	TARGET_AND_CURRENT_PROFILE_INDEX, CURR_SCLK_INDEX);
509		517	u32 uvd_index = REG_GET_FIELD(RREG32_SMC(ixTARGET_AND_CURRENT_PROFILE_INDEX_2),
510	if (current_index >= NUM_SCLK_LEVELS) {	518	TARGET_AND_CURRENT_PROFILE_INDEX_2, CURR_UVD_INDEX);
511	seq_printf(m, "invalid dpm profile %d\n", current_index);	519	u32 vce_index = REG_GET_FIELD(RREG32_SMC(ixTARGET_AND_CURRENT_PROFILE_INDEX_2),
		520	TARGET_AND_CURRENT_PROFILE_INDEX_2, CURR_VCE_INDEX);
		521	u32 sclk, vclk, dclk, ecclk, tmp;
		522	u16 vddnb, vddgfx;
		523
		524	if (sclk_index >= NUM_SCLK_LEVELS) {
		525	seq_printf(m, "invalid sclk dpm profile %d\n", sclk_index);
512	} else {	526	} else {
513	sclk = table->entries[current_index].clk;	527	sclk = table->entries[sclk_index].clk;
514	tmp = (RREG32_SMC(ixSMU_VOLTAGE_STATUS) &	528	seq_printf(m, "%u sclk: %u\n", sclk_index, sclk);
515	SMU_VOLTAGE_STATUS__SMU_VOLTAGE_CURRENT_LEVEL_MASK) >>	529	}
516	SMU_VOLTAGE_STATUS__SMU_VOLTAGE_CURRENT_LEVEL__SHIFT;	530
517	vddc = cz_convert_8bit_index_to_voltage(adev, (u16)tmp);	531	tmp = (RREG32_SMC(ixSMUSVI_NB_CURRENTVID) &
518	seq_printf(m, "power level %d sclk: %u vddc: %u\n",	532	CURRENT_NB_VID_MASK) >> CURRENT_NB_VID__SHIFT;
519	current_index, sclk, vddc);	533	vddnb = cz_convert_8bit_index_to_voltage(adev, (u16)tmp);
		534	tmp = (RREG32_SMC(ixSMUSVI_GFX_CURRENTVID) &
		535	CURRENT_GFX_VID_MASK) >> CURRENT_GFX_VID__SHIFT;
		536	vddgfx = cz_convert_8bit_index_to_voltage(adev, (u16)tmp);
		537	seq_printf(m, "vddnb: %u vddgfx: %u\n", vddnb, vddgfx);
		538
		539	seq_printf(m, "uvd %sabled\n", pi->uvd_power_gated ? "dis" : "en");
		540	if (!pi->uvd_power_gated) {
		541	if (uvd_index >= CZ_MAX_HARDWARE_POWERLEVELS) {
		542	seq_printf(m, "invalid uvd dpm level %d\n", uvd_index);
		543	} else {
		544	vclk = uvd_table->entries[uvd_index].vclk;
		545	dclk = uvd_table->entries[uvd_index].dclk;
		546	seq_printf(m, "%u uvd vclk: %u dclk: %u\n", uvd_index, vclk, dclk);
		547	}
		548	}
		549
		550	seq_printf(m, "vce %sabled\n", pi->vce_power_gated ? "dis" : "en");
		551	if (!pi->vce_power_gated) {
		552	if (vce_index >= CZ_MAX_HARDWARE_POWERLEVELS) {
		553	seq_printf(m, "invalid vce dpm level %d\n", vce_index);
		554	} else {
		555	ecclk = vce_table->entries[vce_index].ecclk;
		556	seq_printf(m, "%u vce ecclk: %u\n", vce_index, ecclk);
		557	}
520	}	558	}
521	}	559	}
522		560

drivers/gpu/drm/amd/amdgpu/dce_v10_0.c+4−0

 	struct drm_device *dev = crtc->dev;
 	struct amdgpu_device *adev = dev->dev_private;
 	struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
+	unsigned type;
 	switch (mode) {
 	case DRM_MODE_DPMS_ON:
 		dce_v10_0_vga_enable(crtc, true);
 		amdgpu_atombios_crtc_blank(crtc, ATOM_DISABLE);
 		dce_v10_0_vga_enable(crtc, false);
+		/* Make sure VBLANK interrupt is still enabled */
+		type = amdgpu_crtc_idx_to_irq_type(adev, amdgpu_crtc->crtc_id);
+		amdgpu_irq_update(adev, &adev->crtc_irq, type);
 		drm_vblank_post_modeset(dev, amdgpu_crtc->crtc_id);
 		dce_v10_0_crtc_load_lut(crtc);
 		break;

drivers/gpu/drm/amd/amdgpu/dce_v11_0.c+4−0

 	struct drm_device *dev = crtc->dev;
 	struct amdgpu_device *adev = dev->dev_private;
 	struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
+	unsigned type;
 	switch (mode) {
 	case DRM_MODE_DPMS_ON:
 		dce_v11_0_vga_enable(crtc, true);
 		amdgpu_atombios_crtc_blank(crtc, ATOM_DISABLE);
 		dce_v11_0_vga_enable(crtc, false);
+		/* Make sure VBLANK interrupt is still enabled */
+		type = amdgpu_crtc_idx_to_irq_type(adev, amdgpu_crtc->crtc_id);
+		amdgpu_irq_update(adev, &adev->crtc_irq, type);
 		drm_vblank_post_modeset(dev, amdgpu_crtc->crtc_id);
 		dce_v11_0_crtc_load_lut(crtc);
 		break;

drivers/gpu/drm/amd/amdgpu/vce_v3_0.c+48−0

@@ -35,6 +35,8 @@ · 34 unmodified lines
35	#include "oss/oss_2_0_d.h"	35	#include "oss/oss_2_0_d.h"
36	#include "oss/oss_2_0_sh_mask.h"	36	#include "oss/oss_2_0_sh_mask.h"
37	#include "gca/gfx_8_0_d.h"	37	#include "gca/gfx_8_0_d.h"
		38	#include "smu/smu_7_1_2_d.h"
		39	#include "smu/smu_7_1_2_sh_mask.h"
38		40
39	#define GRBM_GFX_INDEX__VCE_INSTANCE__SHIFT 0x04	41	#define GRBM_GFX_INDEX__VCE_INSTANCE__SHIFT 0x04
40	#define GRBM_GFX_INDEX__VCE_INSTANCE_MASK 0x10	42	#define GRBM_GFX_INDEX__VCE_INSTANCE_MASK 0x10
@@ -112,6 +114,10 @@ static int vce_v3_0_start(struct amdgpu_device *adev) · 71 unmodified lines
112		114
113	mutex_lock(&adev->grbm_idx_mutex);	115	mutex_lock(&adev->grbm_idx_mutex);
114	for (idx = 0; idx < 2; ++idx) {	116	for (idx = 0; idx < 2; ++idx) {
		117
		118	if (adev->vce.harvest_config & (1 << idx))
		119	continue;
		120
115	if(idx == 0)	121	if(idx == 0)
116	WREG32_P(mmGRBM_GFX_INDEX, 0,	122	WREG32_P(mmGRBM_GFX_INDEX, 0,
117	~GRBM_GFX_INDEX__VCE_INSTANCE_MASK);	123	~GRBM_GFX_INDEX__VCE_INSTANCE_MASK);
@@ -190,10 +196,52 @@ static int vce_v3_0_start(struct amdgpu_device *adev) · 72 unmodified lines
190	return 0;	196	return 0;
191	}	197	}
192		198
		199	#define ixVCE_HARVEST_FUSE_MACRO__ADDRESS 0xC0014074
		200	#define VCE_HARVEST_FUSE_MACRO__SHIFT 27
		201	#define VCE_HARVEST_FUSE_MACRO__MASK 0x18000000
		202
		203	static unsigned vce_v3_0_get_harvest_config(struct amdgpu_device *adev)
		204	{
		205	u32 tmp;
		206	unsigned ret;
		207
		208	if (adev->flags & AMDGPU_IS_APU)
		209	tmp = (RREG32_SMC(ixVCE_HARVEST_FUSE_MACRO__ADDRESS) &
		210	VCE_HARVEST_FUSE_MACRO__MASK) >>
		211	VCE_HARVEST_FUSE_MACRO__SHIFT;
		212	else
		213	tmp = (RREG32_SMC(ixCC_HARVEST_FUSES) &
		214	CC_HARVEST_FUSES__VCE_DISABLE_MASK) >>
		215	CC_HARVEST_FUSES__VCE_DISABLE__SHIFT;
		216
		217	switch (tmp) {
		218	case 1:
		219	ret = AMDGPU_VCE_HARVEST_VCE0;
		220	break;
		221	case 2:
		222	ret = AMDGPU_VCE_HARVEST_VCE1;
		223	break;
		224	case 3:
		225	ret = AMDGPU_VCE_HARVEST_VCE0 \| AMDGPU_VCE_HARVEST_VCE1;
		226	break;
		227	default:
		228	ret = 0;
		229	}
		230
		231	return ret;
		232	}
		233
193	static int vce_v3_0_early_init(void *handle)	234	static int vce_v3_0_early_init(void *handle)
194	{	235	{
195	struct amdgpu_device adev = (struct amdgpu_device )handle;	236	struct amdgpu_device adev = (struct amdgpu_device )handle;
196		237
		238	adev->vce.harvest_config = vce_v3_0_get_harvest_config(adev);
		239
		240	if ((adev->vce.harvest_config &
		241	(AMDGPU_VCE_HARVEST_VCE0 \| AMDGPU_VCE_HARVEST_VCE1)) ==
		242	(AMDGPU_VCE_HARVEST_VCE0 \| AMDGPU_VCE_HARVEST_VCE1))
		243	return -ENOENT;
		244
197	vce_v3_0_set_ring_funcs(adev);	245	vce_v3_0_set_ring_funcs(adev);
198	vce_v3_0_set_irq_funcs(adev);	246	vce_v3_0_set_irq_funcs(adev);
199		247

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c+1−0

@@ -355,6 +355,7 @@ int atmel_hlcdc_crtc_create(struct drm_device *dev) · 354 unmodified lines
355	planes->overlays[i]->base.possible_crtcs = 1 << crtc->id;	355	planes->overlays[i]->base.possible_crtcs = 1 << crtc->id;
356		356
357	drm_crtc_helper_add(&crtc->base, &lcdc_crtc_helper_funcs);	357	drm_crtc_helper_add(&crtc->base, &lcdc_crtc_helper_funcs);
		358	drm_crtc_vblank_reset(&crtc->base);
358		359
359	dc->crtc = &crtc->base;	360	dc->crtc = &crtc->base;
360		361

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c+6−6

 	pm_runtime_enable(dev->dev);
-	ret = atmel_hlcdc_dc_modeset_init(dev);
+	ret = drm_vblank_init(dev, 1);
 	if (ret < 0) {
-		dev_err(dev->dev, "failed to initialize mode setting\n");
+		dev_err(dev->dev, "failed to initialize vblank\n");
 		goto err_periph_clk_disable;
 	}
-	drm_mode_config_reset(dev);
+	ret = atmel_hlcdc_dc_modeset_init(dev);
-	ret = drm_vblank_init(dev, 1);
 	if (ret < 0) {
-		dev_err(dev->dev, "failed to initialize vblank\n");
+		dev_err(dev->dev, "failed to initialize mode setting\n");
 		goto err_periph_clk_disable;
 	}
+	drm_mode_config_reset(dev);
 	pm_runtime_get_sync(dev->dev);
 	ret = drm_irq_install(dev, dc->hlcdc->irq);
 	pm_runtime_put_sync(dev->dev);

drivers/gpu/drm/drm_crtc.c+1−4

 		if (encoder->funcs->reset)
 			encoder->funcs->reset(encoder);
-	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
-		connector->status = connector_status_unknown;
 		if (connector->funcs->reset)
 			connector->funcs->reset(connector);
-	}
 }
 EXPORT_SYMBOL(drm_mode_config_reset);

drivers/gpu/drm/i915/intel_uncore.c+19−7

 	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_reg_read *reg = data;
 	struct register_whitelist const *entry = whitelist;
+	unsigned size;
+	u64 offset;
 	int i, ret = 0;
 	for (i = 0; i < ARRAY_SIZE(whitelist); i++, entry++) {
-		if (entry->offset == reg->offset &&
+		if (entry->offset == (reg->offset & -entry->size) &&
 		    (1 << INTEL_INFO(dev)->gen & entry->gen_bitmask))
 			break;
 	}
 	if (i == ARRAY_SIZE(whitelist))
 		return -EINVAL;
+	/* We use the low bits to encode extra flags as the register should
+	 * be naturally aligned (and those that are not so aligned merely
+	 * limit the available flags for that register).
+	 */
+	offset = entry->offset;
+	size = entry->size;
+	size |= reg->offset ^ offset;
 	intel_runtime_pm_get(dev_priv);
-	switch (entry->size) {
+	switch (size) {
+	case 8 | 1:
+		reg->val = I915_READ64_2x32(offset, offset+4);
+		break;
 	case 8:
-		reg->val = I915_READ64(reg->offset);
+		reg->val = I915_READ64(offset);
 		break;
 	case 4:
-		reg->val = I915_READ(reg->offset);
+		reg->val = I915_READ(offset);
 		break;
 	case 2:
-		reg->val = I915_READ16(reg->offset);
+		reg->val = I915_READ16(offset);
 		break;
 	case 1:
-		reg->val = I915_READ8(reg->offset);
+		reg->val = I915_READ8(offset);
 		break;
 	default:
-		MISSING_CASE(entry->size);
 		ret = -EINVAL;
 		goto out;
 	}

drivers/gpu/drm/ttm/ttm_bo_util.c+2−1

 	else if (boot_cpu_data.x86 > 3)
 		tmp = pgprot_noncached(tmp);
 #endif
-#if defined(__ia64__) || defined(__arm__) || defined(__powerpc__)
+#if defined(__ia64__) || defined(__arm__) || defined(__aarch64__) || \
+    defined(__powerpc__)
 	if (caching_flags & TTM_PL_FLAG_WC)
 		tmp = pgprot_writecombine(tmp);
 	else

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

@@ -356,6 +356,8 @@ static int cp2112_read(struct cp2112_device dev, u8 data, size_t size) · 355 unmodified lines
356	struct cp2112_force_read_report report;	356	struct cp2112_force_read_report report;
357	int ret;	357	int ret;
358		358
		359	if (size > sizeof(dev->read_data))
		360	size = sizeof(dev->read_data);
359	report.report = CP2112_DATA_READ_FORCE_SEND;	361	report.report = CP2112_DATA_READ_FORCE_SEND;
360	report.length = cpu_to_be16(size);	362	report.length = cpu_to_be16(size);
361		363

drivers/hid/hid-multitouch.c+7−0

 	/*
 	 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN"
 	 * for the stylus.
+	 * The check for mt_report_id ensures we don't process
+	 * HID_DG_CONTACTCOUNT from the pen report as it is outside the physical
+	 * collection, but within the report ID.
 	 */
 	if (field->physical == HID_DG_STYLUS)
 		return 0;
+	else if ((field->physical == 0) &&
+		 (field->report->id != td->mt_report_id) &&
+		 (td->mt_report_id != -1))
+		return 0;
 	if (field->application == HID_DG_TOUCHSCREEN ||
 	    field->application == HID_DG_TOUCHPAD)

drivers/hid/usbhid/hid-quirks.c+3−0

 	{ USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOUSE_C05A, HID_QUIRK_ALWAYS_POLL },
 	{ USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOUSE_C06A, HID_QUIRK_ALWAYS_POLL },
 	{ USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS, HID_QUIRK_NOGET },
+	{ USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_SURFACE_PRO_2, HID_QUIRK_NO_INIT_REPORTS },
+	{ USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_2, HID_QUIRK_NO_INIT_REPORTS },
+	{ USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TOUCH_COVER_2, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_3, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_3_JP, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER, HID_QUIRK_NO_INIT_REPORTS },

drivers/hid/wacom_sys.c+4−2

 	pad_input_dev = NULL;
 	wacom_wac->pad_registered = false;
 fail_register_pad_input:
-	input_unregister_device(touch_input_dev);
+	if (touch_input_dev)
+		input_unregister_device(touch_input_dev);
 	wacom_wac->touch_input = NULL;
 	wacom_wac->touch_registered = false;
 fail_register_touch_input:
-	input_unregister_device(pen_input_dev);
+	if (pen_input_dev)
+		input_unregister_device(pen_input_dev);
 	wacom_wac->pen_input = NULL;
 	wacom_wac->pen_registered = false;
 fail_register_pen_input:

drivers/hid/wacom_wac.c+3−0

 			features->x_max = 4096;
 			features->y_max = 4096;
 		}
+		else if (features->pktlen == WACOM_PKGLEN_BBTOUCH) {
+			features->device_type |= WACOM_DEVICETYPE_PAD;
+		}
 	}
 	/*

drivers/iio/accel/mma8452.c+4−4

@@ -557,21 +557,21 @@ static void mma8452_transient_interrupt(struct iio_dev *indio_dev) · 556 unmodified lines
557	if (src & MMA8452_TRANSIENT_SRC_XTRANSE)	557	if (src & MMA8452_TRANSIENT_SRC_XTRANSE)
558	iio_push_event(indio_dev,	558	iio_push_event(indio_dev,
559	IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X,	559	IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X,
560	IIO_EV_TYPE_THRESH,	560	IIO_EV_TYPE_MAG,
561	IIO_EV_DIR_RISING),	561	IIO_EV_DIR_RISING),
562	ts);	562	ts);
563		563
564	if (src & MMA8452_TRANSIENT_SRC_YTRANSE)	564	if (src & MMA8452_TRANSIENT_SRC_YTRANSE)
565	iio_push_event(indio_dev,	565	iio_push_event(indio_dev,
566	IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_Y,	566	IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_Y,
567	IIO_EV_TYPE_THRESH,	567	IIO_EV_TYPE_MAG,
568	IIO_EV_DIR_RISING),	568	IIO_EV_DIR_RISING),
569	ts);	569	ts);
570		570
571	if (src & MMA8452_TRANSIENT_SRC_ZTRANSE)	571	if (src & MMA8452_TRANSIENT_SRC_ZTRANSE)
572	iio_push_event(indio_dev,	572	iio_push_event(indio_dev,
573	IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_Z,	573	IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_Z,
574	IIO_EV_TYPE_THRESH,	574	IIO_EV_TYPE_MAG,
575	IIO_EV_DIR_RISING),	575	IIO_EV_DIR_RISING),
576	ts);	576	ts);
577	}	577	}
@@ -644,7 +644,7 @@ static int mma8452_reg_access_dbg(struct iio_dev *indio_dev, · 66 unmodified lines
644		644
645	static const struct iio_event_spec mma8452_transient_event[] = {	645	static const struct iio_event_spec mma8452_transient_event[] = {
646	{	646	{
647	.type = IIO_EV_TYPE_THRESH,	647	.type = IIO_EV_TYPE_MAG,
648	.dir = IIO_EV_DIR_RISING,	648	.dir = IIO_EV_DIR_RISING,
649	.mask_separate = BIT(IIO_EV_INFO_ENABLE),	649	.mask_separate = BIT(IIO_EV_INFO_ENABLE),
650	.mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) \|	650	.mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) \|

drivers/iio/adc/mcp320x.c+2−0

@@ -299,6 +299,8 @@ static int mcp320x_probe(struct spi_device *spi) · 298 unmodified lines
299	indio_dev->channels = chip_info->channels;	299	indio_dev->channels = chip_info->channels;
300	indio_dev->num_channels = chip_info->num_channels;	300	indio_dev->num_channels = chip_info->num_channels;
301		301
		302	adc->chip_info = chip_info;
		303
302	adc->transfer[0].tx_buf = &adc->tx_buf;	304	adc->transfer[0].tx_buf = &adc->tx_buf;
303	adc->transfer[0].len = sizeof(adc->tx_buf);	305	adc->transfer[0].len = sizeof(adc->tx_buf);
304	adc->transfer[1].rx_buf = adc->rx_buf;	306	adc->transfer[1].rx_buf = adc->rx_buf;

drivers/iio/adc/vf610_adc.c+1−1

@@ -635,7 +635,7 @@ static int vf610_adc_reg_access(struct iio_dev *indio_dev, · 634 unmodified lines
635	struct vf610_adc *info = iio_priv(indio_dev);	635	struct vf610_adc *info = iio_priv(indio_dev);
636		636
637	if ((readval == NULL) \|\|	637	if ((readval == NULL) \|\|
638	(!(reg % 4) \|\| (reg > VF610_REG_ADC_PCTL)))	638	((reg % 4) \|\| (reg > VF610_REG_ADC_PCTL)))
639	return -EINVAL;	639	return -EINVAL;
640		640
641	*readval = readl(info->regs + reg);	641	*readval = readl(info->regs + reg);

drivers/iio/light/stk3310.c+13−13

 			      int *val, int *val2)
 {
 	u8 reg;
-	u16 buf;
+	__be16 buf;
 	int ret;
 	struct stk3310_data *data = iio_priv(indio_dev);
 		dev_err(&data->client->dev, "register read failed\n");
 		return ret;
 	}
-	*val = swab16(buf);
+	*val = be16_to_cpu(buf);
 	return IIO_VAL_INT;
 }
 			       int val, int val2)
 {
 	u8 reg;
-	u16 buf;
+	__be16 buf;
 	int ret;
 	unsigned int index;
 	struct stk3310_data *data = iio_priv(indio_dev);
 	else
 		return -EINVAL;
-	buf = swab16(val);
+	buf = cpu_to_be16(val);
 	ret = regmap_bulk_write(data->regmap, reg, &buf, 2);
 	if (ret < 0)
 		dev_err(&client->dev, "failed to set PS threshold!\n");
 			    int *val, int *val2, long mask)
 {
 	u8 reg;
-	u16 buf;
+	__be16 buf;
 	int ret;
 	unsigned int index;
 	struct stk3310_data *data = iio_priv(indio_dev);
 			mutex_unlock(&data->lock);
 			return ret;
 		}
-		*val = swab16(buf);
+		*val = be16_to_cpu(buf);
 		mutex_unlock(&data->lock);
 		return IIO_VAL_INT;
 	case IIO_CHAN_INFO_INT_TIME:
 	if (ret < 0)
 		return ret;
-	ret = iio_device_register(indio_dev);
+	if (client->irq < 0)
-	if (ret < 0) {
-		dev_err(&client->dev, "device_register failed\n");
-		stk3310_set_state(data, STK3310_STATE_STANDBY);
-	}
-	if (client->irq <= 0)
 		client->irq = stk3310_gpio_probe(client);
 	if (client->irq >= 0) {
 					client->irq);
 	}
+	ret = iio_device_register(indio_dev);
+	if (ret < 0) {
+		dev_err(&client->dev, "device_register failed\n");
+		stk3310_set_state(data, STK3310_STATE_STANDBY);
+	}
 	return ret;
 }

drivers/iio/magnetometer/Kconfig+1−0

@@ -90,6 +90,7 @@ config IIO_ST_MAGN_SPI_3AXIS · 89 unmodified lines
90	config BMC150_MAGN	90	config BMC150_MAGN
91	tristate "Bosch BMC150 Magnetometer Driver"	91	tristate "Bosch BMC150 Magnetometer Driver"
92	depends on I2C	92	depends on I2C
		93	select REGMAP_I2C
93	select IIO_BUFFER	94	select IIO_BUFFER
94	select IIO_TRIGGERED_BUFFER	95	select IIO_TRIGGERED_BUFFER
95	help	96	help

drivers/iio/magnetometer/bmc150_magn.c+2−2

@@ -706,11 +706,11 @@ static int bmc150_magn_init(struct bmc150_magn_data *data) · 705 unmodified lines
706	goto err_poweroff;	706	goto err_poweroff;
707	}	707	}
708	if (chip_id != BMC150_MAGN_CHIP_ID_VAL) {	708	if (chip_id != BMC150_MAGN_CHIP_ID_VAL) {
709	dev_err(&data->client->dev, "Invalid chip id 0x%x\n", ret);	709	dev_err(&data->client->dev, "Invalid chip id 0x%x\n", chip_id);
710	ret = -ENODEV;	710	ret = -ENODEV;
711	goto err_poweroff;	711	goto err_poweroff;
712	}	712	}
713	dev_dbg(&data->client->dev, "Chip id %x\n", ret);	713	dev_dbg(&data->client->dev, "Chip id %x\n", chip_id);
714		714
715	preset = bmc150_magn_presets_table[BMC150_MAGN_DEFAULT_PRESET];	715	preset = bmc150_magn_presets_table[BMC150_MAGN_DEFAULT_PRESET];
716	ret = bmc150_magn_set_odr(data, preset.odr);	716	ret = bmc150_magn_set_odr(data, preset.odr);

drivers/iio/magnetometer/mmc35240.c+7−5

@@ -202,8 +202,8 @@ static int mmc35240_hw_set(struct mmc35240_data *data, bool set) · 201 unmodified lines
202	coil_bit = MMC35240_CTRL0_RESET_BIT;	202	coil_bit = MMC35240_CTRL0_RESET_BIT;
203		203
204	return regmap_update_bits(data->regmap, MMC35240_REG_CTRL0,	204	return regmap_update_bits(data->regmap, MMC35240_REG_CTRL0,
205	MMC35240_CTRL0_REFILL_BIT,	205	coil_bit, coil_bit);
206	coil_bit);	206
207	}	207	}
208		208
209	static int mmc35240_init(struct mmc35240_data *data)	209	static int mmc35240_init(struct mmc35240_data *data)
@@ -222,14 +222,15 @@ static int mmc35240_init(struct mmc35240_data *data) · 12 unmodified lines
222		222
223	/*	223	/*
224	* make sure we restore sensor characteristics, by doing	224	* make sure we restore sensor characteristics, by doing
225	* a RESET/SET sequence	225	* a SET/RESET sequence, the axis polarity being naturally
		226	* aligned after RESET
226	*/	227	*/
227	ret = mmc35240_hw_set(data, false);	228	ret = mmc35240_hw_set(data, true);
228	if (ret < 0)	229	if (ret < 0)
229	return ret;	230	return ret;
230	usleep_range(MMC53240_WAIT_SET_RESET, MMC53240_WAIT_SET_RESET + 1);	231	usleep_range(MMC53240_WAIT_SET_RESET, MMC53240_WAIT_SET_RESET + 1);
231		232
232	ret = mmc35240_hw_set(data, true);	233	ret = mmc35240_hw_set(data, false);
233	if (ret < 0)	234	if (ret < 0)
234	return ret;	235	return ret;
235		236
@@ -503,6 +504,7 @@ static int mmc35240_probe(struct i2c_client *client, · 267 unmodified lines
503	}	504	}
504		505
505	data = iio_priv(indio_dev);	506	data = iio_priv(indio_dev);
		507	i2c_set_clientdata(client, indio_dev);
506	data->client = client;	508	data->client = client;
507	data->regmap = regmap;	509	data->regmap = regmap;
508	data->res = MMC35240_16_BITS_SLOW;	510	data->res = MMC35240_16_BITS_SLOW;

drivers/iio/temperature/mlx90614.c+1−1

@@ -204,7 +204,7 @@ static int mlx90614_read_raw(struct iio_dev *indio_dev, · 203 unmodified lines
204	*val = ret;	204	*val = ret;
205	return IIO_VAL_INT;	205	return IIO_VAL_INT;
206	case IIO_CHAN_INFO_OFFSET:	206	case IIO_CHAN_INFO_OFFSET:
207	*val = 13657;	207	*val = -13657;
208	*val2 = 500000;	208	*val2 = 500000;
209	return IIO_VAL_INT_PLUS_MICRO;	209	return IIO_VAL_INT_PLUS_MICRO;
210	case IIO_CHAN_INFO_SCALE:	210	case IIO_CHAN_INFO_SCALE:

drivers/infiniband/hw/ipath/ipath_driver.c+4−2

  * SOFTWARE.
  */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/sched.h>
 #include <linux/spinlock.h>
 #include <linux/idr.h>
 	u32 bar0 = 0, bar1 = 0;
 #ifdef CONFIG_X86_64
-	if (WARN(pat_enabled(),
+	if (pat_enabled()) {
-		 "ipath needs PAT disabled, boot with nopat kernel parameter\n")) {
+		pr_warn("ipath needs PAT disabled, boot with nopat kernel parameter\n");
 		ret = -ENODEV;
 		goto bail;
 	}

drivers/input/input-leds.c+14−2

 {
 }
+static int input_leds_get_count(struct input_dev *dev)
+{
+	unsigned int led_code;
+	int count = 0;
+	for_each_set_bit(led_code, dev->ledbit, LED_CNT)
+		if (input_led_info[led_code].name)
+			count++;
+	return count;
+}
 static int input_leds_connect(struct input_handler *handler,
 			      struct input_dev *dev,
 			      const struct input_device_id *id)
 	int led_no;
 	int error;
-	num_leds = bitmap_weight(dev->ledbit, LED_CNT);
+	num_leds = input_leds_get_count(dev);
 	if (!num_leds)
 		return -ENXIO;
 		led->handle = &leds->handle;
 		led->code = led_code;
-		if (WARN_ON(!input_led_info[led_code].name))
+		if (!input_led_info[led_code].name)
 			continue;
 		led->cdev.name = kasprintf(GFP_KERNEL, "%s::%s",

drivers/input/mouse/elantech.c+8−5

 	struct input_dev *dev = psmouse->dev;
 	struct elantech_data *etd = psmouse->private;
 	unsigned int x_min = 0, y_min = 0, x_max = 0, y_max = 0, width = 0;
-	unsigned int x_res = 0, y_res = 0;
+	unsigned int x_res = 31, y_res = 31;
 	if (elantech_set_range(psmouse, &x_min, &y_min, &x_max, &y_max, &width))
 		return -1;
 		/* For X to recognize me as touchpad. */
 		input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
 		input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
-		input_abs_set_res(dev, ABS_X, x_res);
-		input_abs_set_res(dev, ABS_Y, y_res);
 		/*
 		 * range of pressure and width is the same as v2,
 		 * report ABS_PRESSURE, ABS_TOOL_WIDTH for compatibility.
 		input_mt_init_slots(dev, ETP_MAX_FINGERS, 0);
 		input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
 		input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
-		input_abs_set_res(dev, ABS_MT_POSITION_X, x_res);
-		input_abs_set_res(dev, ABS_MT_POSITION_Y, y_res);
 		input_set_abs_params(dev, ABS_MT_PRESSURE, ETP_PMIN_V2,
 				     ETP_PMAX_V2, 0, 0);
 		/*
 		break;
 	}
+	input_abs_set_res(dev, ABS_X, x_res);
+	input_abs_set_res(dev, ABS_Y, y_res);
+	if (etd->hw_version > 1) {
+		input_abs_set_res(dev, ABS_MT_POSITION_X, x_res);
+		input_abs_set_res(dev, ABS_MT_POSITION_Y, y_res);
+	}
 	etd->y_max = y_max;
 	etd->width = width;

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

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	*/	15	*/
16		16
17	#include <linux/kernel.h>	17	#include <linux/kernel.h>
		18	#include <linux/dmi.h>
18	#include <linux/i2c.h>	19	#include <linux/i2c.h>
19	#include <linux/input.h>	20	#include <linux/input.h>
20	#include <linux/input/mt.h>	21	#include <linux/input/mt.h>
@@ -34,6 +35,7 @@ struct goodix_ts_data { · 13 unmodified lines
34	int abs_y_max;	35	int abs_y_max;
35	unsigned int max_touch_num;	36	unsigned int max_touch_num;
36	unsigned int int_trigger_type;	37	unsigned int int_trigger_type;
		38	bool rotated_screen;
37	};	39	};
38		40
39	#define GOODIX_MAX_HEIGHT 4096	41	#define GOODIX_MAX_HEIGHT 4096
@@ -60,6 +62,30 @@ static const unsigned long goodix_irq_flags[] = { · 20 unmodified lines
60	IRQ_TYPE_LEVEL_HIGH,	62	IRQ_TYPE_LEVEL_HIGH,
61	};	63	};
62		64
		65	/*
		66	* Those tablets have their coordinates origin at the bottom right
		67	* of the tablet, as if rotated 180 degrees
		68	*/
		69	static const struct dmi_system_id rotated_screen[] = {
		70	#if defined(CONFIG_DMI) && defined(CONFIG_X86)
		71	{
		72	.ident = "WinBook TW100",
		73	.matches = {
		74	DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),
		75	DMI_MATCH(DMI_PRODUCT_NAME, "TW100")
		76	}
		77	},
		78	{
		79	.ident = "WinBook TW700",
		80	.matches = {
		81	DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),
		82	DMI_MATCH(DMI_PRODUCT_NAME, "TW700")
		83	},
		84	},
		85	#endif
		86	{}
		87	};
		88
63	/**	89	/**
64	* goodix_i2c_read - read data from a register of the i2c slave device.	90	* goodix_i2c_read - read data from a register of the i2c slave device.
65	*	91	*
@@ -129,6 +155,11 @@ static void goodix_ts_report_touch(struct goodix_ts_data ts, u8 coor_data) · 63 unmodified lines
129	int input_y = get_unaligned_le16(&coor_data[3]);	155	int input_y = get_unaligned_le16(&coor_data[3]);
130	int input_w = get_unaligned_le16(&coor_data[5]);	156	int input_w = get_unaligned_le16(&coor_data[5]);
131		157
		158	if (ts->rotated_screen) {
		159	input_x = ts->abs_x_max - input_x;
		160	input_y = ts->abs_y_max - input_y;
		161	}
		162
132	input_mt_slot(ts->input_dev, id);	163	input_mt_slot(ts->input_dev, id);
133	input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);	164	input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
134	input_report_abs(ts->input_dev, ABS_MT_POSITION_X, input_x);	165	input_report_abs(ts->input_dev, ABS_MT_POSITION_X, input_x);
@@ -223,6 +254,11 @@ static void goodix_read_config(struct goodix_ts_data *ts) · 88 unmodified lines
223	ts->abs_y_max = GOODIX_MAX_HEIGHT;	254	ts->abs_y_max = GOODIX_MAX_HEIGHT;
224	ts->max_touch_num = GOODIX_MAX_CONTACTS;	255	ts->max_touch_num = GOODIX_MAX_CONTACTS;
225	}	256	}
		257
		258	ts->rotated_screen = dmi_check_system(rotated_screen);
		259	if (ts->rotated_screen)
		260	dev_dbg(&ts->client->dev,
		261	"Applying '180 degrees rotated screen' quirk\n");
226	}	262	}
227		263
228	/**	264	/**

drivers/input/touchscreen/usbtouchscreen.c+3−0

@@ -627,6 +627,9 @@ static int dmc_tsc10_init(struct usbtouch_usb *usbtouch) · 626 unmodified lines
627	goto err_out;	627	goto err_out;
628	}	628	}
629		629
		630	/* TSC-25 data sheet specifies a delay after the RESET command */
		631	msleep(150);
		632
630	/* set coordinate output rate */	633	/* set coordinate output rate */
631	buf[0] = buf[1] = 0xFF;	634	buf[0] = buf[1] = 0xFF;
632	ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),	635	ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),

drivers/input/touchscreen/zforce_ts.c+1−1

@@ -429,7 +429,7 @@ static int zforce_read_packet(struct zforce_ts ts, u8 buf) · 428 unmodified lines
429	goto unlock;	429	goto unlock;
430	}	430	}
431		431
432	if (buf[PAYLOAD_LENGTH] == 0) {	432	if (buf[PAYLOAD_LENGTH] == 0 \|\| buf[PAYLOAD_LENGTH] > FRAME_MAXSIZE) {
433	dev_err(&client->dev, "invalid payload length: %d\n",	433	dev_err(&client->dev, "invalid payload length: %d\n",
434	buf[PAYLOAD_LENGTH]);	434	buf[PAYLOAD_LENGTH]);
435	ret = -EIO;	435	ret = -EIO;

drivers/iommu/arm-smmu-v3.c+46−14

  * Stream table.
  *
  * Linear: Enough to cover 1 << IDR1.SIDSIZE entries
- * 2lvl: 8k L1 entries, 256 lazy entries per table (each table covers a PCI bus)
+ * 2lvl: 128k L1 entries,
+ *       256 lazy entries per table (each table covers a PCI bus)
  */
-#define STRTAB_L1_SZ_SHIFT		16
+#define STRTAB_L1_SZ_SHIFT		20
 #define STRTAB_SPLIT			8
 #define STRTAB_L1_DESC_DWORDS		1
 #define ARM64_TCR_TG0_SHIFT		14
 #define ARM64_TCR_TG0_MASK		0x3UL
 #define CTXDESC_CD_0_TCR_IRGN0_SHIFT	8
-#define ARM64_TCR_IRGN0_SHIFT		24
+#define ARM64_TCR_IRGN0_SHIFT		8
 #define ARM64_TCR_IRGN0_MASK		0x3UL
 #define CTXDESC_CD_0_TCR_ORGN0_SHIFT	10
-#define ARM64_TCR_ORGN0_SHIFT		26
+#define ARM64_TCR_ORGN0_SHIFT		10
 #define ARM64_TCR_ORGN0_MASK		0x3UL
 #define CTXDESC_CD_0_TCR_SH0_SHIFT	12
 #define ARM64_TCR_SH0_SHIFT		12
 #define ARM_SMMU_FEAT_HYP		(1 << 12)
 	u32				features;
+#define ARM_SMMU_OPT_SKIP_PREFETCH	(1 << 0)
+	u32				options;
 	struct arm_smmu_cmdq		cmdq;
 	struct arm_smmu_evtq		evtq;
 	struct arm_smmu_priq		priq;
 static DEFINE_SPINLOCK(arm_smmu_devices_lock);
 static LIST_HEAD(arm_smmu_devices);
+struct arm_smmu_option_prop {
+	u32 opt;
+	const char *prop;
+};
+static struct arm_smmu_option_prop arm_smmu_options[] = {
+	{ ARM_SMMU_OPT_SKIP_PREFETCH, "hisilicon,broken-prefetch-cmd" },
+	{ 0, NULL},
+};
 static struct arm_smmu_domain *to_smmu_domain(struct iommu_domain *dom)
 {
 	return container_of(dom, struct arm_smmu_domain, domain);
 }
+static void parse_driver_options(struct arm_smmu_device *smmu)
+{
+	int i = 0;
+	do {
+		if (of_property_read_bool(smmu->dev->of_node,
+						arm_smmu_options[i].prop)) {
+			smmu->options |= arm_smmu_options[i].opt;
+			dev_notice(smmu->dev, "option %s\n",
+				arm_smmu_options[i].prop);
+		}
+	} while (arm_smmu_options[++i].opt);
+}
 /* Low-level queue manipulation functions */
 static bool queue_full(struct arm_smmu_queue *q)
 {
 	arm_smmu_sync_ste_for_sid(smmu, sid);
 	/* It's likely that we'll want to use the new STE soon */
-	arm_smmu_cmdq_issue_cmd(smmu, &prefetch_cmd);
+	if (!(smmu->options & ARM_SMMU_OPT_SKIP_PREFETCH))
+		arm_smmu_cmdq_issue_cmd(smmu, &prefetch_cmd);
 }
 static void arm_smmu_init_bypass_stes(u64 *strtab, unsigned int nent)
 		return 0;
 	size = 1 << (STRTAB_SPLIT + ilog2(STRTAB_STE_DWORDS) + 3);
-	strtab = &cfg->strtab[sid >> STRTAB_SPLIT << STRTAB_L1_DESC_DWORDS];
+	strtab = &cfg->strtab[(sid >> STRTAB_SPLIT) * STRTAB_L1_DESC_DWORDS];
 	desc->span = STRTAB_SPLIT + 1;
 	desc->l2ptr = dma_zalloc_coherent(smmu->dev, size, &desc->l2ptr_dma,
 {
 	void *strtab;
 	u64 reg;
-	u32 size;
+	u32 size, l1size;
 	int ret;
 	struct arm_smmu_strtab_cfg *cfg = &smmu->strtab_cfg;
 	/* Calculate the L1 size, capped to the SIDSIZE */
 	size = STRTAB_L1_SZ_SHIFT - (ilog2(STRTAB_L1_DESC_DWORDS) + 3);
 	size = min(size, smmu->sid_bits - STRTAB_SPLIT);
-	if (size + STRTAB_SPLIT < smmu->sid_bits)
+	cfg->num_l1_ents = 1 << size;
+	size += STRTAB_SPLIT;
+	if (size < smmu->sid_bits)
 		dev_warn(smmu->dev,
 			 "2-level strtab only covers %u/%u bits of SID\n",
-			 size + STRTAB_SPLIT, smmu->sid_bits);
+			 size, smmu->sid_bits);
-	cfg->num_l1_ents = 1 << size;
+	l1size = cfg->num_l1_ents * (STRTAB_L1_DESC_DWORDS << 3);
-	size = cfg->num_l1_ents * (STRTAB_L1_DESC_DWORDS << 3);
+	strtab = dma_zalloc_coherent(smmu->dev, l1size, &cfg->strtab_dma,
-	strtab = dma_zalloc_coherent(smmu->dev, size, &cfg->strtab_dma,
 				     GFP_KERNEL);
 	if (!strtab) {
 		dev_err(smmu->dev,
 	ret = arm_smmu_init_l1_strtab(smmu);
 	if (ret)
 		dma_free_coherent(smmu->dev,
-				  cfg->num_l1_ents *
+				  l1size,
-				  (STRTAB_L1_DESC_DWORDS << 3),
 				  strtab,
 				  cfg->strtab_dma);
 	return ret;
 	if (irq > 0)
 		smmu->gerr_irq = irq;
+	parse_driver_options(smmu);
 	/* Probe the h/w */
 	ret = arm_smmu_device_probe(smmu);
 	if (ret)

drivers/iommu/intel-iommu.c+6−3

 static void domain_exit(struct dmar_domain *domain)
 {
+	struct dmar_drhd_unit *drhd;
+	struct intel_iommu *iommu;
 	struct page *freelist = NULL;
-	int i;
 	/* Domain 0 is reserved, so dont process it */
 	if (!domain)
 	/* clear attached or cached domains */
 	rcu_read_lock();
-	for_each_set_bit(i, domain->iommu_bmp, g_num_of_iommus)
+	for_each_active_iommu(iommu, drhd)
-		iommu_detach_domain(domain, g_iommus[i]);
+		if (domain_type_is_vm(domain) ||
+		    test_bit(iommu->seq_id, domain->iommu_bmp))
+			iommu_detach_domain(domain, iommu);
 	rcu_read_unlock();
 	dma_free_pagelist(freelist);

drivers/isdn/gigaset/ser-gigaset.c+10−25

 	cs->hw.ser->tty = tty;
 	atomic_set(&cs->hw.ser->refcnt, 1);
 	init_completion(&cs->hw.ser->dead_cmp);
 	tty->disc_data = cs;
+	/* Set the amount of data we're willing to receive per call
+	 * from the hardware driver to half of the input buffer size
+	 * to leave some reserve.
+	 * Note: We don't do flow control towards the hardware driver.
+	 * If more data is received than will fit into the input buffer,
+	 * it will be dropped and an error will be logged. This should
+	 * never happen as the device is slow and the buffer size ample.
+	 */
+	tty->receive_room = RBUFSIZE/2;
 	/* OK.. Initialization of the datastructures and the HW is done.. Now
 	 * startup system and notify the LL that we are ready to run
 	 */
 	return 0;
 }
-/*
- * Read on the tty.
- * Unused, received data goes only to the Gigaset driver.
- */
-static ssize_t
-gigaset_tty_read(struct tty_struct *tty, struct file *file,
-		 unsigned char __user *buf, size_t count)
-{
-	return -EAGAIN;
-}
-/*
- * Write on the tty.
- * Unused, transmit data comes only from the Gigaset driver.
- */
-static ssize_t
-gigaset_tty_write(struct tty_struct *tty, struct file *file,
-		  const unsigned char *buf, size_t count)
-{
-	return -EAGAIN;
-}
 /*
  * Ioctl on the tty.
  * Called in process context only.
 	.open		= gigaset_tty_open,
 	.close		= gigaset_tty_close,
 	.hangup		= gigaset_tty_hangup,
-	.read		= gigaset_tty_read,
-	.write		= gigaset_tty_write,
 	.ioctl		= gigaset_tty_ioctl,
 	.receive_buf	= gigaset_tty_receive,
 	.write_wakeup	= gigaset_tty_wakeup,

drivers/md/bitmap.c+17−11

 	bitmap_super_t *sb;
 	unsigned long chunksize, daemon_sleep, write_behind;
-	bitmap->storage.sb_page = alloc_page(GFP_KERNEL);
+	bitmap->storage.sb_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
 	if (bitmap->storage.sb_page == NULL)
 		return -ENOMEM;
 	bitmap->storage.sb_page->index = 0;
 	sb->state = cpu_to_le32(bitmap->flags);
 	bitmap->events_cleared = bitmap->mddev->events;
 	sb->events_cleared = cpu_to_le64(bitmap->mddev->events);
+	bitmap->mddev->bitmap_info.nodes = 0;
 	kunmap_atomic(sb);
 	unsigned long sectors_reserved = 0;
 	int err = -EINVAL;
 	struct page *sb_page;
+	loff_t offset = bitmap->mddev->bitmap_info.offset;
 	if (!bitmap->storage.file && !bitmap->mddev->bitmap_info.offset) {
 		chunksize = 128 * 1024 * 1024;
 		bm_blocks = ((bm_blocks+7) >> 3) + sizeof(bitmap_super_t);
 		/* to 4k blocks */
 		bm_blocks = DIV_ROUND_UP_SECTOR_T(bm_blocks, 4096);
-		bitmap->mddev->bitmap_info.offset += bitmap->cluster_slot * (bm_blocks << 3);
+		offset = bitmap->mddev->bitmap_info.offset + (bitmap->cluster_slot * (bm_blocks << 3));
 		pr_info("%s:%d bm slot: %d offset: %llu\n", __func__, __LINE__,
-			bitmap->cluster_slot, (unsigned long long)bitmap->mddev->bitmap_info.offset);
+			bitmap->cluster_slot, offset);
 	}
 	if (bitmap->storage.file) {
 				bitmap, bytes, sb_page);
 	} else {
 		err = read_sb_page(bitmap->mddev,
-				   bitmap->mddev->bitmap_info.offset,
+				   offset,
 				   sb_page,
 				   0, sizeof(bitmap_super_t));
 	}
 	daemon_sleep = le32_to_cpu(sb->daemon_sleep) * HZ;
 	write_behind = le32_to_cpu(sb->write_behind);
 	sectors_reserved = le32_to_cpu(sb->sectors_reserved);
-	nodes = le32_to_cpu(sb->nodes);
+	/* XXX: This is a hack to ensure that we don't use clustering
-	strlcpy(bitmap->mddev->bitmap_info.cluster_name, sb->cluster_name, 64);
+	 *  in case:
+	 *	- dm-raid is in use and
+	 *	- the nodes written in bitmap_sb is erroneous.
+	 */
+	if (!bitmap->mddev->sync_super) {
+		nodes = le32_to_cpu(sb->nodes);
+		strlcpy(bitmap->mddev->bitmap_info.cluster_name,
+				sb->cluster_name, 64);
+	}
 	/* verify that the bitmap-specific fields are valid */
 	if (sb->magic != cpu_to_le32(BITMAP_MAGIC))
 	kunmap_atomic(sb);
 	/* Assiging chunksize is required for "re_read" */
 	bitmap->mddev->bitmap_info.chunksize = chunksize;
-	if (nodes && (bitmap->cluster_slot < 0)) {
+	if (err == 0 && nodes && (bitmap->cluster_slot < 0)) {
 		err = md_setup_cluster(bitmap->mddev, nodes);
 		if (err) {
 			pr_err("%s: Could not setup cluster service (%d)\n",
 	if (IS_ERR(bitmap))
 		return PTR_ERR(bitmap);
-	rv = bitmap_read_sb(bitmap);
-	if (rv)
-		goto err;
 	rv = bitmap_init_from_disk(bitmap, 0);
 	if (rv)
 		goto err;

drivers/md/md-cluster.c+11−1

 /* md_cluster_info flags */
 #define		MD_CLUSTER_WAITING_FOR_NEWDISK		1
+#define		MD_CLUSTER_SUSPEND_READ_BALANCING	2
 struct md_cluster_info {
 static void recover_prep(void *arg)
 {
+	struct mddev *mddev = arg;
+	struct md_cluster_info *cinfo = mddev->cluster_info;
+	set_bit(MD_CLUSTER_SUSPEND_READ_BALANCING, &cinfo->state);
 }
 static void recover_slot(void *arg, struct dlm_slot *slot)
 	cinfo->slot_number = our_slot;
 	complete(&cinfo->completion);
+	clear_bit(MD_CLUSTER_SUSPEND_READ_BALANCING, &cinfo->state);
 }
 static const struct dlm_lockspace_ops md_ls_ops = {
 	resync_send(mddev, RESYNCING, 0, 0);
 }
-static int area_resyncing(struct mddev *mddev, sector_t lo, sector_t hi)
+static int area_resyncing(struct mddev *mddev, int direction,
+		sector_t lo, sector_t hi)
 {
 	struct md_cluster_info *cinfo = mddev->cluster_info;
 	int ret = 0;
 	struct suspend_info *s;
+	if ((direction == READ) &&
+		test_bit(MD_CLUSTER_SUSPEND_READ_BALANCING, &cinfo->state))
+		return 1;
 	spin_lock_irq(&cinfo->suspend_lock);
 	if (list_empty(&cinfo->suspend_list))
 		goto out;

drivers/md/md-cluster.h+1−1

@@ -18,7 +18,7 @@ struct md_cluster_operations { · 17 unmodified lines
18	int (metadata_update_start)(struct mddev mddev);	18	int (metadata_update_start)(struct mddev mddev);
19	int (metadata_update_finish)(struct mddev mddev);	19	int (metadata_update_finish)(struct mddev mddev);
20	int (metadata_update_cancel)(struct mddev mddev);	20	int (metadata_update_cancel)(struct mddev mddev);
21	int (area_resyncing)(struct mddev mddev, sector_t lo, sector_t hi);	21	int (area_resyncing)(struct mddev mddev, int direction, sector_t lo, sector_t hi);
22	int (add_new_disk_start)(struct mddev mddev, struct md_rdev *rdev);	22	int (add_new_disk_start)(struct mddev mddev, struct md_rdev *rdev);
23	int (add_new_disk_finish)(struct mddev mddev);	23	int (add_new_disk_finish)(struct mddev mddev);
24	int (new_disk_ack)(struct mddev mddev, bool ack);	24	int (new_disk_ack)(struct mddev mddev, bool ack);

drivers/md/md.c+3−1

 {
 	struct md_personality *pers = mddev->pers;
 	mddev_detach(mddev);
+	/* Ensure ->event_work is done */
+	flush_workqueue(md_misc_wq);
 	spin_lock(&mddev->lock);
 	mddev->ready = 0;
 	mddev->pers = NULL;
 	err = request_module("md-cluster");
 	if (err) {
 		pr_err("md-cluster module not found.\n");
-		return err;
+		return -ENOENT;
 	}
 	spin_lock(&pers_lock);

drivers/md/raid1.c+5−4

 		spin_lock_irqsave(&conf->device_lock, flags);
 		if (r1_bio->mddev->degraded == conf->raid_disks ||
 		    (r1_bio->mddev->degraded == conf->raid_disks-1 &&
-		     !test_bit(Faulty, &conf->mirrors[mirror].rdev->flags)))
+		     test_bit(In_sync, &conf->mirrors[mirror].rdev->flags)))
 			uptodate = 1;
 		spin_unlock_irqrestore(&conf->device_lock, flags);
 	}
 	if ((conf->mddev->recovery_cp < this_sector + sectors) ||
 	    (mddev_is_clustered(conf->mddev) &&
-	    md_cluster_ops->area_resyncing(conf->mddev, this_sector,
+	    md_cluster_ops->area_resyncing(conf->mddev, READ, this_sector,
 		    this_sector + sectors)))
 		choose_first = 1;
 	else
 	    ((bio_end_sector(bio) > mddev->suspend_lo &&
 	    bio->bi_iter.bi_sector < mddev->suspend_hi) ||
 	    (mddev_is_clustered(mddev) &&
-	     md_cluster_ops->area_resyncing(mddev, bio->bi_iter.bi_sector, bio_end_sector(bio))))) {
+	     md_cluster_ops->area_resyncing(mddev, WRITE,
+		     bio->bi_iter.bi_sector, bio_end_sector(bio))))) {
 		/* As the suspend_* range is controlled by
 		 * userspace, we want an interruptible
 		 * wait.
 			if (bio_end_sector(bio) <= mddev->suspend_lo ||
 			    bio->bi_iter.bi_sector >= mddev->suspend_hi ||
 			    (mddev_is_clustered(mddev) &&
-			     !md_cluster_ops->area_resyncing(mddev,
+			     !md_cluster_ops->area_resyncing(mddev, WRITE,
 				     bio->bi_iter.bi_sector, bio_end_sector(bio))))
 				break;
 			schedule();

drivers/md/raid10.c+4−1

 			/* far_copies must be 1 */
 			conf->prev.stride = conf->dev_sectors;
 	}
+	conf->reshape_safe = conf->reshape_progress;
 	spin_lock_init(&conf->device_lock);
 	INIT_LIST_HEAD(&conf->retry_list);
 		}
 		conf->offset_diff = min_offset_diff;
-		conf->reshape_safe = conf->reshape_progress;
 		clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
 		clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
 		set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
 		conf->reshape_progress = size;
 	} else
 		conf->reshape_progress = 0;
+	conf->reshape_safe = conf->reshape_progress;
 	spin_unlock_irq(&conf->device_lock);
 	if (mddev->delta_disks && mddev->bitmap) {
 		rdev->new_data_offset = rdev->data_offset;
 	smp_wmb();
 	conf->reshape_progress = MaxSector;
+	conf->reshape_safe = MaxSector;
 	mddev->reshape_position = MaxSector;
 	spin_unlock_irq(&conf->device_lock);
 	return ret;
 	md_finish_reshape(conf->mddev);
 	smp_wmb();
 	conf->reshape_progress = MaxSector;
+	conf->reshape_safe = MaxSector;
 	spin_unlock_irq(&conf->device_lock);
 	/* read-ahead size must cover two whole stripes, which is

drivers/md/raid5.c+28−7

@@ -2162,6 +2162,9 @@ static int resize_stripes(struct r5conf *conf, int newsize) · 2161 unmodified lines
2162	if (!sc)	2162	if (!sc)
2163	return -ENOMEM;	2163	return -ENOMEM;
2164		2164
		2165	/* Need to ensure auto-resizing doesn't interfere */
		2166	mutex_lock(&conf->cache_size_mutex);
		2167
2165	for (i = conf->max_nr_stripes; i; i--) {	2168	for (i = conf->max_nr_stripes; i; i--) {
2166	nsh = alloc_stripe(sc, GFP_KERNEL);	2169	nsh = alloc_stripe(sc, GFP_KERNEL);
2167	if (!nsh)	2170	if (!nsh)
@@ -2178,6 +2181,7 @@ static int resize_stripes(struct r5conf *conf, int newsize) · 10 unmodified lines
2178	kmem_cache_free(sc, nsh);	2181	kmem_cache_free(sc, nsh);
2179	}	2182	}
2180	kmem_cache_destroy(sc);	2183	kmem_cache_destroy(sc);
		2184	mutex_unlock(&conf->cache_size_mutex);
2181	return -ENOMEM;	2185	return -ENOMEM;
2182	}	2186	}
2183	/* Step 2 - Must use GFP_NOIO now.	2187	/* Step 2 - Must use GFP_NOIO now.
@@ -2224,6 +2228,7 @@ static int resize_stripes(struct r5conf *conf, int newsize) · 40 unmodified lines
2224	} else	2228	} else
2225	err = -ENOMEM;	2229	err = -ENOMEM;
2226		2230
		2231	mutex_unlock(&conf->cache_size_mutex);
2227	/* Step 4, return new stripes to service */	2232	/* Step 4, return new stripes to service */
2228	while(!list_empty(&newstripes)) {	2233	while(!list_empty(&newstripes)) {
2229	nsh = list_entry(newstripes.next, struct stripe_head, lru);	2234	nsh = list_entry(newstripes.next, struct stripe_head, lru);
@@ -4061,8 +4066,10 @@ static void analyse_stripe(struct stripe_head sh, struct stripe_head_state s) · 1831 unmodified lines
4061	&first_bad, &bad_sectors))	4066	&first_bad, &bad_sectors))
4062	set_bit(R5_ReadRepl, &dev->flags);	4067	set_bit(R5_ReadRepl, &dev->flags);
4063	else {	4068	else {
4064	if (rdev)	4069	if (rdev && !test_bit(Faulty, &rdev->flags))
4065	set_bit(R5_NeedReplace, &dev->flags);	4070	set_bit(R5_NeedReplace, &dev->flags);
		4071	else
		4072	clear_bit(R5_NeedReplace, &dev->flags);
4066	rdev = rcu_dereference(conf->disks[i].rdev);	4073	rdev = rcu_dereference(conf->disks[i].rdev);
4067	clear_bit(R5_ReadRepl, &dev->flags);	4074	clear_bit(R5_ReadRepl, &dev->flags);
4068	}	4075	}
@@ -5857,12 +5864,14 @@ static void raid5d(struct md_thread *thread) · 1788 unmodified lines
5857	pr_debug("%d stripes handled\n", handled);	5864	pr_debug("%d stripes handled\n", handled);
5858		5865
5859	spin_unlock_irq(&conf->device_lock);	5866	spin_unlock_irq(&conf->device_lock);
5860	if (test_and_clear_bit(R5_ALLOC_MORE, &conf->cache_state)) {	5867	if (test_and_clear_bit(R5_ALLOC_MORE, &conf->cache_state) &&
		5868	mutex_trylock(&conf->cache_size_mutex)) {
5861	grow_one_stripe(conf, __GFP_NOWARN);	5869	grow_one_stripe(conf, __GFP_NOWARN);
5862	/* Set flag even if allocation failed. This helps	5870	/* Set flag even if allocation failed. This helps
5863	* slow down allocation requests when mem is short	5871	* slow down allocation requests when mem is short
5864	*/	5872	*/
5865	set_bit(R5_DID_ALLOC, &conf->cache_state);	5873	set_bit(R5_DID_ALLOC, &conf->cache_state);
		5874	mutex_unlock(&conf->cache_size_mutex);
5866	}	5875	}
5867		5876
5868	async_tx_issue_pending_all();	5877	async_tx_issue_pending_all();
@@ -5894,18 +5903,22 @@ raid5_set_cache_size(struct mddev *mddev, int size) · 25 unmodified lines
5894	return -EINVAL;	5903	return -EINVAL;
5895		5904
5896	conf->min_nr_stripes = size;	5905	conf->min_nr_stripes = size;
		5906	mutex_lock(&conf->cache_size_mutex);
5897	while (size < conf->max_nr_stripes &&	5907	while (size < conf->max_nr_stripes &&
5898	drop_one_stripe(conf))	5908	drop_one_stripe(conf))
5899	;	5909	;
		5910	mutex_unlock(&conf->cache_size_mutex);
5900		5911
5901		5912
5902	err = md_allow_write(mddev);	5913	err = md_allow_write(mddev);
5903	if (err)	5914	if (err)
5904	return err;	5915	return err;
5905		5916
		5917	mutex_lock(&conf->cache_size_mutex);
5906	while (size > conf->max_nr_stripes)	5918	while (size > conf->max_nr_stripes)
5907	if (!grow_one_stripe(conf, GFP_KERNEL))	5919	if (!grow_one_stripe(conf, GFP_KERNEL))
5908	break;	5920	break;
		5921	mutex_unlock(&conf->cache_size_mutex);
5909		5922
5910	return 0;	5923	return 0;
5911	}	5924	}
@@ -6371,11 +6384,18 @@ static unsigned long raid5_cache_scan(struct shrinker *shrink, · 459 unmodified lines
6371	struct shrink_control *sc)	6384	struct shrink_control *sc)
6372	{	6385	{
6373	struct r5conf *conf = container_of(shrink, struct r5conf, shrinker);	6386	struct r5conf *conf = container_of(shrink, struct r5conf, shrinker);
6374	int ret = 0;	6387	unsigned long ret = SHRINK_STOP;
6375	while (ret < sc->nr_to_scan) {	6388
6376	if (drop_one_stripe(conf) == 0)	6389	if (mutex_trylock(&conf->cache_size_mutex)) {
6377	return SHRINK_STOP;	6390	ret= 0;
6378	ret++;	6391	while (ret < sc->nr_to_scan) {
		6392	if (drop_one_stripe(conf) == 0) {
		6393	ret = SHRINK_STOP;
		6394	break;
		6395	}
		6396	ret++;
		6397	}
		6398	mutex_unlock(&conf->cache_size_mutex);
6379	}	6399	}
6380	return ret;	6400	return ret;
6381	}	6401	}
@@ -6444,6 +6464,7 @@ static struct r5conf setup_conf(struct mddev mddev) · 62 unmodified lines
6444	goto abort;	6464	goto abort;
6445	spin_lock_init(&conf->device_lock);	6465	spin_lock_init(&conf->device_lock);
6446	seqcount_init(&conf->gen_lock);	6466	seqcount_init(&conf->gen_lock);
		6467	mutex_init(&conf->cache_size_mutex);
6447	init_waitqueue_head(&conf->wait_for_quiescent);	6468	init_waitqueue_head(&conf->wait_for_quiescent);
6448	for (i = 0; i < NR_STRIPE_HASH_LOCKS; i++) {	6469	for (i = 0; i < NR_STRIPE_HASH_LOCKS; i++) {
6449	init_waitqueue_head(&conf->wait_for_stripe[i]);	6470	init_waitqueue_head(&conf->wait_for_stripe[i]);

drivers/md/raid5.h+2−1

@@ -482,7 +482,8 @@ struct r5conf { · 481 unmodified lines
482	*/	482	*/
483	int active_name;	483	int active_name;
484	char cache_name[2][32];	484	char cache_name[2][32];
485	struct kmem_cache slab_cache; / for allocating stripes */	485	struct kmem_cache slab_cache; / for allocating stripes */
		486	struct mutex cache_size_mutex; /* Protect changes to cache size */
486		487
487	int seq_flush, seq_write;	488	int seq_flush, seq_write;
488	int quiesce;	489	int quiesce;

drivers/media/pci/ivtv/ivtvfb.c+9−6

     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/fb.h>
 {
 	int rc;
+#ifdef CONFIG_X86_64
+	if (pat_enabled()) {
+		pr_warn("ivtvfb needs PAT disabled, boot with nopat kernel parameter\n");
+		return -ENODEV;
+	}
+#endif
 	if (itv->osd_info) {
 		IVTVFB_ERR("Card %d already initialised\n", ivtvfb_card_id);
 		return -EBUSY;
 	int registered = 0;
 	int err;
-#ifdef CONFIG_X86_64
-	if (WARN(pat_enabled(),
-		 "ivtvfb needs PAT disabled, boot with nopat kernel parameter\n")) {
-		return -ENODEV;
-	}
-#endif
 	if (ivtvfb_card_id < -1 || ivtvfb_card_id >= IVTV_MAX_CARDS) {
 		printk(KERN_ERR "ivtvfb:  ivtvfb_card_id parameter is out of range (valid range: -1 - %d)\n",

drivers/misc/mei/main.c+1−1

@@ -682,7 +682,7 @@ int mei_register(struct mei_device dev, struct device parent) · 681 unmodified lines
682	/* Fill in the data structures */	682	/* Fill in the data structures */
683	devno = MKDEV(MAJOR(mei_devt), dev->minor);	683	devno = MKDEV(MAJOR(mei_devt), dev->minor);
684	cdev_init(&dev->cdev, &mei_fops);	684	cdev_init(&dev->cdev, &mei_fops);
685	dev->cdev.owner = mei_fops.owner;	685	dev->cdev.owner = parent->driver->owner;
686		686
687	/* Add the device */	687	/* Add the device */
688	ret = cdev_add(&dev->cdev, devno, 1);	688	ret = cdev_add(&dev->cdev, devno, 1);

drivers/misc/mic/scif/scif_nodeqp.c+5−10

 }
 static struct scatterlist *
-scif_p2p_setsg(void __iomem *va, int page_size, int page_cnt)
+scif_p2p_setsg(phys_addr_t pa, int page_size, int page_cnt)
 {
 	struct scatterlist *sg;
 	struct page *page;
 		return NULL;
 	sg_init_table(sg, page_cnt);
 	for (i = 0; i < page_cnt; i++) {
-		page = vmalloc_to_page((void __force *)va);
+		page = pfn_to_page(pa >> PAGE_SHIFT);
-		if (!page)
-			goto p2p_sg_err;
 		sg_set_page(&sg[i], page, page_size, 0);
-		va += page_size;
+		pa += page_size;
 	}
 	return sg;
-p2p_sg_err:
-	kfree(sg);
-	return NULL;
 }
 /* Init p2p mappings required to access peerdev from scifdev */
 	p2p = kzalloc(sizeof(*p2p), GFP_KERNEL);
 	if (!p2p)
 		return NULL;
-	p2p->ppi_sg[SCIF_PPI_MMIO] = scif_p2p_setsg(psdev->mmio->va,
+	p2p->ppi_sg[SCIF_PPI_MMIO] = scif_p2p_setsg(psdev->mmio->pa,
 						    PAGE_SIZE, num_mmio_pages);
 	if (!p2p->ppi_sg[SCIF_PPI_MMIO])
 		goto free_p2p;
 	p2p->sg_nentries[SCIF_PPI_MMIO] = num_mmio_pages;
 	sg_page_shift = get_order(min(psdev->aper->len, (u64)(1 << 30)));
 	num_aper_chunks = num_aper_pages >> (sg_page_shift - PAGE_SHIFT);
-	p2p->ppi_sg[SCIF_PPI_APER] = scif_p2p_setsg(psdev->aper->va,
+	p2p->ppi_sg[SCIF_PPI_APER] = scif_p2p_setsg(psdev->aper->pa,
 						    1 << sg_page_shift,
 						    num_aper_chunks);
 	p2p->sg_nentries[SCIF_PPI_APER] = num_aper_chunks;

drivers/mmc/card/block.c+2−0

@@ -208,6 +208,8 @@ static ssize_t power_ro_lock_show(struct device *dev, · 207 unmodified lines
208		208
209	ret = snprintf(buf, PAGE_SIZE, "%d\n", locked);	209	ret = snprintf(buf, PAGE_SIZE, "%d\n", locked);
210		210
		211	mmc_blk_put(md);
		212
211	return ret;	213	return ret;
212	}	214	}
213		215

drivers/mmc/host/Kconfig+1−0

@@ -779,6 +779,7 @@ config MMC_TOSHIBA_PCI · 778 unmodified lines
779		779
780	config MMC_MTK	780	config MMC_MTK
781	tristate "MediaTek SD/MMC Card Interface support"	781	tristate "MediaTek SD/MMC Card Interface support"
		782	depends on HAS_DMA
782	help	783	help
783	This selects the MediaTek(R) Secure digital and Multimedia card Interface.	784	This selects the MediaTek(R) Secure digital and Multimedia card Interface.
784	If you have a machine with a integrated SD/MMC card reader, say Y or M here.	785	If you have a machine with a integrated SD/MMC card reader, say Y or M here.

drivers/mmc/host/omap_hsmmc.c+6−5

 		if (status & (CTO_EN | CCRC_EN))
 			end_cmd = 1;
+		if (host->data || host->response_busy) {
+			end_trans = !end_cmd;
+			host->response_busy = 0;
+		}
 		if (status & (CTO_EN | DTO_EN))
 			hsmmc_command_incomplete(host, -ETIMEDOUT, end_cmd);
-		else if (status & (CCRC_EN | DCRC_EN))
+		else if (status & (CCRC_EN | DCRC_EN | DEB_EN | CEB_EN |
+				   BADA_EN))
 			hsmmc_command_incomplete(host, -EILSEQ, end_cmd);
 		if (status & ACE_EN) {
 			}
 			dev_dbg(mmc_dev(host->mmc), "AC12 err: 0x%x\n", ac12);
 		}
-		if (host->data || host->response_busy) {
-			end_trans = !end_cmd;
-			host->response_busy = 0;
-		}
 	}
 	OMAP_HSMMC_WRITE(host->base, STAT, status);

drivers/mmc/host/sdhci-esdhc-imx.c+104−106

@@ -581,13 +581,8 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg) · 580 unmodified lines
581	static unsigned int esdhc_pltfm_get_max_clock(struct sdhci_host *host)	581	static unsigned int esdhc_pltfm_get_max_clock(struct sdhci_host *host)
582	{	582	{
583	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);	583	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
584	struct pltfm_imx_data *imx_data = pltfm_host->priv;
585	struct esdhc_platform_data *boarddata = &imx_data->boarddata;
586		584
587	if (boarddata->f_max && (boarddata->f_max < pltfm_host->clock))	585	return pltfm_host->clock;
588	return boarddata->f_max;
589	else
590	return pltfm_host->clock;
591	}	586	}
592		587
593	static unsigned int esdhc_pltfm_get_min_clock(struct sdhci_host *host)	588	static unsigned int esdhc_pltfm_get_min_clock(struct sdhci_host *host)
@@ -878,34 +873,19 @@ static const struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = { · 284 unmodified lines
878	static int	873	static int
879	sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,	874	sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,
880	struct sdhci_host *host,	875	struct sdhci_host *host,
881	struct esdhc_platform_data *boarddata)	876	struct pltfm_imx_data *imx_data)
882	{	877	{
883	struct device_node *np = pdev->dev.of_node;	878	struct device_node *np = pdev->dev.of_node;
884		879	struct esdhc_platform_data *boarddata = &imx_data->boarddata;
885	if (!np)	880	int ret;
886	return -ENODEV;
887
888	if (of_get_property(np, "non-removable", NULL))
889	boarddata->cd_type = ESDHC_CD_PERMANENT;
890
891	if (of_get_property(np, "fsl,cd-controller", NULL))
892	boarddata->cd_type = ESDHC_CD_CONTROLLER;
893		881
894	if (of_get_property(np, "fsl,wp-controller", NULL))	882	if (of_get_property(np, "fsl,wp-controller", NULL))
895	boarddata->wp_type = ESDHC_WP_CONTROLLER;	883	boarddata->wp_type = ESDHC_WP_CONTROLLER;
896		884
897	boarddata->cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
898	if (gpio_is_valid(boarddata->cd_gpio))
899	boarddata->cd_type = ESDHC_CD_GPIO;
900
901	boarddata->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);	885	boarddata->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
902	if (gpio_is_valid(boarddata->wp_gpio))	886	if (gpio_is_valid(boarddata->wp_gpio))
903	boarddata->wp_type = ESDHC_WP_GPIO;	887	boarddata->wp_type = ESDHC_WP_GPIO;
904		888
905	of_property_read_u32(np, "bus-width", &boarddata->max_bus_width);
906
907	of_property_read_u32(np, "max-frequency", &boarddata->f_max);
908
909	if (of_find_property(np, "no-1-8-v", NULL))	889	if (of_find_property(np, "no-1-8-v", NULL))
910	boarddata->support_vsel = false;	890	boarddata->support_vsel = false;
911	else	891	else
@@ -916,29 +896,119 @@ sdhci_esdhc_imx_probe_dt(struct platform_device *pdev, · 4 unmodified lines
916		896
917	mmc_of_parse_voltage(np, &host->ocr_mask);	897	mmc_of_parse_voltage(np, &host->ocr_mask);
918		898
		899	/* sdr50 and sdr104 needs work on 1.8v signal voltage */
		900	if ((boarddata->support_vsel) && esdhc_is_usdhc(imx_data) &&
		901	!IS_ERR(imx_data->pins_default)) {
		902	imx_data->pins_100mhz = pinctrl_lookup_state(imx_data->pinctrl,
		903	ESDHC_PINCTRL_STATE_100MHZ);
		904	imx_data->pins_200mhz = pinctrl_lookup_state(imx_data->pinctrl,
		905	ESDHC_PINCTRL_STATE_200MHZ);
		906	if (IS_ERR(imx_data->pins_100mhz) \|\|
		907	IS_ERR(imx_data->pins_200mhz)) {
		908	dev_warn(mmc_dev(host->mmc),
		909	"could not get ultra high speed state, work on normal mode\n");
		910	/*
		911	* fall back to not support uhs by specify no 1.8v quirk
		912	*/
		913	host->quirks2 \|= SDHCI_QUIRK2_NO_1_8_V;
		914	}
		915	} else {
		916	host->quirks2 \|= SDHCI_QUIRK2_NO_1_8_V;
		917	}
		918
919	/* call to generic mmc_of_parse to support additional capabilities */	919	/* call to generic mmc_of_parse to support additional capabilities */
920	return mmc_of_parse(host->mmc);	920	ret = mmc_of_parse(host->mmc);
		921	if (ret)
		922	return ret;
		923
		924	if (!IS_ERR_VALUE(mmc_gpio_get_cd(host->mmc)))
		925	host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION;
		926
		927	return 0;
921	}	928	}
922	#else	929	#else
923	static inline int	930	static inline int
924	sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,	931	sdhci_esdhc_imx_probe_dt(struct platform_device *pdev,
925	struct sdhci_host *host,	932	struct sdhci_host *host,
926	struct esdhc_platform_data *boarddata)	933	struct pltfm_imx_data *imx_data)
927	{	934	{
928	return -ENODEV;	935	return -ENODEV;
929	}	936	}
930	#endif	937	#endif
931		938
		939	static int sdhci_esdhc_imx_probe_nondt(struct platform_device *pdev,
		940	struct sdhci_host *host,
		941	struct pltfm_imx_data *imx_data)
		942	{
		943	struct esdhc_platform_data *boarddata = &imx_data->boarddata;
		944	int err;
		945
		946	if (!host->mmc->parent->platform_data) {
		947	dev_err(mmc_dev(host->mmc), "no board data!\n");
		948	return -EINVAL;
		949	}
		950
		951	imx_data->boarddata = ((struct esdhc_platform_data )
		952	host->mmc->parent->platform_data);
		953	/* write_protect */
		954	if (boarddata->wp_type == ESDHC_WP_GPIO) {
		955	err = mmc_gpio_request_ro(host->mmc, boarddata->wp_gpio);
		956	if (err) {
		957	dev_err(mmc_dev(host->mmc),
		958	"failed to request write-protect gpio!\n");
		959	return err;
		960	}
		961	host->mmc->caps2 \|= MMC_CAP2_RO_ACTIVE_HIGH;
		962	}
		963
		964	/* card_detect */
		965	switch (boarddata->cd_type) {
		966	case ESDHC_CD_GPIO:
		967	err = mmc_gpio_request_cd(host->mmc, boarddata->cd_gpio, 0);
		968	if (err) {
		969	dev_err(mmc_dev(host->mmc),
		970	"failed to request card-detect gpio!\n");
		971	return err;
		972	}
		973	/* fall through */
		974
		975	case ESDHC_CD_CONTROLLER:
		976	/* we have a working card_detect back */
		977	host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION;
		978	break;
		979
		980	case ESDHC_CD_PERMANENT:
		981	host->mmc->caps \|= MMC_CAP_NONREMOVABLE;
		982	break;
		983
		984	case ESDHC_CD_NONE:
		985	break;
		986	}
		987
		988	switch (boarddata->max_bus_width) {
		989	case 8:
		990	host->mmc->caps \|= MMC_CAP_8_BIT_DATA \| MMC_CAP_4_BIT_DATA;
		991	break;
		992	case 4:
		993	host->mmc->caps \|= MMC_CAP_4_BIT_DATA;
		994	break;
		995	case 1:
		996	default:
		997	host->quirks \|= SDHCI_QUIRK_FORCE_1_BIT_DATA;
		998	break;
		999	}
		1000
		1001	return 0;
		1002	}
		1003
932	static int sdhci_esdhc_imx_probe(struct platform_device *pdev)	1004	static int sdhci_esdhc_imx_probe(struct platform_device *pdev)
933	{	1005	{
934	const struct of_device_id *of_id =	1006	const struct of_device_id *of_id =
935	of_match_device(imx_esdhc_dt_ids, &pdev->dev);	1007	of_match_device(imx_esdhc_dt_ids, &pdev->dev);
936	struct sdhci_pltfm_host *pltfm_host;	1008	struct sdhci_pltfm_host *pltfm_host;
937	struct sdhci_host *host;	1009	struct sdhci_host *host;
938	struct esdhc_platform_data *boarddata;
939	int err;	1010	int err;
940	struct pltfm_imx_data *imx_data;	1011	struct pltfm_imx_data *imx_data;
941	bool dt = true;
942		1012
943	host = sdhci_pltfm_init(pdev, &sdhci_esdhc_imx_pdata, 0);	1013	host = sdhci_pltfm_init(pdev, &sdhci_esdhc_imx_pdata, 0);
944	if (IS_ERR(host))	1014	if (IS_ERR(host))
@@ -1030,84 +1100,12 @@ static int sdhci_esdhc_imx_probe(struct platform_device *pdev) · 85 unmodified lines
1030	if (imx_data->socdata->flags & ESDHC_FLAG_ERR004536)	1100	if (imx_data->socdata->flags & ESDHC_FLAG_ERR004536)
1031	host->quirks \|= SDHCI_QUIRK_BROKEN_ADMA;	1101	host->quirks \|= SDHCI_QUIRK_BROKEN_ADMA;
1032		1102
1033	boarddata = &imx_data->boarddata;	1103	if (of_id)
1034	if (sdhci_esdhc_imx_probe_dt(pdev, host, boarddata) < 0) {	1104	err = sdhci_esdhc_imx_probe_dt(pdev, host, imx_data);
1035	if (!host->mmc->parent->platform_data) {	1105	else
1036	dev_err(mmc_dev(host->mmc), "no board data!\n");	1106	err = sdhci_esdhc_imx_probe_nondt(pdev, host, imx_data);
1037	err = -EINVAL;	1107	if (err)
1038	goto disable_clk;	1108	goto disable_clk;
1039	}
1040	imx_data->boarddata = ((struct esdhc_platform_data )
1041	host->mmc->parent->platform_data);
1042	dt = false;
1043	}
1044	/* write_protect */
1045	if (boarddata->wp_type == ESDHC_WP_GPIO && !dt) {
1046	err = mmc_gpio_request_ro(host->mmc, boarddata->wp_gpio);
1047	if (err) {
1048	dev_err(mmc_dev(host->mmc),
1049	"failed to request write-protect gpio!\n");
1050	goto disable_clk;
1051	}
1052	host->mmc->caps2 \|= MMC_CAP2_RO_ACTIVE_HIGH;
1053	}
1054
1055	/* card_detect */
1056	switch (boarddata->cd_type) {
1057	case ESDHC_CD_GPIO:
1058	if (dt)
1059	break;
1060	err = mmc_gpio_request_cd(host->mmc, boarddata->cd_gpio, 0);
1061	if (err) {
1062	dev_err(mmc_dev(host->mmc),
1063	"failed to request card-detect gpio!\n");
1064	goto disable_clk;
1065	}
1066	/* fall through */
1067
1068	case ESDHC_CD_CONTROLLER:
1069	/* we have a working card_detect back */
1070	host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION;
1071	break;
1072
1073	case ESDHC_CD_PERMANENT:
1074	host->mmc->caps \|= MMC_CAP_NONREMOVABLE;
1075	break;
1076
1077	case ESDHC_CD_NONE:
1078	break;
1079	}
1080
1081	switch (boarddata->max_bus_width) {
1082	case 8:
1083	host->mmc->caps \|= MMC_CAP_8_BIT_DATA \| MMC_CAP_4_BIT_DATA;
1084	break;
1085	case 4:
1086	host->mmc->caps \|= MMC_CAP_4_BIT_DATA;
1087	break;
1088	case 1:
1089	default:
1090	host->quirks \|= SDHCI_QUIRK_FORCE_1_BIT_DATA;
1091	break;
1092	}
1093
1094	/* sdr50 and sdr104 needs work on 1.8v signal voltage */
1095	if ((boarddata->support_vsel) && esdhc_is_usdhc(imx_data) &&
1096	!IS_ERR(imx_data->pins_default)) {
1097	imx_data->pins_100mhz = pinctrl_lookup_state(imx_data->pinctrl,
1098	ESDHC_PINCTRL_STATE_100MHZ);
1099	imx_data->pins_200mhz = pinctrl_lookup_state(imx_data->pinctrl,
1100	ESDHC_PINCTRL_STATE_200MHZ);
1101	if (IS_ERR(imx_data->pins_100mhz) \|\|
1102	IS_ERR(imx_data->pins_200mhz)) {
1103	dev_warn(mmc_dev(host->mmc),
1104	"could not get ultra high speed state, work on normal mode\n");
1105	/* fall back to not support uhs by specify no 1.8v quirk */
1106	host->quirks2 \|= SDHCI_QUIRK2_NO_1_8_V;
1107	}
1108	} else {
1109	host->quirks2 \|= SDHCI_QUIRK2_NO_1_8_V;
1110	}
1111		1109
1112	err = sdhci_add_host(host);	1110	err = sdhci_add_host(host);
1113	if (err)	1111	if (err)

drivers/mmc/host/sdhci-esdhc.h+1−1

@@ -45,6 +45,6 @@ · 44 unmodified lines
45	#define ESDHC_DMA_SYSCTL 0x40c	45	#define ESDHC_DMA_SYSCTL 0x40c
46	#define ESDHC_DMA_SNOOP 0x00000040	46	#define ESDHC_DMA_SNOOP 0x00000040
47		47
48	#define ESDHC_HOST_CONTROL_RES 0x05	48	#define ESDHC_HOST_CONTROL_RES 0x01
49		49
50	#endif /* _DRIVERS_MMC_SDHCI_ESDHC_H */	50	#endif /* _DRIVERS_MMC_SDHCI_ESDHC_H */

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

@@ -411,6 +411,7 @@ static int sdhci_pxav3_probe(struct platform_device *pdev) · 410 unmodified lines
411	goto err_of_parse;	411	goto err_of_parse;
412	sdhci_get_of_property(pdev);	412	sdhci_get_of_property(pdev);
413	pdata = pxav3_get_mmc_pdata(dev);	413	pdata = pxav3_get_mmc_pdata(dev);
		414	pdev->dev.platform_data = pdata;
414	} else if (pdata) {	415	} else if (pdata) {
415	/* on-chip device */	416	/* on-chip device */
416	if (pdata->flags & PXA_FLAG_CARD_PERMANENT)	417	if (pdata->flags & PXA_FLAG_CARD_PERMANENT)

drivers/mmc/host/sdhci.c+12−4

 	u32 max_current_caps;
 	unsigned int ocr_avail;
 	unsigned int override_timeout_clk;
+	u32 max_clk;
 	int ret;
 	WARN_ON(host == NULL);
 						      GFP_KERNEL);
 		host->align_buffer = kmalloc(host->align_buffer_sz, GFP_KERNEL);
 		if (!host->adma_table || !host->align_buffer) {
-			dma_free_coherent(mmc_dev(mmc), host->adma_table_sz,
+			if (host->adma_table)
-					  host->adma_table, host->adma_addr);
+				dma_free_coherent(mmc_dev(mmc),
+						  host->adma_table_sz,
+						  host->adma_table,
+						  host->adma_addr);
 			kfree(host->align_buffer);
 			pr_warn("%s: Unable to allocate ADMA buffers - falling back to standard DMA\n",
 				mmc_hostname(mmc));
 	 * Set host parameters.
 	 */
 	mmc->ops = &sdhci_ops;
-	mmc->f_max = host->max_clk;
+	max_clk = host->max_clk;
 	if (host->ops->get_min_clock)
 		mmc->f_min = host->ops->get_min_clock(host);
 	else if (host->version >= SDHCI_SPEC_300) {
 		if (host->clk_mul) {
 			mmc->f_min = (host->max_clk * host->clk_mul) / 1024;
-			mmc->f_max = host->max_clk * host->clk_mul;
+			max_clk = host->max_clk * host->clk_mul;
 		} else
 			mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_300;
 	} else
 		mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200;
+	if (!mmc->f_max || (mmc->f_max && (mmc->f_max > max_clk)))
+		mmc->f_max = max_clk;
 	if (!(host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
 		host->timeout_clk = (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >>
 					SDHCI_TIMEOUT_CLK_SHIFT;

drivers/net/bonding/bond_main.c+31−3

@@ -625,6 +625,23 @@ static void bond_set_dev_addr(struct net_device *bond_dev, · 624 unmodified lines
625	call_netdevice_notifiers(NETDEV_CHANGEADDR, bond_dev);	625	call_netdevice_notifiers(NETDEV_CHANGEADDR, bond_dev);
626	}	626	}
627		627
		628	static struct slave bond_get_old_active(struct bonding bond,
		629	struct slave *new_active)
		630	{
		631	struct slave *slave;
		632	struct list_head *iter;
		633
		634	bond_for_each_slave(bond, slave, iter) {
		635	if (slave == new_active)
		636	continue;
		637
		638	if (ether_addr_equal(bond->dev->dev_addr, slave->dev->dev_addr))
		639	return slave;
		640	}
		641
		642	return NULL;
		643	}
		644
628	/* bond_do_fail_over_mac	645	/* bond_do_fail_over_mac
629	*	646	*
630	* Perform special MAC address swapping for fail_over_mac settings	647	* Perform special MAC address swapping for fail_over_mac settings
@@ -652,6 +669,9 @@ static void bond_do_fail_over_mac(struct bonding *bond, · 21 unmodified lines
652	if (!new_active)	669	if (!new_active)
653	return;	670	return;
654		671
		672	if (!old_active)
		673	old_active = bond_get_old_active(bond, new_active);
		674
655	if (old_active) {	675	if (old_active) {
656	ether_addr_copy(tmp_mac, new_active->dev->dev_addr);	676	ether_addr_copy(tmp_mac, new_active->dev->dev_addr);
657	ether_addr_copy(saddr.sa_data,	677	ether_addr_copy(saddr.sa_data,
@@ -1725,9 +1745,16 @@ err_free: · 1067 unmodified lines
1725		1745
1726	err_undo_flags:	1746	err_undo_flags:
1727	/* Enslave of first slave has failed and we need to fix master's mac */	1747	/* Enslave of first slave has failed and we need to fix master's mac */
1728	if (!bond_has_slaves(bond) &&	1748	if (!bond_has_slaves(bond)) {
1729	ether_addr_equal_64bits(bond_dev->dev_addr, slave_dev->dev_addr))	1749	if (ether_addr_equal_64bits(bond_dev->dev_addr,
1730	eth_hw_addr_random(bond_dev);	1750	slave_dev->dev_addr))
		1751	eth_hw_addr_random(bond_dev);
		1752	if (bond_dev->type != ARPHRD_ETHER) {
		1753	ether_setup(bond_dev);
		1754	bond_dev->flags \|= IFF_MASTER;
		1755	bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING;
		1756	}
		1757	}
1731		1758
1732	return res;	1759	return res;
1733	}	1760	}
@@ -1916,6 +1943,7 @@ static int bond_release_and_destroy(struct net_device *bond_dev, · 182 unmodified lines
1916	bond_dev->priv_flags \|= IFF_DISABLE_NETPOLL;	1943	bond_dev->priv_flags \|= IFF_DISABLE_NETPOLL;
1917	netdev_info(bond_dev, "Destroying bond %s\n",	1944	netdev_info(bond_dev, "Destroying bond %s\n",
1918	bond_dev->name);	1945	bond_dev->name);
		1946	bond_remove_proc_entry(bond);
1919	unregister_netdevice(bond_dev);	1947	unregister_netdevice(bond_dev);
1920	}	1948	}
1921	return ret;	1949	return ret;

drivers/net/can/at91_can.c+4−4

 	cf->can_id |= CAN_ERR_CRTL;
 	cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
-	netif_receive_skb(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_receive_skb(skb);
 }
 /**
 	}
 	at91_read_mb(dev, mb, cf);
-	netif_receive_skb(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_receive_skb(skb);
 	can_led_event(dev, CAN_LED_EVENT_RX);
 }
 		return 0;
 	at91_poll_err_frame(dev, cf, reg_sr);
-	netif_receive_skb(skb);
 	dev->stats.rx_packets++;
 	dev->stats.rx_bytes += cf->can_dlc;
+	netif_receive_skb(skb);
 	return 1;
 }
 		return;
 	at91_irq_err_state(dev, cf, new_state);
-	netif_rx(skb);
 	dev->stats.rx_packets++;
 	dev->stats.rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 	priv->can.state = new_state;
 }

drivers/net/can/bfin_can.c+2−4

 		cf->data[6 - i] = (6 - i) < cf->can_dlc ? (val >> 8) : 0;
 	}
-	netif_rx(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 }
 static int bfin_can_err(struct net_device *dev, u16 isrc, u16 status)
 	priv->can.state = state;
-	netif_rx(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 	return 0;
 }

drivers/net/can/cc770/cc770.c+2−2

 		for (i = 0; i < cf->can_dlc; i++)
 			cf->data[i] = cc770_read_reg(priv, msgobj[mo].data[i]);
 	}
-	netif_rx(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 }
 static int cc770_err(struct net_device *dev, u8 status)
 		}
 	}
-	netif_rx(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 	return 0;
 }

drivers/net/can/flexcan.c+3−4

 		return 0;
 	do_bus_err(dev, cf, reg_esr);
-	netif_receive_skb(skb);
 	dev->stats.rx_packets++;
 	dev->stats.rx_bytes += cf->can_dlc;
+	netif_receive_skb(skb);
 	return 1;
 }
 	if (unlikely(new_state == CAN_STATE_BUS_OFF))
 		can_bus_off(dev);
-	netif_receive_skb(skb);
 	dev->stats.rx_packets++;
 	dev->stats.rx_bytes += cf->can_dlc;
+	netif_receive_skb(skb);
 	return 1;
 }
 	}
 	flexcan_read_fifo(dev, cf);
-	netif_receive_skb(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_receive_skb(skb);
 	can_led_event(dev, CAN_LED_EVENT_RX);

drivers/net/can/grcan.c+2−1

 				cf->data[i] = (u8)(slot[j] >> shift);
 			}
 		}
-		netif_receive_skb(skb);
 		/* Update statistics and read pointer */
 		stats->rx_packets++;
 		stats->rx_bytes += cf->can_dlc;
+		netif_receive_skb(skb);
 		rd = grcan_ring_add(rd, GRCAN_MSG_SIZE, dma->rx.size);
 	}

drivers/net/can/sja1000/sja1000.c+2−4

 	/* release receive buffer */
 	sja1000_write_cmdreg(priv, CMD_RRB);
-	netif_rx(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 	can_led_event(dev, CAN_LED_EVENT_RX);
 }
 			can_bus_off(dev);
 	}
-	netif_rx(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 	return 0;
 }

drivers/net/can/slcan.c+1−1

 	memcpy(skb_put(skb, sizeof(struct can_frame)),
 	       &cf, sizeof(struct can_frame));
-	netif_rx_ni(skb);
 	sl->dev->stats.rx_packets++;
 	sl->dev->stats.rx_bytes += cf.can_dlc;
+	netif_rx_ni(skb);
 }
 /* parse tty input stream */

drivers/net/can/spi/mcp251x.c+8−9

 	if (ret)
 		goto out_clk;
-	priv->power = devm_regulator_get(&spi->dev, "vdd");
+	priv->power = devm_regulator_get_optional(&spi->dev, "vdd");
-	priv->transceiver = devm_regulator_get(&spi->dev, "xceiver");
+	priv->transceiver = devm_regulator_get_optional(&spi->dev, "xceiver");
 	if ((PTR_ERR(priv->power) == -EPROBE_DEFER) ||
 	    (PTR_ERR(priv->transceiver) == -EPROBE_DEFER)) {
 		ret = -EPROBE_DEFER;
 	struct spi_device *spi = to_spi_device(dev);
 	struct mcp251x_priv *priv = spi_get_drvdata(spi);
-	if (priv->after_suspend & AFTER_SUSPEND_POWER) {
+	if (priv->after_suspend & AFTER_SUSPEND_POWER)
 		mcp251x_power_enable(priv->power, 1);
+	if (priv->after_suspend & AFTER_SUSPEND_UP) {
+		mcp251x_power_enable(priv->transceiver, 1);
 		queue_work(priv->wq, &priv->restart_work);
 	} else {
-		if (priv->after_suspend & AFTER_SUSPEND_UP) {
+		priv->after_suspend = 0;
-			mcp251x_power_enable(priv->transceiver, 1);
-			queue_work(priv->wq, &priv->restart_work);
-		} else {
-			priv->after_suspend = 0;
-		}
 	}
 	priv->force_quit = 0;
 	enable_irq(spi->irq);
 	return 0;

drivers/net/can/ti_hecc.c+1−1

 		}
 	}
-	netif_rx(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 	return 0;
 }

drivers/net/can/usb/ems_usb.c+2−4

 			cf->data[i] = msg->msg.can_msg.msg[i];
 	}
-	netif_rx(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 }
 static void ems_usb_rx_err(struct ems_usb *dev, struct ems_cpc_msg *msg)
 		stats->rx_errors++;
 	}
-	netif_rx(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 }
 /*

drivers/net/can/usb/esd_usb2.c+2−4

 			cf->data[7] = rxerr;
 		}
-		netif_rx(skb);
 		priv->bec.txerr = txerr;
 		priv->bec.rxerr = rxerr;
 		stats->rx_packets++;
 		stats->rx_bytes += cf->can_dlc;
+		netif_rx(skb);
 	}
 }
 				cf->data[i] = msg->msg.rx.data[i];
 		}
-		netif_rx(skb);
 		stats->rx_packets++;
 		stats->rx_bytes += cf->can_dlc;
+		netif_rx(skb);
 	}
 	return;

drivers/net/can/usb/peak_usb/pcan_usb.c+3−4

 		hwts->hwtstamp = timeval_to_ktime(tv);
 	}
-	netif_rx(skb);
 	mc->netdev->stats.rx_packets++;
 	mc->netdev->stats.rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 	return 0;
 }
 	hwts = skb_hwtstamps(skb);
 	hwts->hwtstamp = timeval_to_ktime(tv);
-	/* push the skb */
-	netif_rx(skb);
 	/* update statistics */
 	mc->netdev->stats.rx_packets++;
 	mc->netdev->stats.rx_bytes += cf->can_dlc;
+	/* push the skb */
+	netif_rx(skb);
 	return 0;

drivers/net/can/usb/peak_usb/pcan_usb_pro.c+2−2

 	hwts = skb_hwtstamps(skb);
 	hwts->hwtstamp = timeval_to_ktime(tv);
-	netif_rx(skb);
 	netdev->stats.rx_packets++;
 	netdev->stats.rx_bytes += can_frame->can_dlc;
+	netif_rx(skb);
 	return 0;
 }
 	peak_usb_get_ts_tv(&usb_if->time_ref, le32_to_cpu(er->ts32), &tv);
 	hwts = skb_hwtstamps(skb);
 	hwts->hwtstamp = timeval_to_ktime(tv);
-	netif_rx(skb);
 	netdev->stats.rx_packets++;
 	netdev->stats.rx_bytes += can_frame->can_dlc;
+	netif_rx(skb);
 	return 0;
 }

drivers/net/can/usb/usb_8dev.c+2−4

 	priv->bec.txerr = txerr;
 	priv->bec.rxerr = rxerr;
-	netif_rx(skb);
 	stats->rx_packets++;
 	stats->rx_bytes += cf->can_dlc;
+	netif_rx(skb);
 }
 /* Read data and status frames */
 		else
 			memcpy(cf->data, msg->data, cf->can_dlc);
-		netif_rx(skb);
 		stats->rx_packets++;
 		stats->rx_bytes += cf->can_dlc;
+		netif_rx(skb);
 		can_led_event(priv->netdev, CAN_LED_EVENT_RX);
 	} else {

drivers/net/dsa/bcm_sf2.c+13−2

@@ -696,9 +696,20 @@ static int bcm_sf2_sw_setup(struct dsa_switch *ds) · 695 unmodified lines
696	}	696	}
697		697
698	/* Include the pseudo-PHY address and the broadcast PHY address to	698	/* Include the pseudo-PHY address and the broadcast PHY address to
699	* divert reads towards our workaround	699	* divert reads towards our workaround. This is only required for
		700	* 7445D0, since 7445E0 disconnects the internal switch pseudo-PHY such
		701	* that we can use the regular SWITCH_MDIO master controller instead.
		702	*
		703	* By default, DSA initializes ds->phys_mii_mask to ds->phys_port_mask
		704	* to have a 1:1 mapping between Port address and PHY address in order
		705	* to utilize the slave_mii_bus instance to read from Port PHYs. This is
		706	* not what we want here, so we initialize phys_mii_mask 0 to always
		707	* utilize the "master" MDIO bus backed by the "mdio-unimac" driver.
700	*/	708	*/
701	ds->phys_mii_mask \|= ((1 << BRCM_PSEUDO_PHY_ADDR) \| (1 << 0));	709	if (of_machine_is_compatible("brcm,bcm7445d0"))
		710	ds->phys_mii_mask \|= ((1 << BRCM_PSEUDO_PHY_ADDR) \| (1 << 0));
		711	else
		712	ds->phys_mii_mask = 0;
702		713
703	rev = reg_readl(priv, REG_SWITCH_REVISION);	714	rev = reg_readl(priv, REG_SWITCH_REVISION);
704	priv->hw_params.top_rev = (rev >> SWITCH_TOP_REV_SHIFT) &	715	priv->hw_params.top_rev = (rev >> SWITCH_TOP_REV_SHIFT) &

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

@@ -1163,7 +1163,7 @@ int mv88e6xxx_leave_bridge(struct dsa_switch *ds, int port, u32 br_port_mask) · 1162 unmodified lines
1163		1163
1164	newfid = __ffs(ps->fid_mask);	1164	newfid = __ffs(ps->fid_mask);
1165	ps->fid[port] = newfid;	1165	ps->fid[port] = newfid;
1166	ps->fid_mask &= (1 << newfid);	1166	ps->fid_mask &= ~(1 << newfid);
1167	ps->bridge_mask[fid] &= ~(1 << port);	1167	ps->bridge_mask[fid] &= ~(1 << port);
1168	ps->bridge_mask[newfid] = 1 << port;	1168	ps->bridge_mask[newfid] = 1 << port;
1169		1169

drivers/net/ethernet/freescale/fec_main.c+13−75

@@ -24,7 +24,6 @@ · 23 unmodified lines
24	#include <linux/module.h>	24	#include <linux/module.h>
25	#include <linux/kernel.h>	25	#include <linux/kernel.h>
26	#include <linux/string.h>	26	#include <linux/string.h>
27	#include <linux/pm_runtime.h>
28	#include <linux/ptrace.h>	27	#include <linux/ptrace.h>
29	#include <linux/errno.h>	28	#include <linux/errno.h>
30	#include <linux/ioport.h>	29	#include <linux/ioport.h>
@@ -78,7 +77,6 @@ static void fec_enet_itr_coal_init(struct net_device *ndev); · 47 unmodified lines
78	#define FEC_ENET_RAEM_V 0x8	77	#define FEC_ENET_RAEM_V 0x8
79	#define FEC_ENET_RAFL_V 0x8	78	#define FEC_ENET_RAFL_V 0x8
80	#define FEC_ENET_OPD_V 0xFFF0	79	#define FEC_ENET_OPD_V 0xFFF0
81	#define FEC_MDIO_PM_TIMEOUT 100 /* ms */
82		80
83	static struct platform_device_id fec_devtype[] = {	81	static struct platform_device_id fec_devtype[] = {
84	{	82	{
@@ -1769,13 +1767,7 @@ static void fec_enet_adjust_link(struct net_device *ndev) · 1684 unmodified lines
1769	static int fec_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum)	1767	static int fec_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
1770	{	1768	{
1771	struct fec_enet_private *fep = bus->priv;	1769	struct fec_enet_private *fep = bus->priv;
1772	struct device *dev = &fep->pdev->dev;
1773	unsigned long time_left;	1770	unsigned long time_left;
1774	int ret = 0;
1775
1776	ret = pm_runtime_get_sync(dev);
1777	if (IS_ERR_VALUE(ret))
1778	return ret;
1779		1771
1780	fep->mii_timeout = 0;	1772	fep->mii_timeout = 0;
1781	init_completion(&fep->mdio_done);	1773	init_completion(&fep->mdio_done);
@@ -1791,30 +1783,18 @@ static int fec_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum) · 9 unmodified lines
1791	if (time_left == 0) {	1783	if (time_left == 0) {
1792	fep->mii_timeout = 1;	1784	fep->mii_timeout = 1;
1793	netdev_err(fep->netdev, "MDIO read timeout\n");	1785	netdev_err(fep->netdev, "MDIO read timeout\n");
1794	ret = -ETIMEDOUT;	1786	return -ETIMEDOUT;
1795	goto out;
1796	}	1787	}
1797		1788
1798	ret = FEC_MMFR_DATA(readl(fep->hwp + FEC_MII_DATA));	1789	/* return value */
1799		1790	return FEC_MMFR_DATA(readl(fep->hwp + FEC_MII_DATA));
1800	out:
1801	pm_runtime_mark_last_busy(dev);
1802	pm_runtime_put_autosuspend(dev);
1803
1804	return ret;
1805	}	1791	}
1806		1792
1807	static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,	1793	static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
1808	u16 value)	1794	u16 value)
1809	{	1795	{
1810	struct fec_enet_private *fep = bus->priv;	1796	struct fec_enet_private *fep = bus->priv;
1811	struct device *dev = &fep->pdev->dev;
1812	unsigned long time_left;	1797	unsigned long time_left;
1813	int ret = 0;
1814
1815	ret = pm_runtime_get_sync(dev);
1816	if (IS_ERR_VALUE(ret))
1817	return ret;
1818		1798
1819	fep->mii_timeout = 0;	1799	fep->mii_timeout = 0;
1820	init_completion(&fep->mdio_done);	1800	init_completion(&fep->mdio_done);
@@ -1831,13 +1811,10 @@ static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum, · 10 unmodified lines
1831	if (time_left == 0) {	1811	if (time_left == 0) {
1832	fep->mii_timeout = 1;	1812	fep->mii_timeout = 1;
1833	netdev_err(fep->netdev, "MDIO write timeout\n");	1813	netdev_err(fep->netdev, "MDIO write timeout\n");
1834	ret = -ETIMEDOUT;	1814	return -ETIMEDOUT;
1835	}	1815	}
1836		1816
1837	pm_runtime_mark_last_busy(dev);	1817	return 0;
1838	pm_runtime_put_autosuspend(dev);
1839
1840	return ret;
1841	}	1818	}
1842		1819
1843	static int fec_enet_clk_enable(struct net_device *ndev, bool enable)	1820	static int fec_enet_clk_enable(struct net_device *ndev, bool enable)
@@ -1849,6 +1826,9 @@ static int fec_enet_clk_enable(struct net_device *ndev, bool enable) · 5 unmodified lines
1849	ret = clk_prepare_enable(fep->clk_ahb);	1826	ret = clk_prepare_enable(fep->clk_ahb);
1850	if (ret)	1827	if (ret)
1851	return ret;	1828	return ret;
		1829	ret = clk_prepare_enable(fep->clk_ipg);
		1830	if (ret)
		1831	goto failed_clk_ipg;
1852	if (fep->clk_enet_out) {	1832	if (fep->clk_enet_out) {
1853	ret = clk_prepare_enable(fep->clk_enet_out);	1833	ret = clk_prepare_enable(fep->clk_enet_out);
1854	if (ret)	1834	if (ret)
@@ -1872,6 +1852,7 @@ static int fec_enet_clk_enable(struct net_device *ndev, bool enable) · 17 unmodified lines
1872	}	1852	}
1873	} else {	1853	} else {
1874	clk_disable_unprepare(fep->clk_ahb);	1854	clk_disable_unprepare(fep->clk_ahb);
		1855	clk_disable_unprepare(fep->clk_ipg);
1875	if (fep->clk_enet_out)	1856	if (fep->clk_enet_out)
1876	clk_disable_unprepare(fep->clk_enet_out);	1857	clk_disable_unprepare(fep->clk_enet_out);
1877	if (fep->clk_ptp) {	1858	if (fep->clk_ptp) {
@@ -1893,6 +1874,8 @@ failed_clk_ptp: · 15 unmodified lines
1893	if (fep->clk_enet_out)	1874	if (fep->clk_enet_out)
1894	clk_disable_unprepare(fep->clk_enet_out);	1875	clk_disable_unprepare(fep->clk_enet_out);
1895	failed_clk_enet_out:	1876	failed_clk_enet_out:
		1877	clk_disable_unprepare(fep->clk_ipg);
		1878	failed_clk_ipg:
1896	clk_disable_unprepare(fep->clk_ahb);	1879	clk_disable_unprepare(fep->clk_ahb);
1897		1880
1898	return ret;	1881	return ret;
@@ -2864,14 +2847,10 @@ fec_enet_open(struct net_device *ndev) · 965 unmodified lines
2864	struct fec_enet_private *fep = netdev_priv(ndev);	2847	struct fec_enet_private *fep = netdev_priv(ndev);
2865	int ret;	2848	int ret;
2866		2849
2867	ret = pm_runtime_get_sync(&fep->pdev->dev);
2868	if (IS_ERR_VALUE(ret))
2869	return ret;
2870
2871	pinctrl_pm_select_default_state(&fep->pdev->dev);	2850	pinctrl_pm_select_default_state(&fep->pdev->dev);
2872	ret = fec_enet_clk_enable(ndev, true);	2851	ret = fec_enet_clk_enable(ndev, true);
2873	if (ret)	2852	if (ret)
2874	goto clk_enable;	2853	return ret;
2875		2854
2876	/* I should reset the ring buffers here, but I don't yet know	2855	/* I should reset the ring buffers here, but I don't yet know
2877	* a simple way to do that.	2856	* a simple way to do that.
@@ -2902,9 +2881,6 @@ err_enet_mii_probe: · 24 unmodified lines
2902	fec_enet_free_buffers(ndev);	2881	fec_enet_free_buffers(ndev);
2903	err_enet_alloc:	2882	err_enet_alloc:
2904	fec_enet_clk_enable(ndev, false);	2883	fec_enet_clk_enable(ndev, false);
2905	clk_enable:
2906	pm_runtime_mark_last_busy(&fep->pdev->dev);
2907	pm_runtime_put_autosuspend(&fep->pdev->dev);
2908	pinctrl_pm_select_sleep_state(&fep->pdev->dev);	2884	pinctrl_pm_select_sleep_state(&fep->pdev->dev);
2909	return ret;	2885	return ret;
2910	}	2886	}
@@ -2927,9 +2903,6 @@ fec_enet_close(struct net_device *ndev) · 16 unmodified lines
2927		2903
2928	fec_enet_clk_enable(ndev, false);	2904	fec_enet_clk_enable(ndev, false);
2929	pinctrl_pm_select_sleep_state(&fep->pdev->dev);	2905	pinctrl_pm_select_sleep_state(&fep->pdev->dev);
2930	pm_runtime_mark_last_busy(&fep->pdev->dev);
2931	pm_runtime_put_autosuspend(&fep->pdev->dev);
2932
2933	fec_enet_free_buffers(ndev);	2906	fec_enet_free_buffers(ndev);
2934		2907
2935	return 0;	2908	return 0;
@@ -3415,10 +3388,6 @@ fec_probe(struct platform_device *pdev) · 479 unmodified lines
3415	if (ret)	3388	if (ret)
3416	goto failed_clk;	3389	goto failed_clk;
3417		3390
3418	ret = clk_prepare_enable(fep->clk_ipg);
3419	if (ret)
3420	goto failed_clk_ipg;
3421
3422	fep->reg_phy = devm_regulator_get(&pdev->dev, "phy");	3391	fep->reg_phy = devm_regulator_get(&pdev->dev, "phy");
3423	if (!IS_ERR(fep->reg_phy)) {	3392	if (!IS_ERR(fep->reg_phy)) {
3424	ret = regulator_enable(fep->reg_phy);	3393	ret = regulator_enable(fep->reg_phy);
@@ -3465,8 +3434,6 @@ fec_probe(struct platform_device *pdev) · 40 unmodified lines
3465	netif_carrier_off(ndev);	3434	netif_carrier_off(ndev);
3466	fec_enet_clk_enable(ndev, false);	3435	fec_enet_clk_enable(ndev, false);
3467	pinctrl_pm_select_sleep_state(&pdev->dev);	3436	pinctrl_pm_select_sleep_state(&pdev->dev);
3468	pm_runtime_set_active(&pdev->dev);
3469	pm_runtime_enable(&pdev->dev);
3470		3437
3471	ret = register_netdev(ndev);	3438	ret = register_netdev(ndev);
3472	if (ret)	3439	if (ret)
@@ -3480,12 +3447,6 @@ fec_probe(struct platform_device *pdev) · 7 unmodified lines
3480		3447
3481	fep->rx_copybreak = COPYBREAK_DEFAULT;	3448	fep->rx_copybreak = COPYBREAK_DEFAULT;
3482	INIT_WORK(&fep->tx_timeout_work, fec_enet_timeout_work);	3449	INIT_WORK(&fep->tx_timeout_work, fec_enet_timeout_work);
3483
3484	pm_runtime_set_autosuspend_delay(&pdev->dev, FEC_MDIO_PM_TIMEOUT);
3485	pm_runtime_use_autosuspend(&pdev->dev);
3486	pm_runtime_mark_last_busy(&pdev->dev);
3487	pm_runtime_put_autosuspend(&pdev->dev);
3488
3489	return 0;	3450	return 0;
3490		3451
3491	failed_register:	3452	failed_register:
@@ -3496,8 +3457,6 @@ failed_init: · 4 unmodified lines
3496	if (fep->reg_phy)	3457	if (fep->reg_phy)
3497	regulator_disable(fep->reg_phy);	3458	regulator_disable(fep->reg_phy);
3498	failed_regulator:	3459	failed_regulator:
3499	clk_disable_unprepare(fep->clk_ipg);
3500	failed_clk_ipg:
3501	fec_enet_clk_enable(ndev, false);	3460	fec_enet_clk_enable(ndev, false);
3502	failed_clk:	3461	failed_clk:
3503	failed_phy:	3462	failed_phy:
@@ -3609,28 +3568,7 @@ failed_clk: · 105 unmodified lines
3609	return ret;	3568	return ret;
3610	}	3569	}
3611		3570
3612	static int __maybe_unused fec_runtime_suspend(struct device *dev)	3571	static SIMPLE_DEV_PM_OPS(fec_pm_ops, fec_suspend, fec_resume);
3613	{
3614	struct net_device *ndev = dev_get_drvdata(dev);
3615	struct fec_enet_private *fep = netdev_priv(ndev);
3616
3617	clk_disable_unprepare(fep->clk_ipg);
3618
3619	return 0;
3620	}
3621
3622	static int __maybe_unused fec_runtime_resume(struct device *dev)
3623	{
3624	struct net_device *ndev = dev_get_drvdata(dev);
3625	struct fec_enet_private *fep = netdev_priv(ndev);
3626
3627	return clk_prepare_enable(fep->clk_ipg);
3628	}
3629
3630	static const struct dev_pm_ops fec_pm_ops = {
3631	SET_SYSTEM_SLEEP_PM_OPS(fec_suspend, fec_resume)
3632	SET_RUNTIME_PM_OPS(fec_runtime_suspend, fec_runtime_resume, NULL)
3633	};
3634		3572
3635	static struct platform_driver fec_driver = {	3573	static struct platform_driver fec_driver = {
3636	.driver = {	3574	.driver = {

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

 		     struct mvneta_rx_queue *rxq)
 {
 	struct net_device *dev = pp->dev;
-	int rx_done, rx_filled;
+	int rx_done;
 	u32 rcvd_pkts = 0;
 	u32 rcvd_bytes = 0;
 		rx_todo = rx_done;
 	rx_done = 0;
-	rx_filled = 0;
 	/* Fairness NAPI loop */
 	while (rx_done < rx_todo) {
 		int rx_bytes, err;
 		rx_done++;
-		rx_filled++;
 		rx_status = rx_desc->status;
 		rx_bytes = rx_desc->data_size - (ETH_FCS_LEN + MVNETA_MH_SIZE);
 		data = (unsigned char *)rx_desc->buf_cookie;
 			continue;
 		}
+		/* Refill processing */
+		err = mvneta_rx_refill(pp, rx_desc);
+		if (err) {
+			netdev_err(dev, "Linux processing - Can't refill\n");
+			rxq->missed++;
+			goto err_drop_frame;
+		}
 		skb = build_skb(data, pp->frag_size > PAGE_SIZE ? 0 : pp->frag_size);
 		if (!skb)
 			goto err_drop_frame;
 		mvneta_rx_csum(pp, rx_status, skb);
 		napi_gro_receive(&pp->napi, skb);
-		/* Refill processing */
-		err = mvneta_rx_refill(pp, rx_desc);
-		if (err) {
-			netdev_err(dev, "Linux processing - Can't refill\n");
-			rxq->missed++;
-			rx_filled--;
-		}
 	}
 	if (rcvd_pkts) {
 	}
 	/* Update rxq management counters */
-	mvneta_rxq_desc_num_update(pp, rxq, rx_done, rx_filled);
+	mvneta_rxq_desc_num_update(pp, rxq, rx_done, rx_done);
 	return rx_done;
 }

drivers/net/ethernet/renesas/ravb_main.c+38−36

 	struct ravb_desc *desc = NULL;
 	int rx_ring_size = sizeof(*rx_desc) * priv->num_rx_ring[q];
 	int tx_ring_size = sizeof(*tx_desc) * priv->num_tx_ring[q];
-	struct sk_buff *skb;
 	dma_addr_t dma_addr;
-	void *buffer;
 	int i;
 	priv->cur_rx[q] = 0;
 	memset(priv->rx_ring[q], 0, rx_ring_size);
 	/* Build RX ring buffer */
 	for (i = 0; i < priv->num_rx_ring[q]; i++) {
-		priv->rx_skb[q][i] = NULL;
-		skb = netdev_alloc_skb(ndev, PKT_BUF_SZ + RAVB_ALIGN - 1);
-		if (!skb)
-			break;
-		ravb_set_buffer_align(skb);
 		/* RX descriptor */
 		rx_desc = &priv->rx_ring[q][i];
 		/* The size of the buffer should be on 16-byte boundary. */
 		rx_desc->ds_cc = cpu_to_le16(ALIGN(PKT_BUF_SZ, 16));
-		dma_addr = dma_map_single(&ndev->dev, skb->data,
+		dma_addr = dma_map_single(&ndev->dev, priv->rx_skb[q][i]->data,
 					  ALIGN(PKT_BUF_SZ, 16),
 					  DMA_FROM_DEVICE);
-		if (dma_mapping_error(&ndev->dev, dma_addr)) {
+		/* We just set the data size to 0 for a failed mapping which
-			dev_kfree_skb(skb);
+		 * should prevent DMA from happening...
-			break;
+		 */
-		}
+		if (dma_mapping_error(&ndev->dev, dma_addr))
-		priv->rx_skb[q][i] = skb;
+			rx_desc->ds_cc = cpu_to_le16(0);
 		rx_desc->dptr = cpu_to_le32(dma_addr);
 		rx_desc->die_dt = DT_FEMPTY;
 	}
 	rx_desc = &priv->rx_ring[q][i];
 	rx_desc->dptr = cpu_to_le32((u32)priv->rx_desc_dma[q]);
 	rx_desc->die_dt = DT_LINKFIX; /* type */
-	priv->dirty_rx[q] = (u32)(i - priv->num_rx_ring[q]);
 	memset(priv->tx_ring[q], 0, tx_ring_size);
 	/* Build TX ring buffer */
 	for (i = 0; i < priv->num_tx_ring[q]; i++) {
-		priv->tx_skb[q][i] = NULL;
-		priv->tx_buffers[q][i] = NULL;
-		buffer = kmalloc(PKT_BUF_SZ + RAVB_ALIGN - 1, GFP_KERNEL);
-		if (!buffer)
-			break;
-		/* Aligned TX buffer */
-		priv->tx_buffers[q][i] = buffer;
 		tx_desc = &priv->tx_ring[q][i];
 		tx_desc->die_dt = DT_EEMPTY;
 	}
 static int ravb_ring_init(struct net_device *ndev, int q)
 {
 	struct ravb_private *priv = netdev_priv(ndev);
+	struct sk_buff *skb;
 	int ring_size;
+	void *buffer;
+	int i;
 	/* Allocate RX and TX skb rings */
 	priv->rx_skb[q] = kcalloc(priv->num_rx_ring[q],
 	if (!priv->rx_skb[q] || !priv->tx_skb[q])
 		goto error;
+	for (i = 0; i < priv->num_rx_ring[q]; i++) {
+		skb = netdev_alloc_skb(ndev, PKT_BUF_SZ + RAVB_ALIGN - 1);
+		if (!skb)
+			goto error;
+		ravb_set_buffer_align(skb);
+		priv->rx_skb[q][i] = skb;
+	}
 	/* Allocate rings for the aligned buffers */
 	priv->tx_buffers[q] = kcalloc(priv->num_tx_ring[q],
 				      sizeof(*priv->tx_buffers[q]), GFP_KERNEL);
 	if (!priv->tx_buffers[q])
 		goto error;
+	for (i = 0; i < priv->num_tx_ring[q]; i++) {
+		buffer = kmalloc(PKT_BUF_SZ + RAVB_ALIGN - 1, GFP_KERNEL);
+		if (!buffer)
+			goto error;
+		/* Aligned TX buffer */
+		priv->tx_buffers[q][i] = buffer;
+	}
 	/* Allocate all RX descriptors. */
 	ring_size = sizeof(struct ravb_ex_rx_desc) * (priv->num_rx_ring[q] + 1);
 	priv->rx_ring[q] = dma_alloc_coherent(NULL, ring_size,
 		if (--boguscnt < 0)
 			break;
+		/* We use 0-byte descriptors to mark the DMA mapping errors */
+		if (!pkt_len)
+			continue;
 		if (desc_status & MSC_MC)
 			stats->multicast++;
 			skb = priv->rx_skb[q][entry];
 			priv->rx_skb[q][entry] = NULL;
-			dma_sync_single_for_cpu(&ndev->dev,
+			dma_unmap_single(&ndev->dev, le32_to_cpu(desc->dptr),
-						le32_to_cpu(desc->dptr),
+					 ALIGN(PKT_BUF_SZ, 16),
-						ALIGN(PKT_BUF_SZ, 16),
+					 DMA_FROM_DEVICE);
-						DMA_FROM_DEVICE);
 			get_ts &= (q == RAVB_NC) ?
 					RAVB_RXTSTAMP_TYPE_V2_L2_EVENT :
 					~RAVB_RXTSTAMP_TYPE_V2_L2_EVENT;
 			if (!skb)
 				break;	/* Better luck next round. */
 			ravb_set_buffer_align(skb);
-			dma_unmap_single(&ndev->dev, le32_to_cpu(desc->dptr),
-					 ALIGN(PKT_BUF_SZ, 16),
-					 DMA_FROM_DEVICE);
 			dma_addr = dma_map_single(&ndev->dev, skb->data,
 						  le16_to_cpu(desc->ds_cc),
 						  DMA_FROM_DEVICE);
 			skb_checksum_none_assert(skb);
-			if (dma_mapping_error(&ndev->dev, dma_addr)) {
+			/* We just set the data size to 0 for a failed mapping
-				dev_kfree_skb_any(skb);
+			 * which should prevent DMA  from happening...
-				break;
+			 */
-			}
+			if (dma_mapping_error(&ndev->dev, dma_addr))
+				desc->ds_cc = cpu_to_le16(0);
 			desc->dptr = cpu_to_le32(dma_addr);
 			priv->rx_skb[q][entry] = skb;
 		}
 	u32 dma_addr;
 	void *buffer;
 	u32 entry;
-	u32 tccr;
 	spin_lock_irqsave(&priv->lock, flags);
 	if (priv->cur_tx[q] - priv->dirty_tx[q] >= priv->num_tx_ring[q]) {
 	dma_wmb();
 	desc->die_dt = DT_FSINGLE;
-	tccr = ravb_read(ndev, TCCR);
+	ravb_write(ndev, ravb_read(ndev, TCCR) | (TCCR_TSRQ0 << q), TCCR);
-	if (!(tccr & (TCCR_TSRQ0 << q)))
-		ravb_write(ndev, tccr | (TCCR_TSRQ0 << q), TCCR);
 	priv->cur_tx[q]++;
 	if (priv->cur_tx[q] - priv->dirty_tx[q] >= priv->num_tx_ring[q] &&

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

@@ -2843,7 +2843,7 @@ int stmmac_dvr_probe(struct device *device, · 2842 unmodified lines
2843	if (res->mac)	2843	if (res->mac)
2844	memcpy(priv->dev->dev_addr, res->mac, ETH_ALEN);	2844	memcpy(priv->dev->dev_addr, res->mac, ETH_ALEN);
2845		2845
2846	dev_set_drvdata(device, priv);	2846	dev_set_drvdata(device, priv->dev);
2847		2847
2848	/* Verify driver arguments */	2848	/* Verify driver arguments */
2849	stmmac_verify_args();	2849	stmmac_verify_args();

drivers/net/ethernet/ti/cpsw.c+3−6

 static int cpsw_poll(struct napi_struct *napi, int budget)
 {
 	struct cpsw_priv	*priv = napi_to_priv(napi);
-	int			num_tx, num_rx;
+	int			num_rx;
-	num_tx = cpdma_chan_process(priv->txch, 128);
 	num_rx = cpdma_chan_process(priv->rxch, budget);
 	if (num_rx < budget) {
 		}
 	}
-	if (num_rx || num_tx)
+	if (num_rx)
-		cpsw_dbg(priv, intr, "poll %d rx, %d tx pkts\n",
+		cpsw_dbg(priv, intr, "poll %d rx pkts\n", num_rx);
-			 num_rx, num_tx);
 	return num_rx;
 }

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

 	}
 	mutex_unlock(&netcp_modules_lock);
-	netcp_rxpool_refill(netcp);
 	napi_enable(&netcp->rx_napi);
 	napi_enable(&netcp->tx_napi);
 	knav_queue_enable_notify(netcp->tx_compl_q);
 	knav_queue_enable_notify(netcp->rx_queue);
+	netcp_rxpool_refill(netcp);
 	netif_tx_wake_all_queues(ndev);
 	dev_dbg(netcp->ndev_dev, "netcp device %s opened\n", ndev->name);
 	return 0;

drivers/net/ipvlan/ipvlan.h+6−3

 	struct ipvl_port	*port;
 	struct net_device	*phy_dev;
 	struct list_head	addrs;
-	int			ipv4cnt;
-	int			ipv6cnt;
 	struct ipvl_pcpu_stats	__percpu *pcpu_stats;
 	DECLARE_BITMAP(mac_filters, IPVLAN_MAC_FILTER_SIZE);
 	netdev_features_t	sfeatures;
 	return rcu_dereference(d->rx_handler_data);
 }
+static inline struct ipvl_port *ipvlan_port_get_rcu_bh(const struct net_device *d)
+{
+	return rcu_dereference_bh(d->rx_handler_data);
+}
 static inline struct ipvl_port *ipvlan_port_get_rtnl(const struct net_device *d)
 {
 	return rtnl_dereference(d->rx_handler_data);
 bool ipvlan_addr_busy(struct ipvl_port *port, void *iaddr, bool is_v6);
 struct ipvl_addr *ipvlan_ht_addr_lookup(const struct ipvl_port *port,
 					const void *iaddr, bool is_v6);
-void ipvlan_ht_addr_del(struct ipvl_addr *addr, bool sync);
+void ipvlan_ht_addr_del(struct ipvl_addr *addr);
 #endif /* __IPVLAN_H */

drivers/net/ipvlan/ipvlan_core.c+2−4

 		hlist_add_head_rcu(&addr->hlnode, &port->hlhead[hash]);
 }
-void ipvlan_ht_addr_del(struct ipvl_addr *addr, bool sync)
+void ipvlan_ht_addr_del(struct ipvl_addr *addr)
 {
 	hlist_del_init_rcu(&addr->hlnode);
-	if (sync)
-		synchronize_rcu();
 }
 struct ipvl_addr *ipvlan_find_addr(const struct ipvl_dev *ipvlan,
 int ipvlan_queue_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	struct ipvl_dev *ipvlan = netdev_priv(dev);
-	struct ipvl_port *port = ipvlan_port_get_rcu(ipvlan->phy_dev);
+	struct ipvl_port *port = ipvlan_port_get_rcu_bh(ipvlan->phy_dev);
 	if (!port)
 		goto out;

drivers/net/ipvlan/ipvlan_main.c+19−23

@@ -153,10 +153,9 @@ static int ipvlan_open(struct net_device *dev) · 152 unmodified lines
153	else	153	else
154	dev->flags &= ~IFF_NOARP;	154	dev->flags &= ~IFF_NOARP;
155		155
156	if (ipvlan->ipv6cnt > 0 \|\| ipvlan->ipv4cnt > 0) {	156	list_for_each_entry(addr, &ipvlan->addrs, anode)
157	list_for_each_entry(addr, &ipvlan->addrs, anode)	157	ipvlan_ht_addr_add(ipvlan, addr);
158	ipvlan_ht_addr_add(ipvlan, addr);	158
159	}
160	return dev_uc_add(phy_dev, phy_dev->dev_addr);	159	return dev_uc_add(phy_dev, phy_dev->dev_addr);
161	}	160	}
162		161
@@ -171,10 +170,9 @@ static int ipvlan_stop(struct net_device *dev) · 8 unmodified lines
171		170
172	dev_uc_del(phy_dev, phy_dev->dev_addr);	171	dev_uc_del(phy_dev, phy_dev->dev_addr);
173		172
174	if (ipvlan->ipv6cnt > 0 \|\| ipvlan->ipv4cnt > 0) {	173	list_for_each_entry(addr, &ipvlan->addrs, anode)
175	list_for_each_entry(addr, &ipvlan->addrs, anode)	174	ipvlan_ht_addr_del(addr);
176	ipvlan_ht_addr_del(addr, !dev->dismantle);	175
177	}
178	return 0;	176	return 0;
179	}	177	}
180		178
@@ -471,8 +469,6 @@ static int ipvlan_link_new(struct net src_net, struct net_device dev, · 290 unmodified lines
471	ipvlan->port = port;	469	ipvlan->port = port;
472	ipvlan->sfeatures = IPVLAN_FEATURES;	470	ipvlan->sfeatures = IPVLAN_FEATURES;
473	INIT_LIST_HEAD(&ipvlan->addrs);	471	INIT_LIST_HEAD(&ipvlan->addrs);
474	ipvlan->ipv4cnt = 0;
475	ipvlan->ipv6cnt = 0;
476		472
477	/* TODO Probably put random address here to be presented to the	473	/* TODO Probably put random address here to be presented to the
478	* world but keep using the physical-dev address for the outgoing	474	* world but keep using the physical-dev address for the outgoing
@@ -508,12 +504,12 @@ static void ipvlan_link_delete(struct net_device dev, struct list_head head) · 29 unmodified lines
508	struct ipvl_dev *ipvlan = netdev_priv(dev);	504	struct ipvl_dev *ipvlan = netdev_priv(dev);
509	struct ipvl_addr addr, next;	505	struct ipvl_addr addr, next;
510		506
511	if (ipvlan->ipv6cnt > 0 \|\| ipvlan->ipv4cnt > 0) {	507	list_for_each_entry_safe(addr, next, &ipvlan->addrs, anode) {
512	list_for_each_entry_safe(addr, next, &ipvlan->addrs, anode) {	508	ipvlan_ht_addr_del(addr);
513	ipvlan_ht_addr_del(addr, !dev->dismantle);	509	list_del(&addr->anode);
514	list_del(&addr->anode);	510	kfree_rcu(addr, rcu);
515	}
516	}	511	}
		512
517	list_del_rcu(&ipvlan->pnode);	513	list_del_rcu(&ipvlan->pnode);
518	unregister_netdevice_queue(dev, head);	514	unregister_netdevice_queue(dev, head);
519	netdev_upper_dev_unlink(ipvlan->phy_dev, dev);	515	netdev_upper_dev_unlink(ipvlan->phy_dev, dev);
@@ -627,7 +623,7 @@ static int ipvlan_add_addr6(struct ipvl_dev ipvlan, struct in6_addr ip6_addr) · 107 unmodified lines
627	memcpy(&addr->ip6addr, ip6_addr, sizeof(struct in6_addr));	623	memcpy(&addr->ip6addr, ip6_addr, sizeof(struct in6_addr));
628	addr->atype = IPVL_IPV6;	624	addr->atype = IPVL_IPV6;
629	list_add_tail(&addr->anode, &ipvlan->addrs);	625	list_add_tail(&addr->anode, &ipvlan->addrs);
630	ipvlan->ipv6cnt++;	626
631	/* If the interface is not up, the address will be added to the hash	627	/* If the interface is not up, the address will be added to the hash
632	* list by ipvlan_open.	628	* list by ipvlan_open.
633	*/	629	*/
@@ -645,10 +641,8 @@ static void ipvlan_del_addr6(struct ipvl_dev ipvlan, struct in6_addr ip6_addr) · 11 unmodified lines
645	if (!addr)	641	if (!addr)
646	return;	642	return;
647		643
648	ipvlan_ht_addr_del(addr, true);	644	ipvlan_ht_addr_del(addr);
649	list_del(&addr->anode);	645	list_del(&addr->anode);
650	ipvlan->ipv6cnt--;
651	WARN_ON(ipvlan->ipv6cnt < 0);
652	kfree_rcu(addr, rcu);	646	kfree_rcu(addr, rcu);
653		647
654	return;	648	return;
@@ -661,6 +655,10 @@ static int ipvlan_addr6_event(struct notifier_block *unused, · 6 unmodified lines
661	struct net_device dev = (struct net_device )if6->idev->dev;	655	struct net_device dev = (struct net_device )if6->idev->dev;
662	struct ipvl_dev *ipvlan = netdev_priv(dev);	656	struct ipvl_dev *ipvlan = netdev_priv(dev);
663		657
		658	/* FIXME IPv6 autoconf calls us from bh without RTNL */
		659	if (in_softirq())
		660	return NOTIFY_DONE;
		661
664	if (!netif_is_ipvlan(dev))	662	if (!netif_is_ipvlan(dev))
665	return NOTIFY_DONE;	663	return NOTIFY_DONE;
666		664
@@ -699,7 +697,7 @@ static int ipvlan_add_addr4(struct ipvl_dev ipvlan, struct in_addr ip4_addr) · 32 unmodified lines
699	memcpy(&addr->ip4addr, ip4_addr, sizeof(struct in_addr));	697	memcpy(&addr->ip4addr, ip4_addr, sizeof(struct in_addr));
700	addr->atype = IPVL_IPV4;	698	addr->atype = IPVL_IPV4;
701	list_add_tail(&addr->anode, &ipvlan->addrs);	699	list_add_tail(&addr->anode, &ipvlan->addrs);
702	ipvlan->ipv4cnt++;	700
703	/* If the interface is not up, the address will be added to the hash	701	/* If the interface is not up, the address will be added to the hash
704	* list by ipvlan_open.	702	* list by ipvlan_open.
705	*/	703	*/
@@ -717,10 +715,8 @@ static void ipvlan_del_addr4(struct ipvl_dev ipvlan, struct in_addr ip4_addr) · 11 unmodified lines
717	if (!addr)	715	if (!addr)
718	return;	716	return;
719		717
720	ipvlan_ht_addr_del(addr, true);	718	ipvlan_ht_addr_del(addr);
721	list_del(&addr->anode);	719	list_del(&addr->anode);
722	ipvlan->ipv4cnt--;
723	WARN_ON(ipvlan->ipv4cnt < 0);
724	kfree_rcu(addr, rcu);	720	kfree_rcu(addr, rcu);
725		721
726	return;	722	return;

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

@@ -164,7 +164,7 @@ static int dp83867_config_init(struct phy_device *phydev) · 163 unmodified lines
164	return ret;	164	return ret;
165	}	165	}
166		166
167	if ((phydev->interface >= PHY_INTERFACE_MODE_RGMII_ID) \|\|	167	if ((phydev->interface >= PHY_INTERFACE_MODE_RGMII_ID) &&
168	(phydev->interface <= PHY_INTERFACE_MODE_RGMII_RXID)) {	168	(phydev->interface <= PHY_INTERFACE_MODE_RGMII_RXID)) {
169	val = phy_read_mmd_indirect(phydev, DP83867_RGMIICTL,	169	val = phy_read_mmd_indirect(phydev, DP83867_RGMIICTL,
170	DP83867_DEVADDR, phydev->addr);	170	DP83867_DEVADDR, phydev->addr);

drivers/net/phy/mdio_bus.c+17−2

@@ -421,6 +421,8 @@ static int mdio_bus_match(struct device dev, struct device_driver drv) · 420 unmodified lines
421	{	421	{
422	struct phy_device *phydev = to_phy_device(dev);	422	struct phy_device *phydev = to_phy_device(dev);
423	struct phy_driver *phydrv = to_phy_driver(drv);	423	struct phy_driver *phydrv = to_phy_driver(drv);
		424	const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
		425	int i;
424		426
425	if (of_driver_match_device(dev, drv))	427	if (of_driver_match_device(dev, drv))
426	return 1;	428	return 1;
@@ -428,8 +430,21 @@ static int mdio_bus_match(struct device dev, struct device_driver drv) · 1 unmodified line
428	if (phydrv->match_phy_device)	430	if (phydrv->match_phy_device)
429	return phydrv->match_phy_device(phydev);	431	return phydrv->match_phy_device(phydev);
430		432
431	return (phydrv->phy_id & phydrv->phy_id_mask) ==	433	if (phydev->is_c45) {
432	(phydev->phy_id & phydrv->phy_id_mask);	434	for (i = 1; i < num_ids; i++) {
		435	if (!(phydev->c45_ids.devices_in_package & (1 << i)))
		436	continue;
		437
		438	if ((phydrv->phy_id & phydrv->phy_id_mask) ==
		439	(phydev->c45_ids.device_ids[i] &
		440	phydrv->phy_id_mask))
		441	return 1;
		442	}
		443	return 0;
		444	} else {
		445	return (phydrv->phy_id & phydrv->phy_id_mask) ==
		446	(phydev->phy_id & phydrv->phy_id_mask);
		447	}
433	}	448	}
434		449
435	#ifdef CONFIG_PM	450	#ifdef CONFIG_PM

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

@@ -757,6 +757,7 @@ static const struct usb_device_id products[] = { · 756 unmodified lines
757	{QMI_FIXED_INTF(0x1199, 0x901c, 8)}, /* Sierra Wireless EM7700 */	757	{QMI_FIXED_INTF(0x1199, 0x901c, 8)}, /* Sierra Wireless EM7700 */
758	{QMI_FIXED_INTF(0x1199, 0x901f, 8)}, /* Sierra Wireless EM7355 */	758	{QMI_FIXED_INTF(0x1199, 0x901f, 8)}, /* Sierra Wireless EM7355 */
759	{QMI_FIXED_INTF(0x1199, 0x9041, 8)}, /* Sierra Wireless MC7305/MC7355 */	759	{QMI_FIXED_INTF(0x1199, 0x9041, 8)}, /* Sierra Wireless MC7305/MC7355 */
		760	{QMI_FIXED_INTF(0x1199, 0x9041, 10)}, /* Sierra Wireless MC7305/MC7355 */
760	{QMI_FIXED_INTF(0x1199, 0x9051, 8)}, /* Netgear AirCard 340U */	761	{QMI_FIXED_INTF(0x1199, 0x9051, 8)}, /* Netgear AirCard 340U */
761	{QMI_FIXED_INTF(0x1199, 0x9053, 8)}, /* Sierra Wireless Modem */	762	{QMI_FIXED_INTF(0x1199, 0x9053, 8)}, /* Sierra Wireless Modem */
762	{QMI_FIXED_INTF(0x1199, 0x9054, 8)}, /* Sierra Wireless Modem */	763	{QMI_FIXED_INTF(0x1199, 0x9054, 8)}, /* Sierra Wireless Modem */

drivers/net/virtio_net.c+2−1

@@ -1828,7 +1828,8 @@ static int virtnet_probe(struct virtio_device *vdev) · 1827 unmodified lines
1828	else	1828	else
1829	vi->hdr_len = sizeof(struct virtio_net_hdr);	1829	vi->hdr_len = sizeof(struct virtio_net_hdr);
1830		1830
1831	if (virtio_has_feature(vdev, VIRTIO_F_ANY_LAYOUT))	1831	if (virtio_has_feature(vdev, VIRTIO_F_ANY_LAYOUT) \|\|
		1832	virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
1832	vi->any_header_sg = true;	1833	vi->any_header_sg = true;
1833		1834
1834	if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ))	1835	if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ))

drivers/net/wireless/ath/ath9k/hw.c+1−0

@@ -279,6 +279,7 @@ static void ath9k_hw_read_revisions(struct ath_hw *ah) · 278 unmodified lines
279	return;	279	return;
280	case AR9300_DEVID_QCA956X:	280	case AR9300_DEVID_QCA956X:
281	ah->hw_version.macVersion = AR_SREV_VERSION_9561;	281	ah->hw_version.macVersion = AR_SREV_VERSION_9561;
		282	return;
282	}	283	}
283		284
284	val = REG_READ(ah, AR_SREV) & AR_SREV_ID;	285	val = REG_READ(ah, AR_SREV) & AR_SREV_ID;

drivers/net/wireless/iwlwifi/iwl-fh.h+6−0

 #define RX_QUEUE_MASK                         255
 #define RX_QUEUE_SIZE_LOG                     8
+/*
+ * RX related structures and functions
+ */
+#define RX_FREE_BUFFERS 64
+#define RX_LOW_WATERMARK 8
 /**
  * struct iwl_rb_status - reserve buffer status
  * 	host memory mapped FH registers

drivers/net/wireless/iwlwifi/iwl-nvm-parse.c+5−7

@@ -540,13 +540,11 @@ static void iwl_set_hw_address_family_8000(struct device *dev, · 539 unmodified lines
540	hw_addr = (const u8 *)(mac_override +	540	hw_addr = (const u8 *)(mac_override +
541	MAC_ADDRESS_OVERRIDE_FAMILY_8000);	541	MAC_ADDRESS_OVERRIDE_FAMILY_8000);
542		542
543	/* The byte order is little endian 16 bit, meaning 214365 */	543	/*
544	data->hw_addr[0] = hw_addr[1];	544	* Store the MAC address from MAO section.
545	data->hw_addr[1] = hw_addr[0];	545	* No byte swapping is required in MAO section
546	data->hw_addr[2] = hw_addr[3];	546	*/
547	data->hw_addr[3] = hw_addr[2];	547	memcpy(data->hw_addr, hw_addr, ETH_ALEN);
548	data->hw_addr[4] = hw_addr[5];
549	data->hw_addr[5] = hw_addr[4];
550		548
551	/*	549	/*
552	* Force the use of the OTP MAC address in case of reserved MAC	550	* Force the use of the OTP MAC address in case of reserved MAC

drivers/net/wireless/iwlwifi/mvm/fw-api-scan.h+2−1

  * iwl_umac_scan_flags
  *@IWL_UMAC_SCAN_FLAG_PREEMPTIVE: scan process triggered by this scan request
  *	can be preempted by other scan requests with higher priority.
- *	The low priority scan is aborted.
+ *	The low priority scan will be resumed when the higher proirity scan is
+ *	completed.
  *@IWL_UMAC_SCAN_FLAG_START_NOTIF: notification will be sent to the driver
  *	when scan starts.
  */

drivers/net/wireless/iwlwifi/mvm/scan.c+3−0

@@ -1109,6 +1109,9 @@ static int iwl_mvm_scan_umac(struct iwl_mvm mvm, struct ieee80211_vif vif, · 1108 unmodified lines
1109	cmd->uid = cpu_to_le32(uid);	1109	cmd->uid = cpu_to_le32(uid);
1110	cmd->general_flags = cpu_to_le32(iwl_mvm_scan_umac_flags(mvm, params));	1110	cmd->general_flags = cpu_to_le32(iwl_mvm_scan_umac_flags(mvm, params));
1111		1111
		1112	if (type == IWL_MVM_SCAN_SCHED)
		1113	cmd->flags = cpu_to_le32(IWL_UMAC_SCAN_FLAG_PREEMPTIVE);
		1114
1112	if (iwl_mvm_scan_use_ebs(mvm, vif, n_iterations))	1115	if (iwl_mvm_scan_use_ebs(mvm, vif, n_iterations))
1113	cmd->channel_flags = IWL_SCAN_CHANNEL_FLAG_EBS \|	1116	cmd->channel_flags = IWL_SCAN_CHANNEL_FLAG_EBS \|
1114	IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE \|	1117	IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE \|

drivers/net/wireless/iwlwifi/mvm/sta.c+2−1

 	bool mcast = !(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE);
 	u8 sta_id;
 	int ret;
+	static const u8 __maybe_unused zero_addr[ETH_ALEN] = {0};
 	lockdep_assert_held(&mvm->mutex);
 end:
 	IWL_DEBUG_WEP(mvm, "key: cipher=%x len=%d idx=%d sta=%pM ret=%d\n",
 		      keyconf->cipher, keyconf->keylen, keyconf->keyidx,
-		      sta->addr, ret);
+		      sta ? sta->addr : zero_addr, ret);
 	return ret;
 }

drivers/net/wireless/iwlwifi/mvm/time-event.c+1−1

@@ -86,7 +86,7 @@ void iwl_mvm_te_clear_data(struct iwl_mvm *mvm, · 85 unmodified lines
86	{	86	{
87	lockdep_assert_held(&mvm->time_event_lock);	87	lockdep_assert_held(&mvm->time_event_lock);
88		88
89	if (te_data->id == TE_MAX)	89	if (!te_data->vif)
90	return;	90	return;
91		91
92	list_del(&te_data->list);	92	list_del(&te_data->list);

drivers/net/wireless/iwlwifi/mvm/tx.c+1−1

@@ -252,7 +252,7 @@ void iwl_mvm_set_tx_cmd_rate(struct iwl_mvm mvm, struct iwl_tx_cmd tx_cmd, · 251 unmodified lines
252		252
253	if (info->band == IEEE80211_BAND_2GHZ &&	253	if (info->band == IEEE80211_BAND_2GHZ &&
254	!iwl_mvm_bt_coex_is_shared_ant_avail(mvm))	254	!iwl_mvm_bt_coex_is_shared_ant_avail(mvm))
255	rate_flags = BIT(mvm->cfg->non_shared_ant) << RATE_MCS_ANT_POS;	255	rate_flags = mvm->cfg->non_shared_ant << RATE_MCS_ANT_POS;
256	else	256	else
257	rate_flags =	257	rate_flags =
258	BIT(mvm->mgmt_last_antenna_idx) << RATE_MCS_ANT_POS;	258	BIT(mvm->mgmt_last_antenna_idx) << RATE_MCS_ANT_POS;

drivers/net/wireless/iwlwifi/pcie/drv.c+3−2

 /* 3165 Series */
 	{IWL_PCI_DEVICE(0x3165, 0x4010, iwl3165_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x3165, 0x4012, iwl3165_2ac_cfg)},
+	{IWL_PCI_DEVICE(0x3166, 0x4212, iwl3165_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x3165, 0x4410, iwl3165_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x3165, 0x4510, iwl3165_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x3165, 0x4110, iwl3165_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x3166, 0x4310, iwl3165_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x3166, 0x4210, iwl3165_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x3165, 0x8010, iwl3165_2ac_cfg)},
+	{IWL_PCI_DEVICE(0x3165, 0x8110, iwl3165_2ac_cfg)},
 /* 7265 Series */
 	{IWL_PCI_DEVICE(0x095A, 0x5010, iwl7265_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x24F4, 0x1130, iwl8260_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x24F4, 0x1030, iwl8260_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x24F3, 0xC010, iwl8260_2ac_cfg)},
+	{IWL_PCI_DEVICE(0x24F3, 0xC110, iwl8260_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x24F3, 0xD010, iwl8260_2ac_cfg)},
-	{IWL_PCI_DEVICE(0x24F4, 0xC030, iwl8260_2ac_cfg)},
-	{IWL_PCI_DEVICE(0x24F4, 0xD030, iwl8260_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x24F3, 0xC050, iwl8260_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x24F3, 0xD050, iwl8260_2ac_cfg)},
 	{IWL_PCI_DEVICE(0x24F3, 0x8010, iwl8260_2ac_cfg)},

drivers/net/wireless/iwlwifi/pcie/internal.h+8−43

 #include "iwl-io.h"
 #include "iwl-op-mode.h"
-/*
- * RX related structures and functions
- */
-#define RX_NUM_QUEUES 1
-#define RX_POST_REQ_ALLOC 2
-#define RX_CLAIM_REQ_ALLOC 8
-#define RX_POOL_SIZE ((RX_CLAIM_REQ_ALLOC - RX_POST_REQ_ALLOC) * RX_NUM_QUEUES)
-#define RX_LOW_WATERMARK 8
 struct iwl_host_cmd;
 /*This file includes the declaration that are internal to the
  * struct iwl_rxq - Rx queue
  * @bd: driver's pointer to buffer of receive buffer descriptors (rbd)
  * @bd_dma: bus address of buffer of receive buffer descriptors (rbd)
+ * @pool:
+ * @queue:
  * @read: Shared index to newest available Rx buffer
  * @write: Shared index to oldest written Rx packet
  * @free_count: Number of pre-allocated buffers in rx_free
- * @used_count: Number of RBDs handled to allocator to use for allocation
  * @write_actual:
- * @rx_free: list of RBDs with allocated RB ready for use
+ * @rx_free: list of free SKBs for use
- * @rx_used: list of RBDs with no RB attached
+ * @rx_used: List of Rx buffers with no SKB
  * @need_update: flag to indicate we need to update read/write index
  * @rb_stts: driver's pointer to receive buffer status
  * @rb_stts_dma: bus address of receive buffer status
  * @lock:
- * @pool: initial pool of iwl_rx_mem_buffer for the queue
- * @queue: actual rx queue
  *
  * NOTE:  rx_free and rx_used are used as a FIFO for iwl_rx_mem_buffers
  */
 struct iwl_rxq {
 	__le32 *bd;
 	dma_addr_t bd_dma;
+	struct iwl_rx_mem_buffer pool[RX_QUEUE_SIZE + RX_FREE_BUFFERS];
+	struct iwl_rx_mem_buffer *queue[RX_QUEUE_SIZE];
 	u32 read;
 	u32 write;
 	u32 free_count;
-	u32 used_count;
 	u32 write_actual;
 	struct list_head rx_free;
 	struct list_head rx_used;
 	struct iwl_rb_status *rb_stts;
 	dma_addr_t rb_stts_dma;
 	spinlock_t lock;
-	struct iwl_rx_mem_buffer pool[RX_QUEUE_SIZE];
-	struct iwl_rx_mem_buffer *queue[RX_QUEUE_SIZE];
-};
-/**
- * struct iwl_rb_allocator - Rx allocator
- * @pool: initial pool of allocator
- * @req_pending: number of requests the allcator had not processed yet
- * @req_ready: number of requests honored and ready for claiming
- * @rbd_allocated: RBDs with pages allocated and ready to be handled to
- *	the queue. This is a list of &struct iwl_rx_mem_buffer
- * @rbd_empty: RBDs with no page attached for allocator use. This is a list
- *	of &struct iwl_rx_mem_buffer
- * @lock: protects the rbd_allocated and rbd_empty lists
- * @alloc_wq: work queue for background calls
- * @rx_alloc: work struct for background calls
- */
-struct iwl_rb_allocator {
-	struct iwl_rx_mem_buffer pool[RX_POOL_SIZE];
-	atomic_t req_pending;
-	atomic_t req_ready;
-	struct list_head rbd_allocated;
-	struct list_head rbd_empty;
-	spinlock_t lock;
-	struct workqueue_struct *alloc_wq;
-	struct work_struct rx_alloc;
 };
 struct iwl_dma_ptr {
 /**
  * struct iwl_trans_pcie - PCIe transport specific data
  * @rxq: all the RX queue data
- * @rba: allocator for RX replenishing
+ * @rx_replenish: work that will be called when buffers need to be allocated
  * @drv - pointer to iwl_drv
  * @trans: pointer to the generic transport area
  * @scd_base_addr: scheduler sram base address in SRAM
  */
 struct iwl_trans_pcie {
 	struct iwl_rxq rxq;
-	struct iwl_rb_allocator rba;
+	struct work_struct rx_replenish;
 	struct iwl_trans *trans;
 	struct iwl_drv *drv;

drivers/net/wireless/iwlwifi/pcie/rx.c+83−331

@@ -1,7 +1,7 @@
1	/******************************************************************************	1	/******************************************************************************
2	*	2	*
3	* Copyright(c) 2003 - 2014 Intel Corporation. All rights reserved.	3	* Copyright(c) 2003 - 2014 Intel Corporation. All rights reserved.
4	* Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH	4	* Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
5	*	5	*
6	* Portions of this file are derived from the ipw3945 project, as well	6	* Portions of this file are derived from the ipw3945 project, as well
7	* as portions of the ieee80211 subsystem header files.	7	* as portions of the ieee80211 subsystem header files.
@@ -74,29 +74,16 @@ · 66 unmodified lines
74	* resets the Rx queue buffers with new memory.	74	* resets the Rx queue buffers with new memory.
75	*	75	*
76	* The management in the driver is as follows:	76	* The management in the driver is as follows:
77	* + A list of pre-allocated RBDs is stored in iwl->rxq->rx_free.	77	* + A list of pre-allocated SKBs is stored in iwl->rxq->rx_free. When
78	* When the interrupt handler is called, the request is processed.	78	* iwl->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
79	* The page is either stolen - transferred to the upper layer	79	* to replenish the iwl->rxq->rx_free.
80	* or reused - added immediately to the iwl->rxq->rx_free list.	80	* + In iwl_pcie_rx_replenish (scheduled) if 'processed' != 'read' then the
81	* + When the page is stolen - the driver updates the matching queue's used	81	* iwl->rxq is replenished and the READ INDEX is updated (updating the
82	* count, detaches the RBD and transfers it to the queue used list.	82	* 'processed' and 'read' driver indexes as well)
83	* When there are two used RBDs - they are transferred to the allocator empty
84	* list. Work is then scheduled for the allocator to start allocating
85	* eight buffers.
86	* When there are another 6 used RBDs - they are transferred to the allocator
87	* empty list and the driver tries to claim the pre-allocated buffers and
88	* add them to iwl->rxq->rx_free. If it fails - it continues to claim them
89	* until ready.
90	* When there are 8+ buffers in the free list - either from allocation or from
91	* 8 reused unstolen pages - restock is called to update the FW and indexes.
92	* + In order to make sure the allocator always has RBDs to use for allocation
93	* the allocator has initial pool in the size of num_queues*(8-2) - the
94	* maximum missing RBDs per allocation request (request posted with 2
95	* empty RBDs, there is no guarantee when the other 6 RBDs are supplied).
96	* The queues supplies the recycle of the rest of the RBDs.
97	* + A received packet is processed and handed to the kernel network stack,	83	* + A received packet is processed and handed to the kernel network stack,
98	* detached from the iwl->rxq. The driver 'processed' index is updated.	84	* detached from the iwl->rxq. The driver 'processed' index is updated.
99	* + If there are no allocated buffers in iwl->rxq->rx_free,	85	* + The Host/Firmware iwl->rxq is replenished at irq thread time from the
		86	* rx_free list. If there are no allocated buffers in iwl->rxq->rx_free,
100	* the READ INDEX is not incremented and iwl->status(RX_STALLED) is set.	87	* the READ INDEX is not incremented and iwl->status(RX_STALLED) is set.
101	* If there were enough free buffers and RX_STALLED is set it is cleared.	88	* If there were enough free buffers and RX_STALLED is set it is cleared.
102	*	89	*
@@ -105,32 +92,18 @@ · 2 unmodified lines
105	*	92	*
106	* iwl_rxq_alloc() Allocates rx_free	93	* iwl_rxq_alloc() Allocates rx_free
107	* iwl_pcie_rx_replenish() Replenishes rx_free list from rx_used, and calls	94	* iwl_pcie_rx_replenish() Replenishes rx_free list from rx_used, and calls
108	* iwl_pcie_rxq_restock.	95	* iwl_pcie_rxq_restock
109	* Used only during initialization.
110	* iwl_pcie_rxq_restock() Moves available buffers from rx_free into Rx	96	* iwl_pcie_rxq_restock() Moves available buffers from rx_free into Rx
111	* queue, updates firmware pointers, and updates	97	* queue, updates firmware pointers, and updates
112	* the WRITE index.	98	* the WRITE index. If insufficient rx_free buffers
113	* iwl_pcie_rx_allocator() Background work for allocating pages.	99	* are available, schedules iwl_pcie_rx_replenish
114	*	100	*
115	* -- enable interrupts --	101	* -- enable interrupts --
116	* ISR - iwl_rx() Detach iwl_rx_mem_buffers from pool up to the	102	* ISR - iwl_rx() Detach iwl_rx_mem_buffers from pool up to the
117	* READ INDEX, detaching the SKB from the pool.	103	* READ INDEX, detaching the SKB from the pool.
118	* Moves the packet buffer from queue to rx_used.	104	* Moves the packet buffer from queue to rx_used.
119	* Posts and claims requests to the allocator.
120	* Calls iwl_pcie_rxq_restock to refill any empty	105	* Calls iwl_pcie_rxq_restock to refill any empty
121	* slots.	106	* slots.
122	*
123	* RBD life-cycle:
124	*
125	* Init:
126	* rxq.pool -> rxq.rx_used -> rxq.rx_free -> rxq.queue
127	*
128	* Regular Receive interrupt:
129	* Page Stolen:
130	* rxq.queue -> rxq.rx_used -> allocator.rbd_empty ->
131	* allocator.rbd_allocated -> rxq.rx_free -> rxq.queue
132	* Page not Stolen:
133	* rxq.queue -> rxq.rx_free -> rxq.queue
134	* ...	107	* ...
135	*	108	*
136	*/	109	*/
@@ -267,6 +240,10 @@ static void iwl_pcie_rxq_restock(struct iwl_trans *trans) · 130 unmodified lines
267	rxq->free_count--;	240	rxq->free_count--;
268	}	241	}
269	spin_unlock(&rxq->lock);	242	spin_unlock(&rxq->lock);
		243	/* If the pre-allocated buffer pool is dropping low, schedule to
		244	* refill it */
		245	if (rxq->free_count <= RX_LOW_WATERMARK)
		246	schedule_work(&trans_pcie->rx_replenish);
270		247
271	/* If we've added more space for the firmware to place data, tell it.	248	/* If we've added more space for the firmware to place data, tell it.
272	* Increment device's write pointer in multiples of 8. */	249	* Increment device's write pointer in multiples of 8. */
@@ -277,44 +254,6 @@ static void iwl_pcie_rxq_restock(struct iwl_trans *trans) · 4 unmodified lines
277	}	254	}
278	}	255	}
279		256
280	/*
281	* iwl_pcie_rx_alloc_page - allocates and returns a page.
282	*
283	*/
284	static struct page iwl_pcie_rx_alloc_page(struct iwl_trans trans)
285	{
286	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
287	struct iwl_rxq *rxq = &trans_pcie->rxq;
288	struct page *page;
289	gfp_t gfp_mask = GFP_KERNEL;
290
291	if (rxq->free_count > RX_LOW_WATERMARK)
292	gfp_mask \|= __GFP_NOWARN;
293
294	if (trans_pcie->rx_page_order > 0)
295	gfp_mask \|= __GFP_COMP;
296
297	/* Alloc a new receive buffer */
298	page = alloc_pages(gfp_mask, trans_pcie->rx_page_order);
299	if (!page) {
300	if (net_ratelimit())
301	IWL_DEBUG_INFO(trans, "alloc_pages failed, order: %d\n",
302	trans_pcie->rx_page_order);
303	/* Issue an error if the hardware has consumed more than half
304	* of its free buffer list and we don't have enough
305	* pre-allocated buffers.
306	` */
307	if (rxq->free_count <= RX_LOW_WATERMARK &&
308	iwl_rxq_space(rxq) > (RX_QUEUE_SIZE / 2) &&
309	net_ratelimit())
310	IWL_CRIT(trans,
311	"Failed to alloc_pages with GFP_KERNEL. Only %u free buffers remaining.\n",
312	rxq->free_count);
313	return NULL;
314	}
315	return page;
316	}
317
318	/*	257	/*
319	* iwl_pcie_rxq_alloc_rbs - allocate a page for each used RBD	258	* iwl_pcie_rxq_alloc_rbs - allocate a page for each used RBD
320	*	259	*
@@ -324,12 +263,13 @@ static struct page iwl_pcie_rx_alloc_page(struct iwl_trans trans) · 3 unmodified lines
324	* iwl_pcie_rxq_restock. The latter function will update the HW to use the newly	263	* iwl_pcie_rxq_restock. The latter function will update the HW to use the newly
325	* allocated buffers.	264	* allocated buffers.
326	*/	265	*/
327	static void iwl_pcie_rxq_alloc_rbs(struct iwl_trans *trans)	266	static void iwl_pcie_rxq_alloc_rbs(struct iwl_trans *trans, gfp_t priority)
328	{	267	{
329	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);	268	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
330	struct iwl_rxq *rxq = &trans_pcie->rxq;	269	struct iwl_rxq *rxq = &trans_pcie->rxq;
331	struct iwl_rx_mem_buffer *rxb;	270	struct iwl_rx_mem_buffer *rxb;
332	struct page *page;	271	struct page *page;
		272	gfp_t gfp_mask = priority;
333		273
334	while (1) {	274	while (1) {
335	spin_lock(&rxq->lock);	275	spin_lock(&rxq->lock);
@@ -339,10 +279,32 @@ static void iwl_pcie_rxq_alloc_rbs(struct iwl_trans *trans) · 3 unmodified lines
339	}	279	}
340	spin_unlock(&rxq->lock);	280	spin_unlock(&rxq->lock);
341		281
		282	if (rxq->free_count > RX_LOW_WATERMARK)
		283	gfp_mask \|= __GFP_NOWARN;
		284
		285	if (trans_pcie->rx_page_order > 0)
		286	gfp_mask \|= __GFP_COMP;
		287
342	/* Alloc a new receive buffer */	288	/* Alloc a new receive buffer */
343	page = iwl_pcie_rx_alloc_page(trans);	289	page = alloc_pages(gfp_mask, trans_pcie->rx_page_order);
344	if (!page)	290	if (!page) {
		291	if (net_ratelimit())
		292	IWL_DEBUG_INFO(trans, "alloc_pages failed, "
		293	"order: %d\n",
		294	trans_pcie->rx_page_order);
		295
		296	if ((rxq->free_count <= RX_LOW_WATERMARK) &&
		297	net_ratelimit())
		298	IWL_CRIT(trans, "Failed to alloc_pages with %s."
		299	"Only %u free buffers remaining.\n",
		300	priority == GFP_ATOMIC ?
		301	"GFP_ATOMIC" : "GFP_KERNEL",
		302	rxq->free_count);
		303	/* We don't reschedule replenish work here -- we will
		304	* call the restock method and if it still needs
		305	* more buffers it will schedule replenish */
345	return;	306	return;
		307	}
346		308
347	spin_lock(&rxq->lock);	309	spin_lock(&rxq->lock);
348		310
@@ -393,7 +355,7 @@ static void iwl_pcie_rxq_free_rbs(struct iwl_trans *trans) · 44 unmodified lines
393		355
394	lockdep_assert_held(&rxq->lock);	356	lockdep_assert_held(&rxq->lock);
395		357
396	for (i = 0; i < RX_QUEUE_SIZE; i++) {	358	for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
397	if (!rxq->pool[i].page)	359	if (!rxq->pool[i].page)
398	continue;	360	continue;
399	dma_unmap_page(trans->dev, rxq->pool[i].page_dma,	361	dma_unmap_page(trans->dev, rxq->pool[i].page_dma,
@@ -410,144 +372,32 @@ static void iwl_pcie_rxq_free_rbs(struct iwl_trans *trans) · 10 unmodified lines
410	* When moving to rx_free an page is allocated for the slot.	372	* When moving to rx_free an page is allocated for the slot.
411	*	373	*
412	* Also restock the Rx queue via iwl_pcie_rxq_restock.	374	* Also restock the Rx queue via iwl_pcie_rxq_restock.
413	* This is called only during initialization	375	* This is called as a scheduled work item (except for during initialization)
414	*/	376	*/
415	static void iwl_pcie_rx_replenish(struct iwl_trans *trans)	377	static void iwl_pcie_rx_replenish(struct iwl_trans *trans, gfp_t gfp)
416	{	378	{
417	iwl_pcie_rxq_alloc_rbs(trans);	379	iwl_pcie_rxq_alloc_rbs(trans, gfp);
418		380
419	iwl_pcie_rxq_restock(trans);	381	iwl_pcie_rxq_restock(trans);
420	}	382	}
421		383
422	/*	384	static void iwl_pcie_rx_replenish_work(struct work_struct *data)
423	* iwl_pcie_rx_allocator - Allocates pages in the background for RX queues
424	*
425	* Allocates for each received request 8 pages
426	* Called as a scheduled work item.
427	*/
428	static void iwl_pcie_rx_allocator(struct iwl_trans *trans)
429	{
430	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
431	struct iwl_rb_allocator *rba = &trans_pcie->rba;
432
433	while (atomic_read(&rba->req_pending)) {
434	int i;
435	struct list_head local_empty;
436	struct list_head local_allocated;
437
438	INIT_LIST_HEAD(&local_allocated);
439	spin_lock(&rba->lock);
440	/* swap out the entire rba->rbd_empty to a local list */
441	list_replace_init(&rba->rbd_empty, &local_empty);
442	spin_unlock(&rba->lock);
443
444	for (i = 0; i < RX_CLAIM_REQ_ALLOC;) {
445	struct iwl_rx_mem_buffer *rxb;
446	struct page *page;
447
448	/* List should never be empty - each reused RBD is
449	* returned to the list, and initial pool covers any
450	* possible gap between the time the page is allocated
451	* to the time the RBD is added.
452	*/
453	BUG_ON(list_empty(&local_empty));
454	/* Get the first rxb from the rbd list */
455	rxb = list_first_entry(&local_empty,
456	struct iwl_rx_mem_buffer, list);
457	BUG_ON(rxb->page);
458
459	/* Alloc a new receive buffer */
460	page = iwl_pcie_rx_alloc_page(trans);
461	if (!page)
462	continue;
463	rxb->page = page;
464
465	/* Get physical address of the RB */
466	rxb->page_dma = dma_map_page(trans->dev, page, 0,
467	PAGE_SIZE << trans_pcie->rx_page_order,
468	DMA_FROM_DEVICE);
469	if (dma_mapping_error(trans->dev, rxb->page_dma)) {
470	rxb->page = NULL;
471	__free_pages(page, trans_pcie->rx_page_order);
472	continue;
473	}
474	/* dma address must be no more than 36 bits */
475	BUG_ON(rxb->page_dma & ~DMA_BIT_MASK(36));
476	/* and also 256 byte aligned! */
477	BUG_ON(rxb->page_dma & DMA_BIT_MASK(8));
478
479	/* move the allocated entry to the out list */
480	list_move(&rxb->list, &local_allocated);
481	i++;
482	}
483
484	spin_lock(&rba->lock);
485	/* add the allocated rbds to the allocator allocated list */
486	list_splice_tail(&local_allocated, &rba->rbd_allocated);
487	/* add the unused rbds back to the allocator empty list */
488	list_splice_tail(&local_empty, &rba->rbd_empty);
489	spin_unlock(&rba->lock);
490
491	atomic_dec(&rba->req_pending);
492	atomic_inc(&rba->req_ready);
493	}
494	}
495
496	/*
497	* iwl_pcie_rx_allocator_get - Returns the pre-allocated pages
498	.*
499	.* Called by queue when the queue posted allocation request and
500	* has freed 8 RBDs in order to restock itself.
501	*/
502	static int iwl_pcie_rx_allocator_get(struct iwl_trans *trans,
503	struct iwl_rx_mem_buffer
504	*out[RX_CLAIM_REQ_ALLOC])
505	{
506	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
507	struct iwl_rb_allocator *rba = &trans_pcie->rba;
508	int i;
509
510	if (atomic_dec_return(&rba->req_ready) < 0) {
511	atomic_inc(&rba->req_ready);
512	IWL_DEBUG_RX(trans,
513	"Allocation request not ready, pending requests = %d\n",
514	atomic_read(&rba->req_pending));
515	return -ENOMEM;
516	}
517
518	spin_lock(&rba->lock);
519	for (i = 0; i < RX_CLAIM_REQ_ALLOC; i++) {
520	/* Get next free Rx buffer, remove it from free list */
521	out[i] = list_first_entry(&rba->rbd_allocated,
522	struct iwl_rx_mem_buffer, list);
523	list_del(&out[i]->list);
524	}
525	spin_unlock(&rba->lock);
526
527	return 0;
528	}
529
530	static void iwl_pcie_rx_allocator_work(struct work_struct *data)
531	{	385	{
532	struct iwl_rb_allocator *rba_p =
533	container_of(data, struct iwl_rb_allocator, rx_alloc);
534	struct iwl_trans_pcie *trans_pcie =	386	struct iwl_trans_pcie *trans_pcie =
535	container_of(rba_p, struct iwl_trans_pcie, rba);	387	container_of(data, struct iwl_trans_pcie, rx_replenish);
536		388
537	iwl_pcie_rx_allocator(trans_pcie->trans);	389	iwl_pcie_rx_replenish(trans_pcie->trans, GFP_KERNEL);
538	}	390	}
539		391
540	static int iwl_pcie_rx_alloc(struct iwl_trans *trans)	392	static int iwl_pcie_rx_alloc(struct iwl_trans *trans)
541	{	393	{
542	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);	394	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
543	struct iwl_rxq *rxq = &trans_pcie->rxq;	395	struct iwl_rxq *rxq = &trans_pcie->rxq;
544	struct iwl_rb_allocator *rba = &trans_pcie->rba;
545	struct device *dev = trans->dev;	396	struct device *dev = trans->dev;
546		397
547	memset(&trans_pcie->rxq, 0, sizeof(trans_pcie->rxq));	398	memset(&trans_pcie->rxq, 0, sizeof(trans_pcie->rxq));
548		399
549	spin_lock_init(&rxq->lock);	400	spin_lock_init(&rxq->lock);
550	spin_lock_init(&rba->lock);
551		401
552	if (WARN_ON(rxq->bd \|\| rxq->rb_stts))	402	if (WARN_ON(rxq->bd \|\| rxq->rb_stts))
553	return -EINVAL;	403	return -EINVAL;
@@ -637,49 +487,15 @@ static void iwl_pcie_rx_init_rxb_lists(struct iwl_rxq *rxq) · 83 unmodified lines
637	INIT_LIST_HEAD(&rxq->rx_free);	487	INIT_LIST_HEAD(&rxq->rx_free);
638	INIT_LIST_HEAD(&rxq->rx_used);	488	INIT_LIST_HEAD(&rxq->rx_used);
639	rxq->free_count = 0;	489	rxq->free_count = 0;
640	rxq->used_count = 0;
641		490
642	for (i = 0; i < RX_QUEUE_SIZE; i++)	491	for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
643	list_add(&rxq->pool[i].list, &rxq->rx_used);	492	list_add(&rxq->pool[i].list, &rxq->rx_used);
644	}	493	}
645		494
646	static void iwl_pcie_rx_init_rba(struct iwl_rb_allocator *rba)
647	{
648	int i;
649
650	lockdep_assert_held(&rba->lock);
651
652	INIT_LIST_HEAD(&rba->rbd_allocated);
653	INIT_LIST_HEAD(&rba->rbd_empty);
654
655	for (i = 0; i < RX_POOL_SIZE; i++)
656	list_add(&rba->pool[i].list, &rba->rbd_empty);
657	}
658
659	static void iwl_pcie_rx_free_rba(struct iwl_trans *trans)
660	{
661	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
662	struct iwl_rb_allocator *rba = &trans_pcie->rba;
663	int i;
664
665	lockdep_assert_held(&rba->lock);
666
667	for (i = 0; i < RX_POOL_SIZE; i++) {
668	if (!rba->pool[i].page)
669	continue;
670	dma_unmap_page(trans->dev, rba->pool[i].page_dma,
671	PAGE_SIZE << trans_pcie->rx_page_order,
672	DMA_FROM_DEVICE);
673	__free_pages(rba->pool[i].page, trans_pcie->rx_page_order);
674	rba->pool[i].page = NULL;
675	}
676	}
677
678	int iwl_pcie_rx_init(struct iwl_trans *trans)	495	int iwl_pcie_rx_init(struct iwl_trans *trans)
679	{	496	{
680	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);	497	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
681	struct iwl_rxq *rxq = &trans_pcie->rxq;	498	struct iwl_rxq *rxq = &trans_pcie->rxq;
682	struct iwl_rb_allocator *rba = &trans_pcie->rba;
683	int i, err;	499	int i, err;
684		500
685	if (!rxq->bd) {	501	if (!rxq->bd) {
@@ -687,21 +503,11 @@ int iwl_pcie_rx_init(struct iwl_trans *trans) · 1 unmodified line
687	if (err)	503	if (err)
688	return err;	504	return err;
689	}	505	}
690	if (!rba->alloc_wq)
691	rba->alloc_wq = alloc_workqueue("rb_allocator",
692	WQ_HIGHPRI \| WQ_UNBOUND, 1);
693	INIT_WORK(&rba->rx_alloc, iwl_pcie_rx_allocator_work);
694
695	spin_lock(&rba->lock);
696	atomic_set(&rba->req_pending, 0);
697	atomic_set(&rba->req_ready, 0);
698	/* free all first - we might be reconfigured for a different size */
699	iwl_pcie_rx_free_rba(trans);
700	iwl_pcie_rx_init_rba(rba);
701	spin_unlock(&rba->lock);
702		506
703	spin_lock(&rxq->lock);	507	spin_lock(&rxq->lock);
704		508
		509	INIT_WORK(&trans_pcie->rx_replenish, iwl_pcie_rx_replenish_work);
		510
705	/* free all first - we might be reconfigured for a different size */	511	/* free all first - we might be reconfigured for a different size */
706	iwl_pcie_rxq_free_rbs(trans);	512	iwl_pcie_rxq_free_rbs(trans);
707	iwl_pcie_rx_init_rxb_lists(rxq);	513	iwl_pcie_rx_init_rxb_lists(rxq);
@@ -716,7 +522,7 @@ int iwl_pcie_rx_init(struct iwl_trans *trans) · 8 unmodified lines
716	memset(rxq->rb_stts, 0, sizeof(*rxq->rb_stts));	522	memset(rxq->rb_stts, 0, sizeof(*rxq->rb_stts));
717	spin_unlock(&rxq->lock);	523	spin_unlock(&rxq->lock);
718		524
719	iwl_pcie_rx_replenish(trans);	525	iwl_pcie_rx_replenish(trans, GFP_KERNEL);
720		526
721	iwl_pcie_rx_hw_init(trans, rxq);	527	iwl_pcie_rx_hw_init(trans, rxq);
722		528
@@ -731,7 +537,6 @@ void iwl_pcie_rx_free(struct iwl_trans *trans) · 8 unmodified lines
731	{	537	{
732	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);	538	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
733	struct iwl_rxq *rxq = &trans_pcie->rxq;	539	struct iwl_rxq *rxq = &trans_pcie->rxq;
734	struct iwl_rb_allocator *rba = &trans_pcie->rba;
735		540
736	/*if rxq->bd is NULL, it means that nothing has been allocated,	541	/*if rxq->bd is NULL, it means that nothing has been allocated,
737	* exit now */	542	* exit now */
@@ -740,15 +545,7 @@ void iwl_pcie_rx_free(struct iwl_trans *trans) · 2 unmodified lines
740	return;	545	return;
741	}	546	}
742		547
743	cancel_work_sync(&rba->rx_alloc);	548	cancel_work_sync(&trans_pcie->rx_replenish);
744	if (rba->alloc_wq) {
745	destroy_workqueue(rba->alloc_wq);
746	rba->alloc_wq = NULL;
747	}
748
749	spin_lock(&rba->lock);
750	iwl_pcie_rx_free_rba(trans);
751	spin_unlock(&rba->lock);
752		549
753	spin_lock(&rxq->lock);	550	spin_lock(&rxq->lock);
754	iwl_pcie_rxq_free_rbs(trans);	551	iwl_pcie_rxq_free_rbs(trans);
@@ -769,43 +566,6 @@ void iwl_pcie_rx_free(struct iwl_trans *trans) · 14 unmodified lines
769	rxq->rb_stts = NULL;	566	rxq->rb_stts = NULL;
770	}	567	}
771		568
772	/*
773	* iwl_pcie_rx_reuse_rbd - Recycle used RBDs
774	*
775	* Called when a RBD can be reused. The RBD is transferred to the allocator.
776	* When there are 2 empty RBDs - a request for allocation is posted
777	*/
778	static void iwl_pcie_rx_reuse_rbd(struct iwl_trans *trans,
779	struct iwl_rx_mem_buffer *rxb,
780	struct iwl_rxq *rxq)
781	{
782	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
783	struct iwl_rb_allocator *rba = &trans_pcie->rba;
784
785	/* Count the used RBDs */
786	rxq->used_count++;
787
788	/* Move the RBD to the used list, will be moved to allocator in batches
789	* before claiming or posting a request*/
790	list_add_tail(&rxb->list, &rxq->rx_used);
791
792	/* If we have RX_POST_REQ_ALLOC new released rx buffers -
793	* issue a request for allocator. Modulo RX_CLAIM_REQ_ALLOC is
794	* used for the case we failed to claim RX_CLAIM_REQ_ALLOC,
795	* after but we still need to post another request.
796	*/
797	if ((rxq->used_count % RX_CLAIM_REQ_ALLOC) == RX_POST_REQ_ALLOC) {
798	/* Move the 2 RBDs to the allocator ownership.
799	Allocator has another 6 from pool for the request completion*/
800	spin_lock(&rba->lock);
801	list_splice_tail_init(&rxq->rx_used, &rba->rbd_empty);
802	spin_unlock(&rba->lock);
803
804	atomic_inc(&rba->req_pending);
805	queue_work(rba->alloc_wq, &rba->rx_alloc);
806	}
807	}
808
809	static void iwl_pcie_rx_handle_rb(struct iwl_trans *trans,	569	static void iwl_pcie_rx_handle_rb(struct iwl_trans *trans,
810	struct iwl_rx_mem_buffer *rxb)	570	struct iwl_rx_mem_buffer *rxb)
811	{	571	{
@@ -928,13 +688,13 @@ static void iwl_pcie_rx_handle_rb(struct iwl_trans *trans, · 116 unmodified lines
928	*/	688	*/
929	__free_pages(rxb->page, trans_pcie->rx_page_order);	689	__free_pages(rxb->page, trans_pcie->rx_page_order);
930	rxb->page = NULL;	690	rxb->page = NULL;
931	iwl_pcie_rx_reuse_rbd(trans, rxb, rxq);	691	list_add_tail(&rxb->list, &rxq->rx_used);
932	} else {	692	} else {
933	list_add_tail(&rxb->list, &rxq->rx_free);	693	list_add_tail(&rxb->list, &rxq->rx_free);
934	rxq->free_count++;	694	rxq->free_count++;
935	}	695	}
936	} else	696	} else
937	iwl_pcie_rx_reuse_rbd(trans, rxb, rxq);	697	list_add_tail(&rxb->list, &rxq->rx_used);
938	}	698	}
939		699
940	/*	700	/*
@@ -944,7 +704,10 @@ static void iwl_pcie_rx_handle(struct iwl_trans *trans) · 3 unmodified lines
944	{	704	{
945	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);	705	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
946	struct iwl_rxq *rxq = &trans_pcie->rxq;	706	struct iwl_rxq *rxq = &trans_pcie->rxq;
947	u32 r, i, j;	707	u32 r, i;
		708	u8 fill_rx = 0;
		709	u32 count = 8;
		710	int total_empty;
948		711
949	restart:	712	restart:
950	spin_lock(&rxq->lock);	713	spin_lock(&rxq->lock);
@@ -957,6 +720,14 @@ restart: · 6 unmodified lines
957	if (i == r)	720	if (i == r)
958	IWL_DEBUG_RX(trans, "HW = SW = %d\n", r);	721	IWL_DEBUG_RX(trans, "HW = SW = %d\n", r);
959		722
		723	/* calculate total frames need to be restock after handling RX */
		724	total_empty = r - rxq->write_actual;
		725	if (total_empty < 0)
		726	total_empty += RX_QUEUE_SIZE;
		727
		728	if (total_empty > (RX_QUEUE_SIZE / 2))
		729	fill_rx = 1;
		730
960	while (i != r) {	731	while (i != r) {
961	struct iwl_rx_mem_buffer *rxb;	732	struct iwl_rx_mem_buffer *rxb;
962		733
@@ -968,48 +739,29 @@ restart: · 5 unmodified lines
968	iwl_pcie_rx_handle_rb(trans, rxb);	739	iwl_pcie_rx_handle_rb(trans, rxb);
969		740
970	i = (i + 1) & RX_QUEUE_MASK;	741	i = (i + 1) & RX_QUEUE_MASK;
971		742	/* If there are a lot of unused frames,
972	/* If we have RX_CLAIM_REQ_ALLOC released rx buffers -	743	* restock the Rx queue so ucode wont assert. */
973	* try to claim the pre-allocated buffers from the allocator */	744	if (fill_rx) {
974	if (rxq->used_count >= RX_CLAIM_REQ_ALLOC) {	745	count++;
975	struct iwl_rb_allocator *rba = &trans_pcie->rba;	746	if (count >= 8) {
976	struct iwl_rx_mem_buffer *out[RX_CLAIM_REQ_ALLOC];	747	rxq->read = i;
977		748	spin_unlock(&rxq->lock);
978	/* Add the remaining 6 empty RBDs for allocator use */	749	iwl_pcie_rx_replenish(trans, GFP_ATOMIC);
979	spin_lock(&rba->lock);	750	count = 0;
980	list_splice_tail_init(&rxq->rx_used, &rba->rbd_empty);	751	goto restart;
981	spin_unlock(&rba->lock);
982
983	/* If not ready - continue, will try to reclaim later.
984	* No need to reschedule work - allocator exits only on
985	* success */
986	if (!iwl_pcie_rx_allocator_get(trans, out)) {
987	/* If success - then RX_CLAIM_REQ_ALLOC
988	* buffers were retrieved and should be added
989	* to free list */
990	rxq->used_count -= RX_CLAIM_REQ_ALLOC;
991	for (j = 0; j < RX_CLAIM_REQ_ALLOC; j++) {
992	list_add_tail(&out[j]->list,
993	&rxq->rx_free);
994	rxq->free_count++;
995	}
996	}	752	}
997	}	753	}
998	/* handle restock for two cases:
999	* - we just pulled buffers from the allocator
1000	* - we have 8+ unstolen pages accumulated */
1001	if (rxq->free_count >= RX_CLAIM_REQ_ALLOC) {
1002	rxq->read = i;
1003	spin_unlock(&rxq->lock);
1004	iwl_pcie_rxq_restock(trans);
1005	goto restart;
1006	}
1007	}	754	}
1008		755
1009	/* Backtrack one entry */	756	/* Backtrack one entry */
1010	rxq->read = i;	757	rxq->read = i;
1011	spin_unlock(&rxq->lock);	758	spin_unlock(&rxq->lock);
1012		759
		760	if (fill_rx)
		761	iwl_pcie_rx_replenish(trans, GFP_ATOMIC);
		762	else
		763	iwl_pcie_rxq_restock(trans);
		764
1013	if (trans_pcie->napi.poll)	765	if (trans_pcie->napi.poll)
1014	napi_gro_flush(&trans_pcie->napi, false);	766	napi_gro_flush(&trans_pcie->napi, false);
1015	}	767	}

drivers/net/wireless/iwlwifi/pcie/trans.c+29−23

 static void iwl_pcie_set_pwr(struct iwl_trans *trans, bool vaux)
 {
-	if (!trans->cfg->apmg_not_supported)
+	if (trans->cfg->apmg_not_supported)
 		return;
 	if (vaux && pci_pme_capable(to_pci_dev(trans->dev), PCI_D3cold))
 	struct iwl_trans_pcie *trans_pcie;
 	struct iwl_trans *trans;
 	u16 pci_cmd;
-	int err;
+	int ret;
 	trans = iwl_trans_alloc(sizeof(struct iwl_trans_pcie),
 				&pdev->dev, cfg, &trans_ops_pcie, 0);
 	spin_lock_init(&trans_pcie->ref_lock);
 	init_waitqueue_head(&trans_pcie->ucode_write_waitq);
-	err = pci_enable_device(pdev);
+	ret = pci_enable_device(pdev);
-	if (err)
+	if (ret)
 		goto out_no_pci;
 	if (!cfg->base_params->pcie_l1_allowed) {
 	pci_set_master(pdev);
-	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36));
+	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(36));
-	if (!err)
+	if (!ret)
-		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(36));
+		ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(36));
-	if (err) {
+	if (ret) {
-		err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+		ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
-		if (!err)
+		if (!ret)
-			err = pci_set_consistent_dma_mask(pdev,
+			ret = pci_set_consistent_dma_mask(pdev,
 							  DMA_BIT_MASK(32));
 		/* both attempts failed: */
-		if (err) {
+		if (ret) {
 			dev_err(&pdev->dev, "No suitable DMA available\n");
 			goto out_pci_disable_device;
 		}
 	}
-	err = pci_request_regions(pdev, DRV_NAME);
+	ret = pci_request_regions(pdev, DRV_NAME);
-	if (err) {
+	if (ret) {
 		dev_err(&pdev->dev, "pci_request_regions failed\n");
 		goto out_pci_disable_device;
 	}
 	trans_pcie->hw_base = pci_ioremap_bar(pdev, 0);
 	if (!trans_pcie->hw_base) {
 		dev_err(&pdev->dev, "pci_ioremap_bar failed\n");
-		err = -ENODEV;
+		ret = -ENODEV;
 		goto out_pci_release_regions;
 	}
 	trans_pcie->pci_dev = pdev;
 	iwl_disable_interrupts(trans);
-	err = pci_enable_msi(pdev);
+	ret = pci_enable_msi(pdev);
-	if (err) {
+	if (ret) {
-		dev_err(&pdev->dev, "pci_enable_msi failed(0X%x)\n", err);
+		dev_err(&pdev->dev, "pci_enable_msi failed(0X%x)\n", ret);
 		/* enable rfkill interrupt: hw bug w/a */
 		pci_read_config_word(pdev, PCI_COMMAND, &pci_cmd);
 		if (pci_cmd & PCI_COMMAND_INTX_DISABLE) {
 	 */
 	if (trans->cfg->device_family == IWL_DEVICE_FAMILY_8000) {
 		unsigned long flags;
-		int ret;
 		trans->hw_rev = (trans->hw_rev & 0xfff0) |
 				(CSR_HW_REV_STEP(trans->hw_rev << 2) << 2);
+		ret = iwl_pcie_prepare_card_hw(trans);
+		if (ret) {
+			IWL_WARN(trans, "Exit HW not ready\n");
+			goto out_pci_disable_msi;
+		}
 		/*
 		 * in-order to recognize C step driver should read chip version
 		 * id located at the AUX bus MISC address space.
 	/* Initialize the wait queue for commands */
 	init_waitqueue_head(&trans_pcie->wait_command_queue);
-	if (iwl_pcie_alloc_ict(trans))
+	ret = iwl_pcie_alloc_ict(trans);
+	if (ret)
 		goto out_pci_disable_msi;
-	err = request_threaded_irq(pdev->irq, iwl_pcie_isr,
+	ret = request_threaded_irq(pdev->irq, iwl_pcie_isr,
 				   iwl_pcie_irq_handler,
 				   IRQF_SHARED, DRV_NAME, trans);
-	if (err) {
+	if (ret) {
 		IWL_ERR(trans, "Error allocating IRQ %d\n", pdev->irq);
 		goto out_free_ict;
 	}
 	pci_disable_device(pdev);
 out_no_pci:
 	iwl_trans_free(trans);
-	return ERR_PTR(err);
+	return ERR_PTR(ret);
 }

drivers/net/xen-netback/netback.c+3−3

@@ -1566,13 +1566,13 @@ static inline void xenvif_tx_dealloc_action(struct xenvif_queue *queue) · 1565 unmodified lines
1566	smp_rmb();	1566	smp_rmb();
1567		1567
1568	while (dc != dp) {	1568	while (dc != dp) {
1569	BUG_ON(gop - queue->tx_unmap_ops > MAX_PENDING_REQS);	1569	BUG_ON(gop - queue->tx_unmap_ops >= MAX_PENDING_REQS);
1570	pending_idx =	1570	pending_idx =
1571	queue->dealloc_ring[pending_index(dc++)];	1571	queue->dealloc_ring[pending_index(dc++)];
1572		1572
1573	pending_idx_release[gop-queue->tx_unmap_ops] =	1573	pending_idx_release[gop - queue->tx_unmap_ops] =
1574	pending_idx;	1574	pending_idx;
1575	queue->pages_to_unmap[gop-queue->tx_unmap_ops] =	1575	queue->pages_to_unmap[gop - queue->tx_unmap_ops] =
1576	queue->mmap_pages[pending_idx];	1576	queue->mmap_pages[pending_idx];
1577	gnttab_set_unmap_op(gop,	1577	gnttab_set_unmap_op(gop,
1578	idx_to_kaddr(queue, pending_idx),	1578	idx_to_kaddr(queue, pending_idx),

drivers/nvdimm/region_devs.c+5−0

 		nvdimm_bus_unlock(dev);
 	}
 	if (is_nd_btt(dev) && probe) {
+		struct nd_btt *nd_btt = to_nd_btt(dev);
 		nd_region = to_nd_region(dev->parent);
 		nvdimm_bus_lock(dev);
 		if (nd_region->btt_seed == dev)
 			nd_region_create_btt_seed(nd_region);
+		if (nd_region->ns_seed == &nd_btt->ndns->dev &&
+				is_nd_blk(dev->parent))
+			nd_region_create_blk_seed(nd_region);
 		nvdimm_bus_unlock(dev);
 	}
 }

drivers/parport/share.c+6−5

 	par_dev->dev.release = free_pardevice;
 	par_dev->devmodel = true;
 	ret = device_register(&par_dev->dev);
-	if (ret)
+	if (ret) {
-		goto err_put_dev;
+		put_device(&par_dev->dev);
+		goto err_put_port;
+	}
 	/* Chain this onto the list */
 	par_dev->prev = NULL;
 			spin_unlock(&port->physport->pardevice_lock);
 			pr_debug("%s: cannot grant exclusive access for device %s\n",
 				 port->name, name);
-			goto err_put_dev;
+			device_unregister(&par_dev->dev);
+			goto err_put_port;
 		}
 		port->flags |= PARPORT_FLAG_EXCL;
 	}
 	return par_dev;
-err_put_dev:
-	put_device(&par_dev->dev);
 err_free_devname:
 	kfree(devname);
 err_free_par_dev:

drivers/phy/Kconfig+2−0

 config PHY_PXA_28NM_HSIC
 	tristate "Marvell USB HSIC 28nm PHY Driver"
+	depends on HAS_IOMEM
 	select GENERIC_PHY
 	help
 	  Enable this to support Marvell USB HSIC PHY driver for Marvell
 config PHY_PXA_28NM_USB2
 	tristate "Marvell USB 2.0 28nm PHY Driver"
+	depends on HAS_IOMEM
 	select GENERIC_PHY
 	help
 	  Enable this to support Marvell USB 2.0 PHY driver for Marvell

drivers/phy/phy-berlin-usb.c+2−2

 static const u32 phy_berlin_pll_dividers[] = {
 	/* Berlin 2 */
-	CLK_REF_DIV(0xc) | FEEDBACK_CLK_DIV(0x54),
-	/* Berlin 2CD */
 	CLK_REF_DIV(0x6) | FEEDBACK_CLK_DIV(0x55),
+	/* Berlin 2CD/Q */
+	CLK_REF_DIV(0xc) | FEEDBACK_CLK_DIV(0x54),
 };
 struct phy_berlin_usb_priv {

drivers/phy/phy-ti-pipe3.c+41−131

@@ -28,7 +28,6 @@ · 27 unmodified lines
28	#include <linux/delay.h>	28	#include <linux/delay.h>
29	#include <linux/phy/omap_control_phy.h>	29	#include <linux/phy/omap_control_phy.h>
30	#include <linux/of_platform.h>	30	#include <linux/of_platform.h>
31	#include <linux/spinlock.h>
32		31
33	#define PLL_STATUS 0x00000004	32	#define PLL_STATUS 0x00000004
34	#define PLL_GO 0x00000008	33	#define PLL_GO 0x00000008
@@ -83,10 +82,6 @@ struct ti_pipe3 { · 48 unmodified lines
83	struct clk *refclk;	82	struct clk *refclk;
84	struct clk *div_clk;	83	struct clk *div_clk;
85	struct pipe3_dpll_map *dpll_map;	84	struct pipe3_dpll_map *dpll_map;
86	bool enabled;
87	spinlock_t lock; /* serialize clock enable/disable */
88	/* the below flag is needed specifically for SATA */
89	bool refclk_enabled;
90	};	85	};
91		86
92	static struct pipe3_dpll_map dpll_map_usb[] = {	87	static struct pipe3_dpll_map dpll_map_usb[] = {
@@ -137,6 +132,9 @@ static struct pipe3_dpll_params ti_pipe3_get_dpll_params(struct ti_pipe3 phy) · 44 unmodified lines
137	return NULL;	132	return NULL;
138	}	133	}
139		134
		135	static int ti_pipe3_enable_clocks(struct ti_pipe3 *phy);
		136	static void ti_pipe3_disable_clocks(struct ti_pipe3 *phy);
		137
140	static int ti_pipe3_power_off(struct phy *x)	138	static int ti_pipe3_power_off(struct phy *x)
141	{	139	{
142	struct ti_pipe3 *phy = phy_get_drvdata(x);	140	struct ti_pipe3 *phy = phy_get_drvdata(x);
@@ -217,6 +215,7 @@ static int ti_pipe3_init(struct phy *x) · 74 unmodified lines
217	u32 val;	215	u32 val;
218	int ret = 0;	216	int ret = 0;
219		217
		218	ti_pipe3_enable_clocks(phy);
220	/*	219	/*
221	* Set pcie_pcs register to 0x96 for proper functioning of phy	220	* Set pcie_pcs register to 0x96 for proper functioning of phy
222	* as recommended in AM572x TRM SPRUHZ6, section 18.5.2.2, table	221	* as recommended in AM572x TRM SPRUHZ6, section 18.5.2.2, table
@@ -250,33 +249,35 @@ static int ti_pipe3_exit(struct phy *x) · 27 unmodified lines
250	u32 val;	249	u32 val;
251	unsigned long timeout;	250	unsigned long timeout;
252		251
253	/* SATA DPLL can't be powered down due to Errata i783 and PCIe	252	/* SATA DPLL can't be powered down due to Errata i783 */
254	* does not have internal DPLL	253	if (of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-sata"))
255	*/
256	if (of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-sata") \|\|
257	of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-pcie"))
258	return 0;	254	return 0;
259		255
260	/* Put DPLL in IDLE mode */	256	/* PCIe doesn't have internal DPLL */
261	val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION2);	257	if (!of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-pcie")) {
262	val \|= PLL_IDLE;	258	/* Put DPLL in IDLE mode */
263	ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION2, val);	259	val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_CONFIGURATION2);
264		260	val \|= PLL_IDLE;
265	/* wait for LDO and Oscillator to power down */	261	ti_pipe3_writel(phy->pll_ctrl_base, PLL_CONFIGURATION2, val);
266	timeout = jiffies + msecs_to_jiffies(PLL_IDLE_TIME);
267	do {
268	cpu_relax();
269	val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_STATUS);
270	if ((val & PLL_TICOPWDN) && (val & PLL_LDOPWDN))
271	break;
272	} while (!time_after(jiffies, timeout));
273		262
274	if (!(val & PLL_TICOPWDN) \|\| !(val & PLL_LDOPWDN)) {	263	/* wait for LDO and Oscillator to power down */
275	dev_err(phy->dev, "Failed to power down: PLL_STATUS 0x%x\n",	264	timeout = jiffies + msecs_to_jiffies(PLL_IDLE_TIME);
276	val);	265	do {
277	return -EBUSY;	266	cpu_relax();
		267	val = ti_pipe3_readl(phy->pll_ctrl_base, PLL_STATUS);
		268	if ((val & PLL_TICOPWDN) && (val & PLL_LDOPWDN))
		269	break;
		270	} while (!time_after(jiffies, timeout));
		271
		272	if (!(val & PLL_TICOPWDN) \|\| !(val & PLL_LDOPWDN)) {
		273	dev_err(phy->dev, "Failed to power down: PLL_STATUS 0x%x\n",
		274	val);
		275	return -EBUSY;
		276	}
278	}	277	}
279		278
		279	ti_pipe3_disable_clocks(phy);
		280
280	return 0;	281	return 0;
281	}	282	}
282	static struct phy_ops ops = {	283	static struct phy_ops ops = {
@@ -306,7 +307,6 @@ static int ti_pipe3_probe(struct platform_device *pdev) · 23 unmodified lines
306	return -ENOMEM;	307	return -ENOMEM;
307		308
308	phy->dev = &pdev->dev;	309	phy->dev = &pdev->dev;
309	spin_lock_init(&phy->lock);
310		310
311	if (!of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {	311	if (!of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {
312	match = of_match_device(ti_pipe3_id_table, &pdev->dev);	312	match = of_match_device(ti_pipe3_id_table, &pdev->dev);
@@ -402,6 +402,10 @@ static int ti_pipe3_probe(struct platform_device *pdev) · 89 unmodified lines
402		402
403	platform_set_drvdata(pdev, phy);	403	platform_set_drvdata(pdev, phy);
404	pm_runtime_enable(phy->dev);	404	pm_runtime_enable(phy->dev);
		405	/* Prevent auto-disable of refclk for SATA PHY due to Errata i783 */
		406	if (of_device_is_compatible(node, "ti,phy-pipe3-sata"))
		407	if (!IS_ERR(phy->refclk))
		408	clk_prepare_enable(phy->refclk);
405		409
406	generic_phy = devm_phy_create(phy->dev, NULL, &ops);	410	generic_phy = devm_phy_create(phy->dev, NULL, &ops);
407	if (IS_ERR(generic_phy))	411	if (IS_ERR(generic_phy))
@@ -413,63 +417,33 @@ static int ti_pipe3_probe(struct platform_device *pdev) · 5 unmodified lines
413	if (IS_ERR(phy_provider))	417	if (IS_ERR(phy_provider))
414	return PTR_ERR(phy_provider);	418	return PTR_ERR(phy_provider);
415		419
416	pm_runtime_get(&pdev->dev);
417
418	return 0;	420	return 0;
419	}	421	}
420		422
421	static int ti_pipe3_remove(struct platform_device *pdev)	423	static int ti_pipe3_remove(struct platform_device *pdev)
422	{	424	{
423	if (!pm_runtime_suspended(&pdev->dev))
424	pm_runtime_put(&pdev->dev);
425	pm_runtime_disable(&pdev->dev);	425	pm_runtime_disable(&pdev->dev);
426		426
427	return 0;	427	return 0;
428	}	428	}
429		429
430	#ifdef CONFIG_PM	430	static int ti_pipe3_enable_clocks(struct ti_pipe3 *phy)
431	static int ti_pipe3_enable_refclk(struct ti_pipe3 *phy)
432	{	431	{
433	if (!IS_ERR(phy->refclk) && !phy->refclk_enabled) {	432	int ret = 0;
434	int ret;
435		433
		434	if (!IS_ERR(phy->refclk)) {
436	ret = clk_prepare_enable(phy->refclk);	435	ret = clk_prepare_enable(phy->refclk);
437	if (ret) {	436	if (ret) {
438	dev_err(phy->dev, "Failed to enable refclk %d\n", ret);	437	dev_err(phy->dev, "Failed to enable refclk %d\n", ret);
439	return ret;	438	return ret;
440	}	439	}
441	phy->refclk_enabled = true;
442	}	440	}
443		441
444	return 0;
445	}
446
447	static void ti_pipe3_disable_refclk(struct ti_pipe3 *phy)
448	{
449	if (!IS_ERR(phy->refclk))
450	clk_disable_unprepare(phy->refclk);
451
452	phy->refclk_enabled = false;
453	}
454
455	static int ti_pipe3_enable_clocks(struct ti_pipe3 *phy)
456	{
457	int ret = 0;
458	unsigned long flags;
459
460	spin_lock_irqsave(&phy->lock, flags);
461	if (phy->enabled)
462	goto err1;
463
464	ret = ti_pipe3_enable_refclk(phy);
465	if (ret)
466	goto err1;
467
468	if (!IS_ERR(phy->wkupclk)) {	442	if (!IS_ERR(phy->wkupclk)) {
469	ret = clk_prepare_enable(phy->wkupclk);	443	ret = clk_prepare_enable(phy->wkupclk);
470	if (ret) {	444	if (ret) {
471	dev_err(phy->dev, "Failed to enable wkupclk %d\n", ret);	445	dev_err(phy->dev, "Failed to enable wkupclk %d\n", ret);
472	goto err2;	446	goto disable_refclk;
473	}	447	}
474	}	448	}
475		449
@@ -477,96 +451,33 @@ static int ti_pipe3_enable_clocks(struct ti_pipe3 *phy) · 1 unmodified line
477	ret = clk_prepare_enable(phy->div_clk);	451	ret = clk_prepare_enable(phy->div_clk);
478	if (ret) {	452	if (ret) {
479	dev_err(phy->dev, "Failed to enable div_clk %d\n", ret);	453	dev_err(phy->dev, "Failed to enable div_clk %d\n", ret);
480	goto err3;	454	goto disable_wkupclk;
481	}	455	}
482	}	456	}
483		457
484	phy->enabled = true;
485	spin_unlock_irqrestore(&phy->lock, flags);
486	return 0;	458	return 0;
487		459
488	err3:	460	disable_wkupclk:
489	if (!IS_ERR(phy->wkupclk))	461	if (!IS_ERR(phy->wkupclk))
490	clk_disable_unprepare(phy->wkupclk);	462	clk_disable_unprepare(phy->wkupclk);
491		463
492	err2:	464	disable_refclk:
493	if (!IS_ERR(phy->refclk))	465	if (!IS_ERR(phy->refclk))
494	clk_disable_unprepare(phy->refclk);	466	clk_disable_unprepare(phy->refclk);
495		467
496	ti_pipe3_disable_refclk(phy);
497	err1:
498	spin_unlock_irqrestore(&phy->lock, flags);
499	return ret;	468	return ret;
500	}	469	}
501		470
502	static void ti_pipe3_disable_clocks(struct ti_pipe3 *phy)	471	static void ti_pipe3_disable_clocks(struct ti_pipe3 *phy)
503	{	472	{
504	unsigned long flags;
505
506	spin_lock_irqsave(&phy->lock, flags);
507	if (!phy->enabled) {
508	spin_unlock_irqrestore(&phy->lock, flags);
509	return;
510	}
511
512	if (!IS_ERR(phy->wkupclk))	473	if (!IS_ERR(phy->wkupclk))
513	clk_disable_unprepare(phy->wkupclk);	474	clk_disable_unprepare(phy->wkupclk);
514	/* Don't disable refclk for SATA PHY due to Errata i783 */	475	if (!IS_ERR(phy->refclk))
515	if (!of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-sata"))	476	clk_disable_unprepare(phy->refclk);
516	ti_pipe3_disable_refclk(phy);
517	if (!IS_ERR(phy->div_clk))	477	if (!IS_ERR(phy->div_clk))
518	clk_disable_unprepare(phy->div_clk);	478	clk_disable_unprepare(phy->div_clk);
519	phy->enabled = false;
520	spin_unlock_irqrestore(&phy->lock, flags);
521	}
522
523	static int ti_pipe3_runtime_suspend(struct device *dev)
524	{
525	struct ti_pipe3 *phy = dev_get_drvdata(dev);
526
527	ti_pipe3_disable_clocks(phy);
528	return 0;
529	}	479	}
530		480
531	static int ti_pipe3_runtime_resume(struct device *dev)
532	{
533	struct ti_pipe3 *phy = dev_get_drvdata(dev);
534	int ret = 0;
535
536	ret = ti_pipe3_enable_clocks(phy);
537	return ret;
538	}
539
540	static int ti_pipe3_suspend(struct device *dev)
541	{
542	struct ti_pipe3 *phy = dev_get_drvdata(dev);
543
544	ti_pipe3_disable_clocks(phy);
545	return 0;
546	}
547
548	static int ti_pipe3_resume(struct device *dev)
549	{
550	struct ti_pipe3 *phy = dev_get_drvdata(dev);
551	int ret;
552
553	ret = ti_pipe3_enable_clocks(phy);
554	if (ret)
555	return ret;
556
557	pm_runtime_disable(dev);
558	pm_runtime_set_active(dev);
559	pm_runtime_enable(dev);
560	return 0;
561	}
562	#endif
563
564	static const struct dev_pm_ops ti_pipe3_pm_ops = {
565	SET_RUNTIME_PM_OPS(ti_pipe3_runtime_suspend,
566	ti_pipe3_runtime_resume, NULL)
567	SET_SYSTEM_SLEEP_PM_OPS(ti_pipe3_suspend, ti_pipe3_resume)
568	};
569
570	static const struct of_device_id ti_pipe3_id_table[] = {	481	static const struct of_device_id ti_pipe3_id_table[] = {
571	{	482	{
572	.compatible = "ti,phy-usb3",	483	.compatible = "ti,phy-usb3",
@@ -592,7 +503,6 @@ static struct platform_driver ti_pipe3_driver = { · 19 unmodified lines
592	.remove = ti_pipe3_remove,	503	.remove = ti_pipe3_remove,
593	.driver = {	504	.driver = {
594	.name = "ti-pipe3",	505	.name = "ti-pipe3",
595	.pm = &ti_pipe3_pm_ops,
596	.of_match_table = ti_pipe3_id_table,	506	.of_match_table = ti_pipe3_id_table,
597	},	507	},
598	};	508	};

drivers/pinctrl/bcm/pinctrl-bcm2835.c+2−0

@@ -473,6 +473,8 @@ static void bcm2835_gpio_irq_disable(struct irq_data *data) · 472 unmodified lines
473		473
474	spin_lock_irqsave(&pc->irq_lock[bank], flags);	474	spin_lock_irqsave(&pc->irq_lock[bank], flags);
475	bcm2835_gpio_irq_config(pc, gpio, false);	475	bcm2835_gpio_irq_config(pc, gpio, false);
		476	/* Clear events that were latched prior to clearing event sources */
		477	bcm2835_gpio_set_bit(pc, GPEDS0, gpio);
476	clear_bit(offset, &pc->enabled_irq_map[bank]);	478	clear_bit(offset, &pc->enabled_irq_map[bank]);
477	spin_unlock_irqrestore(&pc->irq_lock[bank], flags);	479	spin_unlock_irqrestore(&pc->irq_lock[bank], flags);
478	}	480	}

drivers/pinctrl/freescale/pinctrl-imx1-core.c+1−2

 			     unsigned num_configs)
 {
 	struct imx1_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
-	const struct imx1_pinctrl_soc_info *info = ipctl->info;
 	int i;
 	for (i = 0; i != num_configs; ++i) {
 		imx1_write_bit(ipctl, pin_id, configs[i] & 0x01, MX1_PUEN);
 		dev_dbg(ipctl->dev, "pinconf set pullup pin %s\n",
-			info->pins[pin_id].name);
+			pin_desc_get(pctldev, pin_id)->name);
 	}
 	return 0;

drivers/pinctrl/nomadik/pinctrl-abx500.c+0−1

@@ -787,7 +787,6 @@ static const struct pinmux_ops abx500_pinmux_ops = { · 786 unmodified lines
787	.set_mux = abx500_pmx_set,	787	.set_mux = abx500_pmx_set,
788	.gpio_request_enable = abx500_gpio_request_enable,	788	.gpio_request_enable = abx500_gpio_request_enable,
789	.gpio_disable_free = abx500_gpio_disable_free,	789	.gpio_disable_free = abx500_gpio_disable_free,
790	.strict = true,
791	};	790	};
792		791
793	static int abx500_get_groups_cnt(struct pinctrl_dev *pctldev)	792	static int abx500_get_groups_cnt(struct pinctrl_dev *pctldev)

drivers/pinctrl/pinctrl-lpc18xx.c+2−2

@@ -823,7 +823,7 @@ static int lpc18xx_pconf_set_i2c0(struct pinctrl_dev *pctldev, · 822 unmodified lines
823	break;	823	break;
824		824
825	case PIN_CONFIG_INPUT_SCHMITT_ENABLE:	825	case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
826	if (param)	826	if (param_val)
827	*reg &= ~(LPC18XX_SCU_I2C0_ZIF << shift);	827	*reg &= ~(LPC18XX_SCU_I2C0_ZIF << shift);
828	else	828	else
829	*reg \|= (LPC18XX_SCU_I2C0_ZIF << shift);	829	*reg \|= (LPC18XX_SCU_I2C0_ZIF << shift);
@@ -876,7 +876,7 @@ static int lpc18xx_pconf_set_pin(struct pinctrl_dev *pctldev, · 46 unmodified lines
876	break;	876	break;
877		877
878	case PIN_CONFIG_INPUT_SCHMITT_ENABLE:	878	case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
879	if (param)	879	if (param_val)
880	*reg &= ~LPC18XX_SCU_PIN_ZIF;	880	*reg &= ~LPC18XX_SCU_PIN_ZIF;
881	else	881	else
882	*reg \|= LPC18XX_SCU_PIN_ZIF;	882	*reg \|= LPC18XX_SCU_PIN_ZIF;

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

@@ -1760,7 +1760,8 @@ static int pcs_irq_init_chained_handler(struct pcs_device *pcs, · 1759 unmodified lines
1760	int res;	1760	int res;
1761		1761
1762	res = request_irq(pcs_soc->irq, pcs_irq_handler,	1762	res = request_irq(pcs_soc->irq, pcs_irq_handler,
1763	IRQF_SHARED \| IRQF_NO_SUSPEND,	1763	IRQF_SHARED \| IRQF_NO_SUSPEND \|
		1764	IRQF_NO_THREAD,
1764	name, pcs_soc);	1765	name, pcs_soc);
1765	if (res) {	1766	if (res) {
1766	pcs_soc->irq = -1;	1767	pcs_soc->irq = -1;

drivers/pinctrl/samsung/pinctrl-samsung.c+0−5

 #include "../core.h"
 #include "pinctrl-samsung.h"
-#define GROUP_SUFFIX		"-grp"
-#define GSUFFIX_LEN		sizeof(GROUP_SUFFIX)
-#define FUNCTION_SUFFIX		"-mux"
-#define FSUFFIX_LEN		sizeof(FUNCTION_SUFFIX)
 /* list of all possible config options supported */
 static struct pin_config {
 	const char *property;

drivers/pinctrl/sh-pfc/sh_pfc.h+1−1

@@ -224,7 +224,7 @@ struct sh_pfc_soc_info { · 223 unmodified lines
224		224
225	/* PINMUX_GPIO_GP_ALL - Expand to a list of sh_pfc_pin entries */	225	/* PINMUX_GPIO_GP_ALL - Expand to a list of sh_pfc_pin entries */
226	#define _GP_GPIO(bank, _pin, _name, sfx) \	226	#define _GP_GPIO(bank, _pin, _name, sfx) \
227	[(bank * 32) + _pin] = { \	227	{ \
228	.pin = (bank * 32) + _pin, \	228	.pin = (bank * 32) + _pin, \
229	.name = __stringify(_name), \	229	.name = __stringify(_name), \
230	.enum_id = _name##_DATA, \	230	.enum_id = _name##_DATA, \

drivers/regulator/88pm800.c+1−1

@@ -130,7 +130,7 @@ struct pm800_regulators { · 129 unmodified lines
130	.owner = THIS_MODULE, \	130	.owner = THIS_MODULE, \
131	.n_voltages = ARRAY_SIZE(ldo_volt_table), \	131	.n_voltages = ARRAY_SIZE(ldo_volt_table), \
132	.vsel_reg = PM800_##vreg##_VOUT, \	132	.vsel_reg = PM800_##vreg##_VOUT, \
133	.vsel_mask = 0x1f, \	133	.vsel_mask = 0xf, \
134	.enable_reg = PM800_##ereg, \	134	.enable_reg = PM800_##ereg, \
135	.enable_mask = 1 << (ebit), \	135	.enable_mask = 1 << (ebit), \
136	.volt_table = ldo_volt_table, \	136	.volt_table = ldo_volt_table, \

drivers/regulator/core.c+15−4

 static struct regulator *create_regulator(struct regulator_dev *rdev,
 					  struct device *dev,
 					  const char *supply_name);
+static void _regulator_put(struct regulator *regulator);
 static const char *rdev_get_name(struct regulator_dev *rdev)
 {
 	rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
+	if (!try_module_get(supply_rdev->owner))
+		return -ENODEV;
 	rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
 	if (rdev->supply == NULL) {
 		err = -ENOMEM;
 	}
 	if (!r) {
-		dev_err(dev, "Failed to resolve %s-supply for %s\n",
+		if (have_full_constraints()) {
-			rdev->supply_name, rdev->desc->name);
+			r = dummy_regulator_rdev;
-		return -EPROBE_DEFER;
+		} else {
+			dev_err(dev, "Failed to resolve %s-supply for %s\n",
+				rdev->supply_name, rdev->desc->name);
+			return -EPROBE_DEFER;
+		}
 	}
 	/* Recursively resolve the supply of the supply */
 	/* Cascade always-on state to supply */
 	if (_regulator_is_enabled(rdev)) {
 		ret = regulator_enable(rdev->supply);
-		if (ret < 0)
+		if (ret < 0) {
+			if (rdev->supply)
+				_regulator_put(rdev->supply);
 			return ret;
+		}
 	}
 	return 0;

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

@@ -450,7 +450,7 @@ static struct max8973_regulator_platform_data *max8973_parse_dt( · 449 unmodified lines
450	pdata->control_flags \|= MAX8973_CONTROL_FREQ_SHIFT_9PER_ENABLE;	450	pdata->control_flags \|= MAX8973_CONTROL_FREQ_SHIFT_9PER_ENABLE;
451		451
452	if (of_property_read_bool(np, "maxim,enable-bias-control"))	452	if (of_property_read_bool(np, "maxim,enable-bias-control"))
453	pdata->control_flags \|= MAX8973_BIAS_ENABLE;	453	pdata->control_flags \|= MAX8973_CONTROL_BIAS_ENABLE;
454		454
455	return pdata;	455	return pdata;
456	}	456	}

drivers/regulator/s2mps11.c+10−4

 #include <linux/mfd/samsung/s2mps14.h>
 #include <linux/mfd/samsung/s2mpu02.h>
+/* The highest number of possible regulators for supported devices. */
+#define S2MPS_REGULATOR_MAX		S2MPS13_REGULATOR_MAX
 struct s2mps11_info {
 	unsigned int rdev_num;
 	int ramp_delay2;
 	 * One bit for each S2MPS13/S2MPS14/S2MPU02 regulator whether
 	 * the suspend mode was enabled.
 	 */
-	unsigned long long s2mps14_suspend_state:50;
+	DECLARE_BITMAP(suspend_state, S2MPS_REGULATOR_MAX);
 	/* Array of size rdev_num with GPIO-s for external sleep control */
 	int *ext_control_gpio;
 	switch (s2mps11->dev_type) {
 	case S2MPS13X:
 	case S2MPS14X:
-		if (s2mps11->s2mps14_suspend_state & (1 << rdev_get_id(rdev)))
+		if (test_bit(rdev_get_id(rdev), s2mps11->suspend_state))
 			val = S2MPS14_ENABLE_SUSPEND;
 		else if (gpio_is_valid(s2mps11->ext_control_gpio[rdev_get_id(rdev)]))
 			val = S2MPS14_ENABLE_EXT_CONTROL;
 			val = rdev->desc->enable_mask;
 		break;
 	case S2MPU02:
-		if (s2mps11->s2mps14_suspend_state & (1 << rdev_get_id(rdev)))
+		if (test_bit(rdev_get_id(rdev), s2mps11->suspend_state))
 			val = S2MPU02_ENABLE_SUSPEND;
 		else
 			val = rdev->desc->enable_mask;
 	if (ret < 0)
 		return ret;
-	s2mps11->s2mps14_suspend_state |= (1 << rdev_get_id(rdev));
+	set_bit(rdev_get_id(rdev), s2mps11->suspend_state);
 	/*
 	 * Don't enable suspend mode if regulator is already disabled because
 	 * this would effectively for a short time turn on the regulator after
 	case S2MPS11X:
 		s2mps11->rdev_num = ARRAY_SIZE(s2mps11_regulators);
 		regulators = s2mps11_regulators;
+		BUILD_BUG_ON(S2MPS_REGULATOR_MAX < s2mps11->rdev_num);
 		break;
 	case S2MPS13X:
 		s2mps11->rdev_num = ARRAY_SIZE(s2mps13_regulators);
 		regulators = s2mps13_regulators;
+		BUILD_BUG_ON(S2MPS_REGULATOR_MAX < s2mps11->rdev_num);
 		break;
 	case S2MPS14X:
 		s2mps11->rdev_num = ARRAY_SIZE(s2mps14_regulators);
 		regulators = s2mps14_regulators;
+		BUILD_BUG_ON(S2MPS_REGULATOR_MAX < s2mps11->rdev_num);
 		break;
 	case S2MPU02:
 		s2mps11->rdev_num = ARRAY_SIZE(s2mpu02_regulators);
 		regulators = s2mpu02_regulators;
+		BUILD_BUG_ON(S2MPS_REGULATOR_MAX < s2mps11->rdev_num);
 		break;
 	default:
 		dev_err(&pdev->dev, "Invalid device type: %u\n",

drivers/s390/Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	# Makefile for the S/390 specific device drivers	2	# Makefile for the S/390 specific device drivers
3	#	3	#
4		4
5	obj-y += cio/ block/ char/ crypto/ net/ scsi/ kvm/	5	obj-y += cio/ block/ char/ crypto/ net/ scsi/ virtio/
6		6
7	drivers-y += drivers/s390/built-in.o	7	drivers-y += drivers/s390/built-in.o
8		8

drivers/s390/virtio/Makefilerenamed from drivers/s390/kvm/Makefile+0−0

File renamed without changes.

drivers/s390/virtio/kvm_virtio.crenamed from drivers/s390/kvm/kvm_virtio.c+0−0

File renamed without changes.

drivers/s390/virtio/virtio_ccw.crenamed from drivers/s390/kvm/virtio_ccw.c+0−0

File renamed without changes.

drivers/scsi/virtio_scsi.c+3−1

 {
 	struct Scsi_Host *shost;
 	struct virtio_scsi *vscsi;
-	int err, host_prot;
+	int err;
 	u32 sg_elems, num_targets;
 	u32 cmd_per_lun;
 	u32 num_queues;
 #ifdef CONFIG_BLK_DEV_INTEGRITY
 	if (virtio_has_feature(vdev, VIRTIO_SCSI_F_T10_PI)) {
+		int host_prot;
 		host_prot = SHOST_DIF_TYPE1_PROTECTION | SHOST_DIF_TYPE2_PROTECTION |
 			    SHOST_DIF_TYPE3_PROTECTION | SHOST_DIX_TYPE1_PROTECTION |
 			    SHOST_DIX_TYPE2_PROTECTION | SHOST_DIX_TYPE3_PROTECTION;

drivers/spi/Kconfig+1−1

@@ -612,7 +612,7 @@ config SPI_XTENSA_XTFPGA · 611 unmodified lines
612		612
613	config SPI_ZYNQMP_GQSPI	613	config SPI_ZYNQMP_GQSPI
614	tristate "Xilinx ZynqMP GQSPI controller"	614	tristate "Xilinx ZynqMP GQSPI controller"
615	depends on SPI_MASTER	615	depends on SPI_MASTER && HAS_DMA
616	help	616	help
617	Enables Xilinx GQSPI controller driver for Zynq UltraScale+ MPSoC.	617	Enables Xilinx GQSPI controller driver for Zynq UltraScale+ MPSoC.
618		618

drivers/spi/spi-img-spfi.c+2−0

 #define SPFI_CONTROL_SOFT_RESET			BIT(11)
 #define SPFI_CONTROL_SEND_DMA			BIT(10)
 #define SPFI_CONTROL_GET_DMA			BIT(9)
+#define SPFI_CONTROL_SE			BIT(8)
 #define SPFI_CONTROL_TMODE_SHIFT		5
 #define SPFI_CONTROL_TMODE_MASK			0x7
 #define SPFI_CONTROL_TMODE_SINGLE		0
 	else if (xfer->tx_nbits == SPI_NBITS_QUAD &&
 		 xfer->rx_nbits == SPI_NBITS_QUAD)
 		val |= SPFI_CONTROL_TMODE_QUAD << SPFI_CONTROL_TMODE_SHIFT;
+	val |= SPFI_CONTROL_SE;
 	spfi_writel(spfi, val, SPFI_CONTROL);
 }

drivers/spi/spi-imx.c+3−2

 {
 	struct spi_imx_data *spi_imx = spi_master_get_devdata(master);
-	if (spi_imx->dma_is_inited && (transfer->len > spi_imx->rx_wml)
+	if (spi_imx->dma_is_inited
-	    && (transfer->len > spi_imx->tx_wml))
+	    && transfer->len > spi_imx->rx_wml * sizeof(u32)
+	    && transfer->len > spi_imx->tx_wml * sizeof(u32))
 		return true;
 	return false;
 }

drivers/spi/spi-zynqmp-gqspi.c+1−0

@@ -214,6 +214,7 @@ static void zynqmp_gqspi_selectslave(struct zynqmp_qspi *instanceptr, · 213 unmodified lines
214	case GQSPI_SELECT_FLASH_CS_BOTH:	214	case GQSPI_SELECT_FLASH_CS_BOTH:
215	instanceptr->genfifocs = GQSPI_GENFIFO_CS_LOWER \|	215	instanceptr->genfifocs = GQSPI_GENFIFO_CS_LOWER \|
216	GQSPI_GENFIFO_CS_UPPER;	216	GQSPI_GENFIFO_CS_UPPER;
		217	break;
217	case GQSPI_SELECT_FLASH_CS_UPPER:	218	case GQSPI_SELECT_FLASH_CS_UPPER:
218	instanceptr->genfifocs = GQSPI_GENFIFO_CS_UPPER;	219	instanceptr->genfifocs = GQSPI_GENFIFO_CS_UPPER;
219	break;	220	break;

drivers/spi/spidev.c+1−0

@@ -693,6 +693,7 @@ static struct class *spidev_class; · 692 unmodified lines
693	#ifdef CONFIG_OF	693	#ifdef CONFIG_OF
694	static const struct of_device_id spidev_dt_ids[] = {	694	static const struct of_device_id spidev_dt_ids[] = {
695	{ .compatible = "rohm,dh2228fv" },	695	{ .compatible = "rohm,dh2228fv" },
		696	{ .compatible = "lineartechnology,ltc2488" },
696	{},	697	{},
697	};	698	};
698	MODULE_DEVICE_TABLE(of, spidev_dt_ids);	699	MODULE_DEVICE_TABLE(of, spidev_dt_ids);

drivers/tty/n_tty.c+13−3

  *	Locking: ctrl_lock
  */
-static void isig(int sig, struct tty_struct *tty)
+static void __isig(int sig, struct tty_struct *tty)
 {
-	struct n_tty_data *ldata = tty->disc_data;
 	struct pid *tty_pgrp = tty_get_pgrp(tty);
 	if (tty_pgrp) {
 		kill_pgrp(tty_pgrp, sig, 1);
 		put_pid(tty_pgrp);
 	}
+}
-	if (!L_NOFLSH(tty)) {
+static void isig(int sig, struct tty_struct *tty)
+{
+	struct n_tty_data *ldata = tty->disc_data;
+	if (L_NOFLSH(tty)) {
+		/* signal only */
+		__isig(sig, tty);
+	} else { /* signal and flush */
 		up_read(&tty->termios_rwsem);
 		down_write(&tty->termios_rwsem);
+		__isig(sig, tty);
 		/* clear echo buffer */
 		mutex_lock(&ldata->output_lock);
 		ldata->echo_head = ldata->echo_tail = 0;

drivers/tty/serial/Kconfig+1−1

@@ -1185,7 +1185,7 @@ config SERIAL_SC16IS7XX_CORE · 1184 unmodified lines
1185	config SERIAL_SC16IS7XX	1185	config SERIAL_SC16IS7XX
1186	tristate "SC16IS7xx serial support"	1186	tristate "SC16IS7xx serial support"
1187	select SERIAL_CORE	1187	select SERIAL_CORE
1188	depends on I2C \|\| SPI_MASTER	1188	depends on (SPI_MASTER && !I2C) \|\| I2C
1189	help	1189	help
1190	This selects support for SC16IS7xx serial ports.	1190	This selects support for SC16IS7xx serial ports.
1191	Supported ICs are SC16IS740, SC16IS741, SC16IS750, SC16IS752,	1191	Supported ICs are SC16IS740, SC16IS741, SC16IS750, SC16IS752,

drivers/tty/serial/amba-pl011.c+2−2

@@ -2310,8 +2310,8 @@ static int pl011_setup_port(struct device dev, struct uart_amba_port uap, · 2309 unmodified lines
2310	void __iomem *base;	2310	void __iomem *base;
2311		2311
2312	base = devm_ioremap_resource(dev, mmiobase);	2312	base = devm_ioremap_resource(dev, mmiobase);
2313	if (!base)	2313	if (IS_ERR(base))
2314	return -ENOMEM;	2314	return PTR_ERR(base);
2315		2315
2316	index = pl011_probe_dt_alias(index, dev);	2316	index = pl011_probe_dt_alias(index, dev);
2317		2317

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

@@ -943,7 +943,7 @@ static int etraxfs_uart_remove(struct platform_device *pdev) · 942 unmodified lines
943		943
944	port = platform_get_drvdata(pdev);	944	port = platform_get_drvdata(pdev);
945	uart_remove_one_port(&etraxfs_uart_driver, port);	945	uart_remove_one_port(&etraxfs_uart_driver, port);
946	etraxfs_uart_ports[pdev->id] = NULL;	946	etraxfs_uart_ports[port->line] = NULL;
947		947
948	return 0;	948	return 0;
949	}	949	}

drivers/tty/serial/imx.c+7−8

 	writel(temp & ~UCR4_DREN, sport->port.membase + UCR4);
-	/* Can we enable the DMA support? */
-	if (is_imx6q_uart(sport) && !uart_console(port) &&
-	    !sport->dma_is_inited)
-		imx_uart_dma_init(sport);
 	spin_lock_irqsave(&sport->port.lock, flags);
 	/* Reset fifo's and state machines */
 	imx_reset(sport);
 	writel(USR1_RTSD, sport->port.membase + USR1);
 	writel(USR2_ORE, sport->port.membase + USR2);
-	if (sport->dma_is_inited && !sport->dma_is_enabled)
-		imx_enable_dma(sport);
 	temp = readl(sport->port.membase + UCR1);
 	temp |= UCR1_RRDYEN | UCR1_RTSDEN | UCR1_UARTEN;
 			} else {
 				ucr2 |= UCR2_CTSC;
 			}
+			/* Can we enable the DMA support? */
+			if (is_imx6q_uart(sport) && !uart_console(port)
+				&& !sport->dma_is_inited)
+				imx_uart_dma_init(sport);
 		} else {
 			termios->c_cflag &= ~CRTSCTS;
 		}
 	if (UART_ENABLE_MS(&sport->port, termios->c_cflag))
 		imx_enable_ms(&sport->port);
+	if (sport->dma_is_inited && !sport->dma_is_enabled)
+		imx_enable_dma(sport);
 	spin_unlock_irqrestore(&sport->port.lock, flags);
 }

drivers/tty/serial/sc16is7xx.c+23−7

@@ -354,6 +354,26 @@ static void sc16is7xx_port_write(struct uart_port *port, u8 reg, u8 val) · 353 unmodified lines
354	(reg << SC16IS7XX_REG_SHIFT) \| port->line, val);	354	(reg << SC16IS7XX_REG_SHIFT) \| port->line, val);
355	}	355	}
356		356
		357	static void sc16is7xx_fifo_read(struct uart_port *port, unsigned int rxlen)
		358	{
		359	struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
		360	u8 addr = (SC16IS7XX_RHR_REG << SC16IS7XX_REG_SHIFT) \| port->line;
		361
		362	regcache_cache_bypass(s->regmap, true);
		363	regmap_raw_read(s->regmap, addr, s->buf, rxlen);
		364	regcache_cache_bypass(s->regmap, false);
		365	}
		366
		367	static void sc16is7xx_fifo_write(struct uart_port *port, u8 to_send)
		368	{
		369	struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
		370	u8 addr = (SC16IS7XX_THR_REG << SC16IS7XX_REG_SHIFT) \| port->line;
		371
		372	regcache_cache_bypass(s->regmap, true);
		373	regmap_raw_write(s->regmap, addr, s->buf, to_send);
		374	regcache_cache_bypass(s->regmap, false);
		375	}
		376
357	static void sc16is7xx_port_update(struct uart_port *port, u8 reg,	377	static void sc16is7xx_port_update(struct uart_port *port, u8 reg,
358	u8 mask, u8 val)	378	u8 mask, u8 val)
359	{	379	{
@@ -508,10 +528,7 @@ static void sc16is7xx_handle_rx(struct uart_port *port, unsigned int rxlen, · 148 unmodified lines
508	s->buf[0] = sc16is7xx_port_read(port, SC16IS7XX_RHR_REG);	528	s->buf[0] = sc16is7xx_port_read(port, SC16IS7XX_RHR_REG);
509	bytes_read = 1;	529	bytes_read = 1;
510	} else {	530	} else {
511	regcache_cache_bypass(s->regmap, true);	531	sc16is7xx_fifo_read(port, rxlen);
512	regmap_raw_read(s->regmap, SC16IS7XX_RHR_REG,
513	s->buf, rxlen);
514	regcache_cache_bypass(s->regmap, false);
515	bytes_read = rxlen;	532	bytes_read = rxlen;
516	}	533	}
517		534
@@ -591,9 +608,8 @@ static void sc16is7xx_handle_tx(struct uart_port *port) · 73 unmodified lines
591	s->buf[i] = xmit->buf[xmit->tail];	608	s->buf[i] = xmit->buf[xmit->tail];
592	xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);	609	xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
593	}	610	}
594	regcache_cache_bypass(s->regmap, true);	611
595	regmap_raw_write(s->regmap, SC16IS7XX_THR_REG, s->buf, to_send);	612	sc16is7xx_fifo_write(port, to_send);
596	regcache_cache_bypass(s->regmap, false);
597	}	613	}
598		614
599	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)	615	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)

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

@@ -1418,7 +1418,7 @@ static void uart_close(struct tty_struct tty, struct file filp) · 1417 unmodified lines
1418	mutex_lock(&port->mutex);	1418	mutex_lock(&port->mutex);
1419	uart_shutdown(tty, state);	1419	uart_shutdown(tty, state);
1420	tty_port_tty_set(port, NULL);	1420	tty_port_tty_set(port, NULL);
1421	tty->closing = 0;	1421
1422	spin_lock_irqsave(&port->lock, flags);	1422	spin_lock_irqsave(&port->lock, flags);
1423		1423
1424	if (port->blocked_open) {	1424	if (port->blocked_open) {
@@ -1444,6 +1444,7 @@ static void uart_close(struct tty_struct tty, struct file filp) · 19 unmodified lines
1444	mutex_unlock(&port->mutex);	1444	mutex_unlock(&port->mutex);
1445		1445
1446	tty_ldisc_flush(tty);	1446	tty_ldisc_flush(tty);
		1447	tty->closing = 0;
1447	}	1448	}
1448		1449
1449	static void uart_wait_until_sent(struct tty_struct *tty, int timeout)	1450	static void uart_wait_until_sent(struct tty_struct *tty, int timeout)

drivers/tty/vt/selection.c+1−0

@@ -356,6 +356,7 @@ int paste_selection(struct tty_struct *tty) · 355 unmodified lines
356	schedule();	356	schedule();
357	continue;	357	continue;
358	}	358	}
		359	__set_current_state(TASK_RUNNING);
359	count = sel_buffer_lth - pasted;	360	count = sel_buffer_lth - pasted;
360	count = tty_ldisc_receive_buf(ld, sel_buffer + pasted, NULL,	361	count = tty_ldisc_receive_buf(ld, sel_buffer + pasted, NULL,
361	count);	362	count);

drivers/tty/vt/vt.c+2−0

 	__module_get(vc->vc_sw->owner);
 	vc->vc_num = num;
 	vc->vc_display_fg = &master_display_fg;
+	if (vc->vc_uni_pagedir_loc)
+		con_free_unimap(vc);
 	vc->vc_uni_pagedir_loc = &vc->vc_uni_pagedir;
 	vc->vc_uni_pagedir = NULL;
 	vc->vc_hi_font_mask = 0;

drivers/usb/class/cdc-acm.c+1−0

@@ -1944,6 +1944,7 @@ static void __exit acm_exit(void) · 1943 unmodified lines
1944	usb_deregister(&acm_driver);	1944	usb_deregister(&acm_driver);
1945	tty_unregister_driver(acm_tty_driver);	1945	tty_unregister_driver(acm_tty_driver);
1946	put_tty_driver(acm_tty_driver);	1946	put_tty_driver(acm_tty_driver);
		1947	idr_destroy(&acm_minors);
1947	}	1948	}
1948		1949
1949	module_init(acm_init);	1950	module_init(acm_init);

drivers/usb/common/ulpi.c+1−1

@@ -242,7 +242,7 @@ static int __init ulpi_init(void) · 241 unmodified lines
242	{	242	{
243	return bus_register(&ulpi_bus);	243	return bus_register(&ulpi_bus);
244	}	244	}
245	module_init(ulpi_init);	245	subsys_initcall(ulpi_init);
246		246
247	static void __exit ulpi_exit(void)	247	static void __exit ulpi_exit(void)
248	{	248	{

drivers/usb/core/hcd.c+5−2

@@ -1022,9 +1022,12 @@ static int register_root_hub(struct usb_hcd *hcd) · 1021 unmodified lines
1022	dev_name(&usb_dev->dev), retval);	1022	dev_name(&usb_dev->dev), retval);
1023	return (retval < 0) ? retval : -EMSGSIZE;	1023	return (retval < 0) ? retval : -EMSGSIZE;
1024	}	1024	}
1025	if (usb_dev->speed == USB_SPEED_SUPER) {	1025
		1026	if (le16_to_cpu(usb_dev->descriptor.bcdUSB) >= 0x0201) {
1026	retval = usb_get_bos_descriptor(usb_dev);	1027	retval = usb_get_bos_descriptor(usb_dev);
1027	if (retval < 0) {	1028	if (!retval) {
		1029	usb_dev->lpm_capable = usb_device_supports_lpm(usb_dev);
		1030	} else if (usb_dev->speed == USB_SPEED_SUPER) {
1028	mutex_unlock(&usb_bus_list_lock);	1031	mutex_unlock(&usb_bus_list_lock);
1029	dev_dbg(parent_dev, "can't read %s bos descriptor %d\n",	1032	dev_dbg(parent_dev, "can't read %s bos descriptor %d\n",
1030	dev_name(&usb_dev->dev), retval);	1033	dev_name(&usb_dev->dev), retval);

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

@@ -122,7 +122,7 @@ struct usb_hub usb_hub_to_struct_hub(struct usb_device hdev) · 121 unmodified lines
122	return usb_get_intfdata(hdev->actconfig->interface[0]);	122	return usb_get_intfdata(hdev->actconfig->interface[0]);
123	}	123	}
124		124
125	static int usb_device_supports_lpm(struct usb_device *udev)	125	int usb_device_supports_lpm(struct usb_device *udev)
126	{	126	{
127	/* USB 2.1 (and greater) devices indicate LPM support through	127	/* USB 2.1 (and greater) devices indicate LPM support through
128	* their USB 2.0 Extended Capabilities BOS descriptor.	128	* their USB 2.0 Extended Capabilities BOS descriptor.

drivers/usb/core/usb.h+1−0

@@ -65,6 +65,7 @@ extern int usb_hub_init(void); · 64 unmodified lines
65	extern void usb_hub_cleanup(void);	65	extern void usb_hub_cleanup(void);
66	extern int usb_major_init(void);	66	extern int usb_major_init(void);
67	extern void usb_major_cleanup(void);	67	extern void usb_major_cleanup(void);
		68	extern int usb_device_supports_lpm(struct usb_device *udev);
68		69
69	#ifdef CONFIG_PM	70	#ifdef CONFIG_PM
70		71

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

 		dwc3_trace(trace_dwc3_ep0, "USB_REQ_SET_ISOCH_DELAY");
 		ret = dwc3_ep0_set_isoch_delay(dwc, ctrl);
 		break;
+	case USB_REQ_SET_INTERFACE:
+		dwc3_trace(trace_dwc3_ep0, "USB_REQ_SET_INTERFACE");
+		dwc->start_config_issued = false;
+		/* Fall through */
 	default:
 		dwc3_trace(trace_dwc3_ep0, "Forwarding to gadget driver");
 		ret = dwc3_ep0_delegate_req(dwc, ctrl);

drivers/usb/gadget/udc/mv_udc_core.c+1−1

@@ -2167,7 +2167,7 @@ static int mv_udc_probe(struct platform_device *pdev) · 2166 unmodified lines
2167	return -ENODEV;	2167	return -ENODEV;
2168	}	2168	}
2169		2169
2170	udc->phy_regs = ioremap(r->start, resource_size(r));	2170	udc->phy_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r));
2171	if (udc->phy_regs == NULL) {	2171	if (udc->phy_regs == NULL) {
2172	dev_err(&pdev->dev, "failed to map phy I/O memory\n");	2172	dev_err(&pdev->dev, "failed to map phy I/O memory\n");
2173	return -EBUSY;	2173	return -EBUSY;

drivers/usb/gadget/udc/udc-core.c+8−6

 int usb_gadget_map_request(struct usb_gadget *gadget,
 		struct usb_request *req, int is_in)
 {
+	struct device *dev = gadget->dev.parent;
 	if (req->length == 0)
 		return 0;
 	if (req->num_sgs) {
 		int     mapped;
-		mapped = dma_map_sg(&gadget->dev, req->sg, req->num_sgs,
+		mapped = dma_map_sg(dev, req->sg, req->num_sgs,
 				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
 		if (mapped == 0) {
 			dev_err(&gadget->dev, "failed to map SGs\n");
 		req->num_mapped_sgs = mapped;
 	} else {
-		req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
+		req->dma = dma_map_single(dev, req->buf, req->length,
 				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-		if (dma_mapping_error(&gadget->dev, req->dma)) {
+		if (dma_mapping_error(dev, req->dma)) {
-			dev_err(&gadget->dev, "failed to map buffer\n");
+			dev_err(dev, "failed to map buffer\n");
 			return -EFAULT;
 		}
 	}
 		return;
 	if (req->num_mapped_sgs) {
-		dma_unmap_sg(&gadget->dev, req->sg, req->num_mapped_sgs,
+		dma_unmap_sg(gadget->dev.parent, req->sg, req->num_mapped_sgs,
 				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
 		req->num_mapped_sgs = 0;
 	} else {
-		dma_unmap_single(&gadget->dev, req->dma, req->length,
+		dma_unmap_single(gadget->dev.parent, req->dma, req->length,
 				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
 	}
 }

drivers/usb/host/ohci-q.c+1−6

 		int			completed, modified;
 		__hc32			*prev;
-		/* Is this ED already invisible to the hardware? */
-		if (ed->state == ED_IDLE)
-			goto ed_idle;
 		/* only take off EDs that the HC isn't using, accounting for
 		 * frame counter wraps and EDs with partially retired TDs
 		 */
 		}
 		/* ED's now officially unlinked, hc doesn't see */
-		ed->state = ED_IDLE;
 		ed->hwHeadP &= ~cpu_to_hc32(ohci, ED_H);
 		ed->hwNextED = 0;
 		wmb();
 		ed->hwINFO &= ~cpu_to_hc32(ohci, ED_SKIP | ED_DEQUEUE);
-ed_idle:
 		/* reentrancy:  if we drop the schedule lock, someone might
 		 * have modified this list.  normally it's just prepending
 		if (list_empty(&ed->td_list)) {
 			*last = ed->ed_next;
 			ed->ed_next = NULL;
+			ed->state = ED_IDLE;
 			list_del(&ed->in_use_list);
 		} else if (ohci->rh_state == OHCI_RH_RUNNING) {
 			*last = ed->ed_next;

drivers/usb/host/ohci-tmio.c+1−1

@@ -58,7 +58,7 @@ · 57 unmodified lines
58	#define CCR_PM_CKRNEN 0x0002	58	#define CCR_PM_CKRNEN 0x0002
59	#define CCR_PM_USBPW1 0x0004	59	#define CCR_PM_USBPW1 0x0004
60	#define CCR_PM_USBPW2 0x0008	60	#define CCR_PM_USBPW2 0x0008
61	#define CCR_PM_USBPW3 0x0008	61	#define CCR_PM_USBPW3 0x0010
62	#define CCR_PM_PMEE 0x0100	62	#define CCR_PM_PMEE 0x0100
63	#define CCR_PM_PMES 0x8000	63	#define CCR_PM_PMES 0x8000
64		64

drivers/usb/host/xhci-hub.c+16−6

 	u32 pls = status_reg & PORT_PLS_MASK;
 	/* resume state is a xHCI internal state.
-	 * Do not report it to usb core.
+	 * Do not report it to usb core, instead, pretend to be U3,
+	 * thus usb core knows it's not ready for transfer
 	 */
-	if (pls == XDEV_RESUME)
+	if (pls == XDEV_RESUME) {
+		*status |= USB_SS_PORT_LS_U3;
 		return;
+	}
 	/* When the CAS bit is set then warm reset
 	 * should be performed on port
 		status |= USB_PORT_STAT_C_RESET << 16;
 	/* USB3.0 only */
 	if (hcd->speed == HCD_USB3) {
-		if ((raw_port_status & PORT_PLC))
+		/* Port link change with port in resume state should not be
+		 * reported to usbcore, as this is an internal state to be
+		 * handled by xhci driver. Reporting PLC to usbcore may
+		 * cause usbcore clearing PLC first and port change event
+		 * irq won't be generated.
+		 */
+		if ((raw_port_status & PORT_PLC) &&
+			(raw_port_status & PORT_PLS_MASK) != XDEV_RESUME)
 			status |= USB_PORT_STAT_C_LINK_STATE << 16;
 		if ((raw_port_status & PORT_WRC))
 			status |= USB_PORT_STAT_C_BH_RESET << 16;
 	spin_lock_irqsave(&xhci->lock, flags);
 	if (hcd->self.root_hub->do_remote_wakeup) {
-		if (bus_state->resuming_ports) {
+		if (bus_state->resuming_ports ||	/* USB2 */
+		    bus_state->port_remote_wakeup) {	/* USB3 */
 			spin_unlock_irqrestore(&xhci->lock, flags);
-			xhci_dbg(xhci, "suspend failed because "
+			xhci_dbg(xhci, "suspend failed because a port is resuming\n");
-						"a port is resuming\n");
 			return -EBUSY;
 		}
 	}

drivers/usb/host/xhci-mem.c+1−1

 		/* Attempt to use the ring cache */
 		if (virt_dev->num_rings_cached == 0)
 			return -ENOMEM;
+		virt_dev->num_rings_cached--;
 		virt_dev->eps[ep_index].new_ring =
 			virt_dev->ring_cache[virt_dev->num_rings_cached];
 		virt_dev->ring_cache[virt_dev->num_rings_cached] = NULL;
-		virt_dev->num_rings_cached--;
 		xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring,
 					1, type);
 	}

drivers/usb/host/xhci-pci.c+54−3

@@ -23,10 +23,15 @@ · 22 unmodified lines
23	#include <linux/pci.h>	23	#include <linux/pci.h>
24	#include <linux/slab.h>	24	#include <linux/slab.h>
25	#include <linux/module.h>	25	#include <linux/module.h>
		26	#include <linux/acpi.h>
26		27
27	#include "xhci.h"	28	#include "xhci.h"
28	#include "xhci-trace.h"	29	#include "xhci-trace.h"
29		30
		31	#define PORT2_SSIC_CONFIG_REG2 0x883c
		32	#define PROG_DONE (1 << 30)
		33	#define SSIC_PORT_UNUSED (1 << 31)
		34
30	/* Device for a quirk */	35	/* Device for a quirk */
31	#define PCI_VENDOR_ID_FRESCO_LOGIC 0x1b73	36	#define PCI_VENDOR_ID_FRESCO_LOGIC 0x1b73
32	#define PCI_DEVICE_ID_FRESCO_LOGIC_PDK 0x1000	37	#define PCI_DEVICE_ID_FRESCO_LOGIC_PDK 0x1000
@@ -176,20 +181,63 @@ static void xhci_pci_quirks(struct device dev, struct xhci_hcd xhci) · 143 unmodified lines
176	}	181	}
177		182
178	/*	183	/*
		184	* In some Intel xHCI controllers, in order to get D3 working,
		185	* through a vendor specific SSIC CONFIG register at offset 0x883c,
		186	* SSIC PORT need to be marked as "unused" before putting xHCI
		187	* into D3. After D3 exit, the SSIC port need to be marked as "used".
		188	* Without this change, xHCI might not enter D3 state.
179	* Make sure PME works on some Intel xHCI controllers by writing 1 to clear	189	* Make sure PME works on some Intel xHCI controllers by writing 1 to clear
180	* the Internal PME flag bit in vendor specific PMCTRL register at offset 0x80a4	190	* the Internal PME flag bit in vendor specific PMCTRL register at offset 0x80a4
181	*/	191	*/
182	static void xhci_pme_quirk(struct xhci_hcd *xhci)	192	static void xhci_pme_quirk(struct usb_hcd *hcd, bool suspend)
183	{	193	{
		194	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
		195	struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
184	u32 val;	196	u32 val;
185	void __iomem *reg;	197	void __iomem *reg;
186		198
		199	if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
		200	pdev->device == PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI) {
		201
		202	reg = (void __iomem *) xhci->cap_regs + PORT2_SSIC_CONFIG_REG2;
		203
		204	/* Notify SSIC that SSIC profile programming is not done */
		205	val = readl(reg) & ~PROG_DONE;
		206	writel(val, reg);
		207
		208	/* Mark SSIC port as unused(suspend) or used(resume) */
		209	val = readl(reg);
		210	if (suspend)
		211	val \|= SSIC_PORT_UNUSED;
		212	else
		213	val &= ~SSIC_PORT_UNUSED;
		214	writel(val, reg);
		215
		216	/* Notify SSIC that SSIC profile programming is done */
		217	val = readl(reg) \| PROG_DONE;
		218	writel(val, reg);
		219	readl(reg);
		220	}
		221
187	reg = (void __iomem *) xhci->cap_regs + 0x80a4;	222	reg = (void __iomem *) xhci->cap_regs + 0x80a4;
188	val = readl(reg);	223	val = readl(reg);
189	writel(val \| BIT(28), reg);	224	writel(val \| BIT(28), reg);
190	readl(reg);	225	readl(reg);
191	}	226	}
192		227
		228	#ifdef CONFIG_ACPI
		229	static void xhci_pme_acpi_rtd3_enable(struct pci_dev *dev)
		230	{
		231	static const u8 intel_dsm_uuid[] = {
		232	0xb7, 0x0c, 0x34, 0xac, 0x01, 0xe9, 0xbf, 0x45,
		233	0xb7, 0xe6, 0x2b, 0x34, 0xec, 0x93, 0x1e, 0x23,
		234	};
		235	acpi_evaluate_dsm(ACPI_HANDLE(&dev->dev), intel_dsm_uuid, 3, 1, NULL);
		236	}
		237	#else
		238	static void xhci_pme_acpi_rtd3_enable(struct pci_dev *dev) { }
		239	#endif /* CONFIG_ACPI */
		240
193	/* called during probe() after chip reset completes */	241	/* called during probe() after chip reset completes */
194	static int xhci_pci_setup(struct usb_hcd *hcd)	242	static int xhci_pci_setup(struct usb_hcd *hcd)
195	{	243	{
@@ -263,6 +311,9 @@ static int xhci_pci_probe(struct pci_dev dev, const struct pci_device_id id) · 67 unmodified lines
263	HCC_MAX_PSA(xhci->hcc_params) >= 4)	311	HCC_MAX_PSA(xhci->hcc_params) >= 4)
264	xhci->shared_hcd->can_do_streams = 1;	312	xhci->shared_hcd->can_do_streams = 1;
265		313
		314	if (xhci->quirks & XHCI_PME_STUCK_QUIRK)
		315	xhci_pme_acpi_rtd3_enable(dev);
		316
266	/* USB-2 and USB-3 roothubs initialized, allow runtime pm suspend */	317	/* USB-2 and USB-3 roothubs initialized, allow runtime pm suspend */
267	pm_runtime_put_noidle(&dev->dev);	318	pm_runtime_put_noidle(&dev->dev);
268		319
@@ -307,7 +358,7 @@ static int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup) · 38 unmodified lines
307	pdev->no_d3cold = true;	358	pdev->no_d3cold = true;
308		359
309	if (xhci->quirks & XHCI_PME_STUCK_QUIRK)	360	if (xhci->quirks & XHCI_PME_STUCK_QUIRK)
310	xhci_pme_quirk(xhci);	361	xhci_pme_quirk(hcd, true);
311		362
312	return xhci_suspend(xhci, do_wakeup);	363	return xhci_suspend(xhci, do_wakeup);
313	}	364	}
@@ -340,7 +391,7 @@ static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated) · 26 unmodified lines
340	usb_enable_intel_xhci_ports(pdev);	391	usb_enable_intel_xhci_ports(pdev);
341		392
342	if (xhci->quirks & XHCI_PME_STUCK_QUIRK)	393	if (xhci->quirks & XHCI_PME_STUCK_QUIRK)
343	xhci_pme_quirk(xhci);	394	xhci_pme_quirk(hcd, false);
344		395
345	retval = xhci_resume(xhci, hibernated);	396	retval = xhci_resume(xhci, hibernated);
346	return retval;	397	return retval;

drivers/usb/host/xhci-ring.c+3−0

@@ -1546,6 +1546,9 @@ static void handle_port_status(struct xhci_hcd *xhci, · 1545 unmodified lines
1546	usb_hcd_resume_root_hub(hcd);	1546	usb_hcd_resume_root_hub(hcd);
1547	}	1547	}
1548		1548
		1549	if (hcd->speed == HCD_USB3 && (temp & PORT_PLS_MASK) == XDEV_INACTIVE)
		1550	bus_state->port_remote_wakeup &= ~(1 << faked_port_index);
		1551
1549	if ((temp & PORT_PLC) && (temp & PORT_PLS_MASK) == XDEV_RESUME) {	1552	if ((temp & PORT_PLC) && (temp & PORT_PLS_MASK) == XDEV_RESUME) {
1550	xhci_dbg(xhci, "port resume event for port %d\n", port_id);	1553	xhci_dbg(xhci, "port resume event for port %d\n", port_id);
1551		1554

drivers/usb/host/xhci.c+3−0

@@ -3453,6 +3453,9 @@ int xhci_discover_or_reset_device(struct usb_hcd hcd, struct usb_device udev) · 3452 unmodified lines
3453	return -EINVAL;	3453	return -EINVAL;
3454	}	3454	}
3455		3455
		3456	if (virt_dev->tt_info)
		3457	old_active_eps = virt_dev->tt_info->active_eps;
		3458
3456	if (virt_dev->udev != udev) {	3459	if (virt_dev->udev != udev) {
3457	/* If the virt_dev and the udev does not match, this virt_dev	3460	/* If the virt_dev and the udev does not match, this virt_dev
3458	* may belong to another udev.	3461	* may belong to another udev.

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

@@ -285,6 +285,7 @@ struct xhci_op_regs { · 284 unmodified lines
285	#define XDEV_U0 (0x0 << 5)	285	#define XDEV_U0 (0x0 << 5)
286	#define XDEV_U2 (0x2 << 5)	286	#define XDEV_U2 (0x2 << 5)
287	#define XDEV_U3 (0x3 << 5)	287	#define XDEV_U3 (0x3 << 5)
		288	#define XDEV_INACTIVE (0x6 << 5)
288	#define XDEV_RESUME (0xf << 5)	289	#define XDEV_RESUME (0xf << 5)
289	/* true: port has power (see HCC_PPC) */	290	/* true: port has power (see HCC_PPC) */
290	#define PORT_POWER (1 << 9)	291	#define PORT_POWER (1 << 9)

drivers/usb/storage/unusual_devs.h+23−0

@@ -2065,6 +2065,18 @@ UNUSUAL_DEV( 0x1908, 0x3335, 0x0200, 0x0200, · 2064 unmodified lines
2065	USB_SC_DEVICE, USB_PR_DEVICE, NULL,	2065	USB_SC_DEVICE, USB_PR_DEVICE, NULL,
2066	US_FL_NO_READ_DISC_INFO ),	2066	US_FL_NO_READ_DISC_INFO ),
2067		2067
		2068	/* Reported by Oliver Neukum <oneukum@suse.com>
		2069	* This device morphes spontaneously into another device if the access
		2070	* pattern of Windows isn't followed. Thus writable media would be dirty
		2071	* if the initial instance is used. So the device is limited to its
		2072	* virtual CD.
		2073	* And yes, the concept that BCD goes up to 9 is not heeded */
		2074	UNUSUAL_DEV( 0x19d2, 0x1225, 0x0000, 0xffff,
		2075	"ZTE,Incorporated",
		2076	"ZTE WCDMA Technologies MSM",
		2077	USB_SC_DEVICE, USB_PR_DEVICE, NULL,
		2078	US_FL_SINGLE_LUN ),
		2079
2068	/* Reported by Sven Geggus <sven-usbst@geggus.net>	2080	/* Reported by Sven Geggus <sven-usbst@geggus.net>
2069	* This encrypted pen drive returns bogus data for the initial READ(10).	2081	* This encrypted pen drive returns bogus data for the initial READ(10).
2070	*/	2082	*/
@@ -2074,6 +2086,17 @@ UNUSUAL_DEV( 0x1b1c, 0x1ab5, 0x0200, 0x0200, · 3 unmodified lines
2074	USB_SC_DEVICE, USB_PR_DEVICE, NULL,	2086	USB_SC_DEVICE, USB_PR_DEVICE, NULL,
2075	US_FL_INITIAL_READ10 ),	2087	US_FL_INITIAL_READ10 ),
2076		2088
		2089	/* Reported by Hans de Goede <hdegoede@redhat.com>
		2090	* These are mini projectors using USB for both power and video data transport
		2091	* The usb-storage interface is a virtual windows driver CD, which the gm12u320
		2092	* driver automatically converts into framebuffer & kms dri device nodes.
		2093	*/
		2094	UNUSUAL_DEV( 0x1de1, 0xc102, 0x0000, 0xffff,
		2095	"Grain-media Technology Corp.",
		2096	"USB3.0 Device GM12U320",
		2097	USB_SC_DEVICE, USB_PR_DEVICE, NULL,
		2098	US_FL_IGNORE_DEVICE ),
		2099
2077	/* Patch by Richard Schütz <r.schtz@t-online.de>	2100	/* Patch by Richard Schütz <r.schtz@t-online.de>
2078	* This external hard drive enclosure uses a JMicron chip which	2101	* This external hard drive enclosure uses a JMicron chip which
2079	* needs the US_FL_IGNORE_RESIDUE flag to work properly. */	2102	* needs the US_FL_IGNORE_RESIDUE flag to work properly. */

drivers/vhost/vhost.c+51−16

 #include <linux/file.h>
 #include <linux/highmem.h>
 #include <linux/slab.h>
+#include <linux/vmalloc.h>
 #include <linux/kthread.h>
 #include <linux/cgroup.h>
 #include <linux/module.h>
+#include <linux/sort.h>
 #include "vhost.h"
+static ushort max_mem_regions = 64;
+module_param(max_mem_regions, ushort, 0444);
+MODULE_PARM_DESC(max_mem_regions,
+	"Maximum number of memory regions in memory map. (default: 64)");
 enum {
-	VHOST_MEMORY_MAX_NREGIONS = 64,
 	VHOST_MEMORY_F_LOG = 0x1,
 };
 		fput(dev->log_file);
 	dev->log_file = NULL;
 	/* No one will access memory at this point */
-	kfree(dev->memory);
+	kvfree(dev->memory);
 	dev->memory = NULL;
 	WARN_ON(!list_empty(&dev->work_list));
 	if (dev->worker) {
 }
 EXPORT_SYMBOL_GPL(vhost_vq_access_ok);
+static int vhost_memory_reg_sort_cmp(const void *p1, const void *p2)
+{
+	const struct vhost_memory_region *r1 = p1, *r2 = p2;
+	if (r1->guest_phys_addr < r2->guest_phys_addr)
+		return 1;
+	if (r1->guest_phys_addr > r2->guest_phys_addr)
+		return -1;
+	return 0;
+}
+static void *vhost_kvzalloc(unsigned long size)
+{
+	void *n = kzalloc(size, GFP_KERNEL | __GFP_NOWARN | __GFP_REPEAT);
+	if (!n) {
+		n = vzalloc(size);
+		if (!n)
+			return ERR_PTR(-ENOMEM);
+	}
+	return n;
+}
 static long vhost_set_memory(struct vhost_dev *d, struct vhost_memory __user *m)
 {
 	struct vhost_memory mem, *newmem, *oldmem;
 		return -EFAULT;
 	if (mem.padding)
 		return -EOPNOTSUPP;
-	if (mem.nregions > VHOST_MEMORY_MAX_NREGIONS)
+	if (mem.nregions > max_mem_regions)
 		return -E2BIG;
-	newmem = kmalloc(size + mem.nregions * sizeof *m->regions, GFP_KERNEL);
+	newmem = vhost_kvzalloc(size + mem.nregions * sizeof(*m->regions));
 	if (!newmem)
 		return -ENOMEM;
 	memcpy(newmem, &mem, size);
 	if (copy_from_user(newmem->regions, m->regions,
 			   mem.nregions * sizeof *m->regions)) {
-		kfree(newmem);
+		kvfree(newmem);
 		return -EFAULT;
 	}
+	sort(newmem->regions, newmem->nregions, sizeof(*newmem->regions),
+		vhost_memory_reg_sort_cmp, NULL);
 	if (!memory_access_ok(d, newmem, 0)) {
-		kfree(newmem);
+		kvfree(newmem);
 		return -EFAULT;
 	}
 	oldmem = d->memory;
 		d->vqs[i]->memory = newmem;
 		mutex_unlock(&d->vqs[i]->mutex);
 	}
-	kfree(oldmem);
+	kvfree(oldmem);
 	return 0;
 }
 static const struct vhost_memory_region *find_region(struct vhost_memory *mem,
 						     __u64 addr, __u32 len)
 {
-	struct vhost_memory_region *reg;
+	const struct vhost_memory_region *reg;
-	int i;
+	int start = 0, end = mem->nregions;
-	/* linear search is not brilliant, but we really have on the order of 6
+	while (start < end) {
-	 * regions in practice */
+		int slot = start + (end - start) / 2;
-	for (i = 0; i < mem->nregions; ++i) {
+		reg = mem->regions + slot;
-		reg = mem->regions + i;
+		if (addr >= reg->guest_phys_addr)
-		if (reg->guest_phys_addr <= addr &&
+			end = slot;
-		    reg->guest_phys_addr + reg->memory_size - 1 >= addr)
+		else
-			return reg;
+			start = slot + 1;
 	}
+	reg = mem->regions + start;
+	if (addr >= reg->guest_phys_addr &&
+		reg->guest_phys_addr + reg->memory_size > addr)
+		return reg;
 	return NULL;
 }

fs/fs-writeback.c+1−0

@@ -702,6 +702,7 @@ void wbc_account_io(struct writeback_control wbc, struct page page, · 701 unmodified lines
702	else	702	else
703	wbc->wb_tcand_bytes -= min(bytes, wbc->wb_tcand_bytes);	703	wbc->wb_tcand_bytes -= min(bytes, wbc->wb_tcand_bytes);
704	}	704	}
		705	EXPORT_SYMBOL_GPL(wbc_account_io);
705		706
706	/**	707	/**
707	* inode_congested - test whether an inode is congested	708	* inode_congested - test whether an inode is congested

fs/namespace.c+33−9

@@ -1361,6 +1361,36 @@ enum umount_tree_flags { · 1360 unmodified lines
1361	UMOUNT_PROPAGATE = 2,	1361	UMOUNT_PROPAGATE = 2,
1362	UMOUNT_CONNECTED = 4,	1362	UMOUNT_CONNECTED = 4,
1363	};	1363	};
		1364
		1365	static bool disconnect_mount(struct mount *mnt, enum umount_tree_flags how)
		1366	{
		1367	/* Leaving mounts connected is only valid for lazy umounts */
		1368	if (how & UMOUNT_SYNC)
		1369	return true;
		1370
		1371	/* A mount without a parent has nothing to be connected to */
		1372	if (!mnt_has_parent(mnt))
		1373	return true;
		1374
		1375	/* Because the reference counting rules change when mounts are
		1376	* unmounted and connected, umounted mounts may not be
		1377	* connected to mounted mounts.
		1378	*/
		1379	if (!(mnt->mnt_parent->mnt.mnt_flags & MNT_UMOUNT))
		1380	return true;
		1381
		1382	/* Has it been requested that the mount remain connected? */
		1383	if (how & UMOUNT_CONNECTED)
		1384	return false;
		1385
		1386	/* Is the mount locked such that it needs to remain connected? */
		1387	if (IS_MNT_LOCKED(mnt))
		1388	return false;
		1389
		1390	/* By default disconnect the mount */
		1391	return true;
		1392	}
		1393
1364	/*	1394	/*
1365	* mount_lock must be held	1395	* mount_lock must be held
1366	* namespace_sem must be held for write	1396	* namespace_sem must be held for write
@@ -1398,10 +1428,7 @@ static void umount_tree(struct mount *mnt, enum umount_tree_flags how) · 31 unmodified lines
1398	if (how & UMOUNT_SYNC)	1428	if (how & UMOUNT_SYNC)
1399	p->mnt.mnt_flags \|= MNT_SYNC_UMOUNT;	1429	p->mnt.mnt_flags \|= MNT_SYNC_UMOUNT;
1400		1430
1401	disconnect = !(((how & UMOUNT_CONNECTED) &&	1431	disconnect = disconnect_mount(p, how);
1402	mnt_has_parent(p) &&
1403	(p->mnt_parent->mnt.mnt_flags & MNT_UMOUNT)) \|\|
1404	IS_MNT_LOCKED_AND_LAZY(p));
1405		1432
1406	pin_insert_group(&p->mnt_umount, &p->mnt_parent->mnt,	1433	pin_insert_group(&p->mnt_umount, &p->mnt_parent->mnt,
1407	disconnect ? &unmounted : NULL);	1434	disconnect ? &unmounted : NULL);
@@ -1538,11 +1565,8 @@ void __detach_mounts(struct dentry *dentry) · 130 unmodified lines
1538	while (!hlist_empty(&mp->m_list)) {	1565	while (!hlist_empty(&mp->m_list)) {
1539	mnt = hlist_entry(mp->m_list.first, struct mount, mnt_mp_list);	1566	mnt = hlist_entry(mp->m_list.first, struct mount, mnt_mp_list);
1540	if (mnt->mnt.mnt_flags & MNT_UMOUNT) {	1567	if (mnt->mnt.mnt_flags & MNT_UMOUNT) {
1541	struct mount p, tmp;	1568	hlist_add_head(&mnt->mnt_umount.s_list, &unmounted);
1542	list_for_each_entry_safe(p, tmp, &mnt->mnt_mounts, mnt_child) {	1569	umount_mnt(mnt);
1543	hlist_add_head(&p->mnt_umount.s_list, &unmounted);
1544	umount_mnt(p);
1545	}
1546	}	1570	}
1547	else umount_tree(mnt, UMOUNT_CONNECTED);	1571	else umount_tree(mnt, UMOUNT_CONNECTED);
1548	}	1572	}

fs/notify/mark.c+20−14

 		BUG();
 	list_del_init(&mark->g_list);
 	spin_unlock(&mark->lock);
 	if (inode && (mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED))
 		iput(inode);
+	/* release lock temporarily */
+	mutex_unlock(&group->mark_mutex);
 	spin_lock(&destroy_lock);
 	list_add(&mark->g_list, &destroy_list);
 	spin_unlock(&destroy_lock);
 	wake_up(&destroy_waitq);
+	/*
+	 * We don't necessarily have a ref on mark from caller so the above destroy
+	 * may have actually freed it, unless this group provides a 'freeing_mark'
+	 * function which must be holding a reference.
+	 */
+	/*
+	 * Some groups like to know that marks are being freed.  This is a
+	 * callback to the group function to let it know that this mark
+	 * is being freed.
+	 */
+	if (group->ops->freeing_mark)
+		group->ops->freeing_mark(mark, group);
 	/*
 	 * __fsnotify_update_child_dentry_flags(inode);
 	 */
 	atomic_dec(&group->num_marks);
+	mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
 }
 void fsnotify_destroy_mark(struct fsnotify_mark *mark,
 /*
  * Destroy all marks in the given list. The marks must be already detached from
- * the original inode / vfsmount. Note that we can race with
+ * the original inode / vfsmount.
- * fsnotify_clear_marks_by_group_flags(). However we hold a reference to each
- * mark so they won't get freed from under us and nobody else touches our
- * free_list list_head.
  */
 void fsnotify_destroy_marks(struct list_head *to_free)
 {
 }
 /*
- * Clear any marks in a group in which mark->flags & flags is true.
+ * clear any marks in a group in which mark->flags & flags is true
  */
 void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group,
 					 unsigned int flags)
 {
 	struct fsnotify_mark *mark, *next;
 	struct list_head private_destroy_list;
-	struct fsnotify_group *group;
 	for (;;) {
 		spin_lock(&destroy_lock);
 		list_for_each_entry_safe(mark, next, &private_destroy_list, g_list) {
 			list_del_init(&mark->g_list);
-			group = mark->group;
-			/*
-			 * Some groups like to know that marks are being freed.
-			 * This is a callback to the group function to let it
-			 * know that this mark is being freed.
-			 */
-			if (group && group->ops->freeing_mark)
-				group->ops->freeing_mark(mark, group);
 			fsnotify_put_mark(mark);
 		}

fs/pnode.h+0−2

@@ -20,8 +20,6 @@ · 19 unmodified lines
20	#define SET_MNT_MARK(m) ((m)->mnt.mnt_flags \|= MNT_MARKED)	20	#define SET_MNT_MARK(m) ((m)->mnt.mnt_flags \|= MNT_MARKED)
21	#define CLEAR_MNT_MARK(m) ((m)->mnt.mnt_flags &= ~MNT_MARKED)	21	#define CLEAR_MNT_MARK(m) ((m)->mnt.mnt_flags &= ~MNT_MARKED)
22	#define IS_MNT_LOCKED(m) ((m)->mnt.mnt_flags & MNT_LOCKED)	22	#define IS_MNT_LOCKED(m) ((m)->mnt.mnt_flags & MNT_LOCKED)
23	#define IS_MNT_LOCKED_AND_LAZY(m) \
24	(((m)->mnt.mnt_flags & (MNT_LOCKED\|MNT_SYNC_UMOUNT)) == MNT_LOCKED)
25		23
26	#define CL_EXPIRE 0x01	24	#define CL_EXPIRE 0x01
27	#define CL_SLAVE 0x02	25	#define CL_SLAVE 0x02

fs/udf/inode.c+7−12

 		       iinfo->i_ext.i_data, inode->i_sb->s_blocksize -
 					sizeof(struct unallocSpaceEntry));
 		use->descTag.tagIdent = cpu_to_le16(TAG_IDENT_USE);
-		use->descTag.tagLocation =
+		crclen = sizeof(struct unallocSpaceEntry);
-				cpu_to_le32(iinfo->i_location.logicalBlockNum);
-		crclen = sizeof(struct unallocSpaceEntry) +
-				iinfo->i_lenAlloc - sizeof(struct tag);
-		use->descTag.descCRCLength = cpu_to_le16(crclen);
-		use->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)use +
-							   sizeof(struct tag),
-							   crclen));
-		use->descTag.tagChecksum = udf_tag_checksum(&use->descTag);
-		goto out;
+		goto finish;
 	}
 	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
 		efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
 		crclen = sizeof(struct extendedFileEntry);
 	}
+finish:
 	if (iinfo->i_strat4096) {
 		fe->icbTag.strategyType = cpu_to_le16(4096);
 		fe->icbTag.strategyParameter = cpu_to_le16(1);
 		fe->icbTag.numEntries = cpu_to_le16(1);
 	}
-	if (S_ISDIR(inode->i_mode))
+	if (iinfo->i_use)
+		fe->icbTag.fileType = ICBTAG_FILE_TYPE_USE;
+	else if (S_ISDIR(inode->i_mode))
 		fe->icbTag.fileType = ICBTAG_FILE_TYPE_DIRECTORY;
 	else if (S_ISREG(inode->i_mode))
 		fe->icbTag.fileType = ICBTAG_FILE_TYPE_REGULAR;
 						  crclen));
 	fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag);
-out:
 	set_buffer_uptodate(bh);
 	unlock_buffer(bh);

include/linux/ata.h+1−0

@@ -45,6 +45,7 @@ enum { · 44 unmodified lines
45	ATA_SECT_SIZE = 512,	45	ATA_SECT_SIZE = 512,
46	ATA_MAX_SECTORS_128 = 128,	46	ATA_MAX_SECTORS_128 = 128,
47	ATA_MAX_SECTORS = 256,	47	ATA_MAX_SECTORS = 256,
		48	ATA_MAX_SECTORS_1024 = 1024,
48	ATA_MAX_SECTORS_LBA48 = 65535,/* TODO: 65536? */	49	ATA_MAX_SECTORS_LBA48 = 65535,/* TODO: 65536? */
49	ATA_MAX_SECTORS_TAPE = 65535,	50	ATA_MAX_SECTORS_TAPE = 65535,
50		51

include/linux/cper.h+21−1

@@ -340,7 +340,27 @@ struct cper_ia_proc_ctx { · 339 unmodified lines
340	__u64 mm_reg_addr;	340	__u64 mm_reg_addr;
341	};	341	};
342		342
343	/* Memory Error Section */	343	/* Old Memory Error Section UEFI 2.1, 2.2 */
		344	struct cper_sec_mem_err_old {
		345	__u64 validation_bits;
		346	__u64 error_status;
		347	__u64 physical_addr;
		348	__u64 physical_addr_mask;
		349	__u16 node;
		350	__u16 card;
		351	__u16 module;
		352	__u16 bank;
		353	__u16 device;
		354	__u16 row;
		355	__u16 column;
		356	__u16 bit_pos;
		357	__u64 requestor_id;
		358	__u64 responder_id;
		359	__u64 target_id;
		360	__u8 error_type;
		361	};
		362
		363	/* Memory Error Section UEFI >= 2.3 */
344	struct cper_sec_mem_err {	364	struct cper_sec_mem_err {
345	__u64 validation_bits;	365	__u64 validation_bits;
346	__u64 error_status;	366	__u64 error_status;

include/linux/ftrace.h+3−0

  *            SAVE_REGS. If another ops with this flag set is already registered
  *            for any of the functions that this ops will be registered for, then
  *            this ops will fail to register or set_filter_ip.
+ * PID     - Is affected by set_ftrace_pid (allows filtering on those pids)
  */
 enum {
 	FTRACE_OPS_FL_ENABLED			= 1 << 0,
 	FTRACE_OPS_FL_MODIFYING			= 1 << 11,
 	FTRACE_OPS_FL_ALLOC_TRAMP		= 1 << 12,
 	FTRACE_OPS_FL_IPMODIFY			= 1 << 13,
+	FTRACE_OPS_FL_PID			= 1 << 14,
 };
 #ifdef CONFIG_DYNAMIC_FTRACE
 	struct ftrace_ops		*next;
 	unsigned long			flags;
 	void				*private;
+	ftrace_func_t			saved_func;
 	int __percpu			*disabled;
 #ifdef CONFIG_DYNAMIC_FTRACE
 	int				nr_trampolines;

include/linux/libata.h+2−0

@@ -431,6 +431,8 @@ enum { · 430 unmodified lines
431	ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21), /* some WDs have broken LPM */	431	ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21), /* some WDs have broken LPM */
432	ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */	432	ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */
433	ATA_HORKAGE_NO_NCQ_LOG = (1 << 23), /* don't use NCQ for log read */	433	ATA_HORKAGE_NO_NCQ_LOG = (1 << 23), /* don't use NCQ for log read */
		434	ATA_HORKAGE_NOTRIM = (1 << 24), /* don't use TRIM */
		435	ATA_HORKAGE_MAX_SEC_1024 = (1 << 25), /* Limit max sects to 1024 */
434		436
435	/* DMA mask for user DMA control: User visible values; DO NOT	437	/* DMA mask for user DMA control: User visible values; DO NOT
436	renumber */	438	renumber */

include/linux/mtd/nand.h+5−5

 #define NAND_OWN_BUFFERS	0x00020000
 /* Chip may not exist, so silence any errors in scan */
 #define NAND_SCAN_SILENT_NODEV	0x00040000
-/*
- * This option could be defined by controller drivers to protect against
- * kmap'ed, vmalloc'ed highmem buffers being passed from upper layers
- */
-#define NAND_USE_BOUNCE_BUFFER	0x00080000
 /*
  * Autodetect nand buswidth with readid/onfi.
  * This suppose the driver will configure the hardware in 8 bits mode
  * before calling nand_scan_tail.
  */
 #define NAND_BUSWIDTH_AUTO      0x00080000
+/*
+ * This option could be defined by controller drivers to protect against
+ * kmap'ed, vmalloc'ed highmem buffers being passed from upper layers
+ */
+#define NAND_USE_BOUNCE_BUFFER	0x00100000
 /* Options set by nand scan */
 /* Nand scan has allocated controller struct */

include/linux/platform_data/mmc-esdhc-imx.h+0−1

@@ -43,7 +43,6 @@ struct esdhc_platform_data { · 42 unmodified lines
43	enum wp_types wp_type;	43	enum wp_types wp_type;
44	enum cd_types cd_type;	44	enum cd_types cd_type;
45	int max_bus_width;	45	int max_bus_width;
46	unsigned int f_max;
47	bool support_vsel;	46	bool support_vsel;
48	unsigned int delay_line;	47	unsigned int delay_line;
49	};	48	};

include/net/cfg80211.h+17−0

@@ -4868,6 +4868,23 @@ bool cfg80211_reg_can_beacon(struct wiphy *wiphy, · 4867 unmodified lines
4868	struct cfg80211_chan_def *chandef,	4868	struct cfg80211_chan_def *chandef,
4869	enum nl80211_iftype iftype);	4869	enum nl80211_iftype iftype);
4870		4870
		4871	/**
		4872	* cfg80211_reg_can_beacon_relax - check if beaconing is allowed with relaxation
		4873	* @wiphy: the wiphy
		4874	* @chandef: the channel definition
		4875	* @iftype: interface type
		4876	*
		4877	* Return: %true if there is no secondary channel or the secondary channel(s)
		4878	* can be used for beaconing (i.e. is not a radar channel etc.). This version
		4879	* also checks if IR-relaxation conditions apply, to allow beaconing under
		4880	* more permissive conditions.
		4881	*
		4882	* Requires the RTNL to be held.
		4883	*/
		4884	bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
		4885	struct cfg80211_chan_def *chandef,
		4886	enum nl80211_iftype iftype);
		4887
4871	/*	4888	/*
4872	* cfg80211_ch_switch_notify - update wdev channel and notify userspace	4889	* cfg80211_ch_switch_notify - update wdev channel and notify userspace
4873	* @dev: the device which switched channels	4890	* @dev: the device which switched channels

include/net/ip.h+1−0

@@ -161,6 +161,7 @@ static inline __u8 get_rtconn_flags(struct ipcm_cookie* ipc, struct sock* sk) · 160 unmodified lines
161	}	161	}
162		162
163	/* datagram.c */	163	/* datagram.c */
		164	int __ip4_datagram_connect(struct sock sk, struct sockaddr uaddr, int addr_len);
164	int ip4_datagram_connect(struct sock sk, struct sockaddr uaddr, int addr_len);	165	int ip4_datagram_connect(struct sock sk, struct sockaddr uaddr, int addr_len);
165		166
166	void ip4_datagram_release_cb(struct sock *sk);	167	void ip4_datagram_release_cb(struct sock *sk);

include/uapi/drm/amdgpu_drm.h+2−0

@@ -614,6 +614,8 @@ struct drm_amdgpu_info_device { · 613 unmodified lines
614	uint32_t vram_type;	614	uint32_t vram_type;
615	/** video memory bit width*/	615	/** video memory bit width*/
616	uint32_t vram_bit_width;	616	uint32_t vram_bit_width;
		617	/* vce harvesting instance */
		618	uint32_t vce_harvest_config;
617	};	619	};
618		620
619	struct drm_amdgpu_info_hw_ip {	621	struct drm_amdgpu_info_hw_ip {

include/uapi/drm/i915_drm.h+8−0

@@ -1070,6 +1070,14 @@ struct drm_i915_reg_read { · 1069 unmodified lines
1070	__u64 offset;	1070	__u64 offset;
1071	__u64 val; /* Return value */	1071	__u64 val; /* Return value */
1072	};	1072	};
		1073	/* Known registers:
		1074	*
		1075	* Render engine timestamp - 0x2358 + 64bit - gen7+
		1076	* - Note this register returns an invalid value if using the default
		1077	* single instruction 8byte read, in order to workaround that use
		1078	* offset (0x2538 \| 1) instead.
		1079	*
		1080	*/
1073		1081
1074	struct drm_i915_reset_stats {	1082	struct drm_i915_reset_stats {
1075	__u32 ctx_id;	1083	__u32 ctx_id;

include/uapi/linux/virtio_net.h+16−0

@@ -34,6 +34,7 @@ · 33 unmodified lines
34	/* The feature bitmap for virtio net */	34	/* The feature bitmap for virtio net */
35	#define VIRTIO_NET_F_CSUM 0 /* Host handles pkts w/ partial csum */	35	#define VIRTIO_NET_F_CSUM 0 /* Host handles pkts w/ partial csum */
36	#define VIRTIO_NET_F_GUEST_CSUM 1 /* Guest handles pkts w/ partial csum */	36	#define VIRTIO_NET_F_GUEST_CSUM 1 /* Guest handles pkts w/ partial csum */
		37	#define VIRTIO_NET_F_CTRL_GUEST_OFFLOADS 2 /* Dynamic offload configuration. */
37	#define VIRTIO_NET_F_MAC 5 /* Host has given MAC address. */	38	#define VIRTIO_NET_F_MAC 5 /* Host has given MAC address. */
38	#define VIRTIO_NET_F_GUEST_TSO4 7 /* Guest can handle TSOv4 in. */	39	#define VIRTIO_NET_F_GUEST_TSO4 7 /* Guest can handle TSOv4 in. */
39	#define VIRTIO_NET_F_GUEST_TSO6 8 /* Guest can handle TSOv6 in. */	40	#define VIRTIO_NET_F_GUEST_TSO6 8 /* Guest can handle TSOv6 in. */
@@ -226,4 +227,19 @@ struct virtio_net_ctrl_mq { · 186 unmodified lines
226	#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN 1	227	#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN 1
227	#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX 0x8000	228	#define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX 0x8000
228		229
		230	/*
		231	* Control network offloads
		232	*
		233	* Reconfigures the network offloads that Guest can handle.
		234	*
		235	* Available with the VIRTIO_NET_F_CTRL_GUEST_OFFLOADS feature bit.
		236	*
		237	* Command data format matches the feature bit mask exactly.
		238	*
		239	* See VIRTIO_NET_F_GUEST_* for the list of offloads
		240	* that can be enabled/disabled.
		241	*/
		242	#define VIRTIO_NET_CTRL_GUEST_OFFLOADS 5
		243	#define VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET 0
		244
229	#endif /* _LINUX_VIRTIO_NET_H */	245	#endif /* _LINUX_VIRTIO_NET_H */

include/uapi/linux/virtio_pci.h+6−0

 	__le32 queue_used_hi;		/* read-write */
 };
+/* Fields in VIRTIO_PCI_CAP_PCI_CFG: */
+struct virtio_pci_cfg_cap {
+	struct virtio_pci_cap cap;
+	__u8 pci_cfg_data[4]; /* Data for BAR access. */
+};
 /* Macro versions of offsets for the Old Timers! */
 #define VIRTIO_PCI_CAP_VNDR		0
 #define VIRTIO_PCI_CAP_NEXT		1

include/uapi/linux/virtio_ring.h+4−1

  * SUCH DAMAGE.
  *
  * Copyright Rusty Russell IBM Corporation 2007. */
+#ifndef __KERNEL__
+#include <stdint.h>
+#endif
 #include <linux/types.h>
 #include <linux/virtio_types.h>
 	vr->num = num;
 	vr->desc = p;
 	vr->avail = p + num*sizeof(struct vring_desc);
-	vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + sizeof(__virtio16)
+	vr->used = (void *)(((uintptr_t)&vr->avail->ring[num] + sizeof(__virtio16)
 		+ align-1) & ~(align - 1));
 }

kernel/resource.c+3−3

@@ -504,13 +504,13 @@ int region_is_ram(resource_size_t start, unsigned long size) · 503 unmodified lines
504	{	504	{
505	struct resource *p;	505	struct resource *p;
506	resource_size_t end = start + size - 1;	506	resource_size_t end = start + size - 1;
507	int flags = IORESOURCE_MEM \| IORESOURCE_BUSY;	507	unsigned long flags = IORESOURCE_MEM \| IORESOURCE_BUSY;
508	const char *name = "System RAM";	508	const char *name = "System RAM";
509	int ret = -1;	509	int ret = -1;
510		510
511	read_lock(&resource_lock);	511	read_lock(&resource_lock);
512	for (p = iomem_resource.child; p ; p = p->sibling) {	512	for (p = iomem_resource.child; p ; p = p->sibling) {
513	if (end < p->start)	513	if (p->end < start)
514	continue;	514	continue;
515		515
516	if (p->start <= start && end <= p->end) {	516	if (p->start <= start && end <= p->end) {
@@ -521,7 +521,7 @@ int region_is_ram(resource_size_t start, unsigned long size) · 4 unmodified lines
521	ret = 1;	521	ret = 1;
522	break;	522	break;
523	}	523	}
524	if (p->end < start)	524	if (end < p->start)
525	break; /* not found */	525	break; /* not found */
526	}	526	}
527	read_unlock(&resource_lock);	527	read_unlock(&resource_lock);

kernel/trace/ftrace.c+34−18

 	struct pid *pid;
 };
+static bool ftrace_pids_enabled(void)
+{
+	return !list_empty(&ftrace_pids);
+}
+static void ftrace_update_trampoline(struct ftrace_ops *ops);
 /*
  * ftrace_disabled is set when an anomaly is discovered.
  * ftrace_disabled is much stronger than ftrace_enabled.
 static struct ftrace_ops *ftrace_control_list __read_mostly = &ftrace_list_end;
 static struct ftrace_ops *ftrace_ops_list __read_mostly = &ftrace_list_end;
 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
-ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub;
 static struct ftrace_ops global_ops;
 static struct ftrace_ops control_ops;
 	if (!test_tsk_trace_trace(current))
 		return;
-	ftrace_pid_function(ip, parent_ip, op, regs);
+	op->saved_func(ip, parent_ip, op, regs);
-}
-static void set_ftrace_pid_function(ftrace_func_t func)
-{
-	/* do not set ftrace_pid_function to itself! */
-	if (func != ftrace_pid_func)
-		ftrace_pid_function = func;
 }
 /**
 void clear_ftrace_function(void)
 {
 	ftrace_trace_function = ftrace_stub;
-	ftrace_pid_function = ftrace_stub;
 }
 static void control_ops_disable_all(struct ftrace_ops *ops)
 	} else
 		add_ftrace_ops(&ftrace_ops_list, ops);
+	/* Always save the function, and reset at unregistering */
+	ops->saved_func = ops->func;
+	if (ops->flags & FTRACE_OPS_FL_PID && ftrace_pids_enabled())
+		ops->func = ftrace_pid_func;
 	ftrace_update_trampoline(ops);
 	if (ftrace_enabled)
 	if (ftrace_enabled)
 		update_ftrace_function();
+	ops->func = ops->saved_func;
 	return 0;
 }
 static void ftrace_update_pid_func(void)
 {
+	bool enabled = ftrace_pids_enabled();
+	struct ftrace_ops *op;
 	/* Only do something if we are tracing something */
 	if (ftrace_trace_function == ftrace_stub)
 		return;
+	do_for_each_ftrace_op(op, ftrace_ops_list) {
+		if (op->flags & FTRACE_OPS_FL_PID) {
+			op->func = enabled ? ftrace_pid_func :
+				op->saved_func;
+			ftrace_update_trampoline(op);
+		}
+	} while_for_each_ftrace_op(op);
 	update_ftrace_function();
 }
 	.local_hash.filter_hash		= EMPTY_HASH,
 	INIT_OPS_HASH(global_ops)
 	.flags				= FTRACE_OPS_FL_RECURSION_SAFE |
-					  FTRACE_OPS_FL_INITIALIZED,
+					  FTRACE_OPS_FL_INITIALIZED |
+					  FTRACE_OPS_FL_PID,
 };
 /*
 static struct ftrace_ops global_ops = {
 	.func			= ftrace_stub,
-	.flags			= FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,
+	.flags			= FTRACE_OPS_FL_RECURSION_SAFE |
+				  FTRACE_OPS_FL_INITIALIZED |
+				  FTRACE_OPS_FL_PID,
 };
 static int __init ftrace_nodyn_init(void)
 		if (WARN_ON(tr->ops->func != ftrace_stub))
 			printk("ftrace ops had %pS for function\n",
 			       tr->ops->func);
-		/* Only the top level instance does pid tracing */
-		if (!list_empty(&ftrace_pids)) {
-			set_ftrace_pid_function(func);
-			func = ftrace_pid_func;
-		}
 	}
 	tr->ops->func = func;
 	tr->ops->private = tr;
 {
 	mutex_lock(&ftrace_lock);
-	if (list_empty(&ftrace_pids) && (!*pos))
+	if (!ftrace_pids_enabled() && (!*pos))
 		return (void *) 1;
 	return seq_list_start(&ftrace_pids, *pos);
 	.func			= ftrace_stub,
 	.flags			= FTRACE_OPS_FL_RECURSION_SAFE |
 				   FTRACE_OPS_FL_INITIALIZED |
+				   FTRACE_OPS_FL_PID |
 				   FTRACE_OPS_FL_STUB,
 #ifdef FTRACE_GRAPH_TRAMP_ADDR
 	.trampoline		= FTRACE_GRAPH_TRAMP_ADDR,

net/9p/trans_virtio.c+1−0

@@ -704,6 +704,7 @@ static void p9_virtio_remove(struct virtio_device *vdev) · 703 unmodified lines
704		704
705	mutex_unlock(&virtio_9p_lock);	705	mutex_unlock(&virtio_9p_lock);
706		706
		707	vdev->config->reset(vdev);
707	vdev->config->del_vqs(vdev);	708	vdev->config->del_vqs(vdev);
708		709
709	sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);	710	sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);

net/ax25/ax25_subr.c+1−0

@@ -264,6 +264,7 @@ void ax25_disconnect(ax25_cb *ax25, int reason) · 263 unmodified lines
264	{	264	{
265	ax25_clear_queues(ax25);	265	ax25_clear_queues(ax25);
266		266
		267	ax25_stop_heartbeat(ax25);
267	ax25_stop_t1timer(ax25);	268	ax25_stop_t1timer(ax25);
268	ax25_stop_t2timer(ax25);	269	ax25_stop_t2timer(ax25);
269	ax25_stop_t3timer(ax25);	270	ax25_stop_t3timer(ax25);

net/bridge/br_mdb.c+0−1

@@ -351,7 +351,6 @@ static int br_mdb_add_group(struct net_bridge br, struct net_bridge_port port, · 350 unmodified lines
351	if (state == MDB_TEMPORARY)	351	if (state == MDB_TEMPORARY)
352	mod_timer(&p->timer, now + br->multicast_membership_interval);	352	mod_timer(&p->timer, now + br->multicast_membership_interval);
353		353
354	br_mdb_notify(br->dev, port, group, RTM_NEWMDB);
355	return 0;	354	return 0;
356	}	355	}
357		356

net/bridge/br_multicast.c+30−7

 				       struct bridge_mcast_own_query *query);
 static void br_multicast_add_router(struct net_bridge *br,
 				    struct net_bridge_port *port);
+static void br_ip4_multicast_leave_group(struct net_bridge *br,
+					 struct net_bridge_port *port,
+					 __be32 group,
+					 __u16 vid);
+#if IS_ENABLED(CONFIG_IPV6)
+static void br_ip6_multicast_leave_group(struct net_bridge *br,
+					 struct net_bridge_port *port,
+					 const struct in6_addr *group,
+					 __u16 vid);
+#endif
 unsigned int br_mdb_rehash_seq;
 static inline int br_ip_equal(const struct br_ip *a, const struct br_ip *b)
 			continue;
 		}
-		err = br_ip4_multicast_add_group(br, port, group, vid);
+		if ((type == IGMPV3_CHANGE_TO_INCLUDE ||
-		if (err)
+		     type == IGMPV3_MODE_IS_INCLUDE) &&
-			break;
+		    ntohs(grec->grec_nsrcs) == 0) {
+			br_ip4_multicast_leave_group(br, port, group, vid);
+		} else {
+			err = br_ip4_multicast_add_group(br, port, group, vid);
+			if (err)
+				break;
+		}
 	}
 	return err;
 			continue;
 		}
-		err = br_ip6_multicast_add_group(br, port, &grec->grec_mca,
+		if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE ||
-						 vid);
+		     grec->grec_type == MLD2_MODE_IS_INCLUDE) &&
-		if (err)
+		    ntohs(*nsrcs) == 0) {
-			break;
+			br_ip6_multicast_leave_group(br, port, &grec->grec_mca,
+						     vid);
+		} else {
+			err = br_ip6_multicast_add_group(br, port,
+							 &grec->grec_mca, vid);
+			if (!err)
+				break;
+		}
 	}
 	return err;

net/caif/caif_socket.c+8−11

@@ -121,12 +121,13 @@ static void caif_flow_ctrl(struct sock *sk, int mode) · 120 unmodified lines
121	* Copied from sock.c:sock_queue_rcv_skb(), but changed so packets are	121	* Copied from sock.c:sock_queue_rcv_skb(), but changed so packets are
122	* not dropped, but CAIF is sending flow off instead.	122	* not dropped, but CAIF is sending flow off instead.
123	*/	123	*/
124	static int caif_queue_rcv_skb(struct sock sk, struct sk_buff skb)	124	static void caif_queue_rcv_skb(struct sock sk, struct sk_buff skb)
125	{	125	{
126	int err;	126	int err;
127	unsigned long flags;	127	unsigned long flags;
128	struct sk_buff_head *list = &sk->sk_receive_queue;	128	struct sk_buff_head *list = &sk->sk_receive_queue;
129	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);	129	struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
		130	bool queued = false;
130		131
131	if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=	132	if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
132	(unsigned int)sk->sk_rcvbuf && rx_flow_is_on(cf_sk)) {	133	(unsigned int)sk->sk_rcvbuf && rx_flow_is_on(cf_sk)) {
@@ -139,7 +140,8 @@ static int caif_queue_rcv_skb(struct sock sk, struct sk_buff skb) · 6 unmodified lines
139		140
140	err = sk_filter(sk, skb);	141	err = sk_filter(sk, skb);
141	if (err)	142	if (err)
142	return err;	143	goto out;
		144
143	if (!sk_rmem_schedule(sk, skb, skb->truesize) && rx_flow_is_on(cf_sk)) {	145	if (!sk_rmem_schedule(sk, skb, skb->truesize) && rx_flow_is_on(cf_sk)) {
144	set_rx_flow_off(cf_sk);	146	set_rx_flow_off(cf_sk);
145	net_dbg_ratelimited("sending flow OFF due to rmem_schedule\n");	147	net_dbg_ratelimited("sending flow OFF due to rmem_schedule\n");
@@ -147,21 +149,16 @@ static int caif_queue_rcv_skb(struct sock sk, struct sk_buff skb) · 1 unmodified line
147	}	149	}
148	skb->dev = NULL;	150	skb->dev = NULL;
149	skb_set_owner_r(skb, sk);	151	skb_set_owner_r(skb, sk);
150	/* Cache the SKB length before we tack it onto the receive
151	* queue. Once it is added it no longer belongs to us and
152	* may be freed by other threads of control pulling packets
153	* from the queue.
154	*/
155	spin_lock_irqsave(&list->lock, flags);	152	spin_lock_irqsave(&list->lock, flags);
156	if (!sock_flag(sk, SOCK_DEAD))	153	queued = !sock_flag(sk, SOCK_DEAD);
		154	if (queued)
157	__skb_queue_tail(list, skb);	155	__skb_queue_tail(list, skb);
158	spin_unlock_irqrestore(&list->lock, flags);	156	spin_unlock_irqrestore(&list->lock, flags);
159		157	out:
160	if (!sock_flag(sk, SOCK_DEAD))	158	if (queued)
161	sk->sk_data_ready(sk);	159	sk->sk_data_ready(sk);
162	else	160	else
163	kfree_skb(skb);	161	kfree_skb(skb);
164	return 0;
165	}	162	}
166		163
167	/* Packet Receive Callback function called from CAIF Stack */	164	/* Packet Receive Callback function called from CAIF Stack */

net/core/datagram.c+47−9

@@ -131,6 +131,35 @@ out_noerr: · 130 unmodified lines
131	goto out;	131	goto out;
132	}	132	}
133		133
		134	static int skb_set_peeked(struct sk_buff *skb)
		135	{
		136	struct sk_buff *nskb;
		137
		138	if (skb->peeked)
		139	return 0;
		140
		141	/* We have to unshare an skb before modifying it. */
		142	if (!skb_shared(skb))
		143	goto done;
		144
		145	nskb = skb_clone(skb, GFP_ATOMIC);
		146	if (!nskb)
		147	return -ENOMEM;
		148
		149	skb->prev->next = nskb;
		150	skb->next->prev = nskb;
		151	nskb->prev = skb->prev;
		152	nskb->next = skb->next;
		153
		154	consume_skb(skb);
		155	skb = nskb;
		156
		157	done:
		158	skb->peeked = 1;
		159
		160	return 0;
		161	}
		162
134	/**	163	/**
135	* __skb_recv_datagram - Receive a datagram skbuff	164	* __skb_recv_datagram - Receive a datagram skbuff
136	* @sk: socket	165	* @sk: socket
@@ -165,7 +194,9 @@ out_noerr: · 28 unmodified lines
165	struct sk_buff __skb_recv_datagram(struct sock sk, unsigned int flags,	194	struct sk_buff __skb_recv_datagram(struct sock sk, unsigned int flags,
166	int peeked, int off, int *err)	195	int peeked, int off, int *err)
167	{	196	{
		197	struct sk_buff_head *queue = &sk->sk_receive_queue;
168	struct sk_buff skb, last;	198	struct sk_buff skb, last;
		199	unsigned long cpu_flags;
169	long timeo;	200	long timeo;
170	/*	201	/*
171	* Caller is allowed not to check sk->sk_err before skb_recv_datagram()	202	* Caller is allowed not to check sk->sk_err before skb_recv_datagram()
@@ -184,8 +215,6 @@ struct sk_buff __skb_recv_datagram(struct sock sk, unsigned int flags, · 12 unmodified lines
184	* Look at current nfs client by the way...	215	* Look at current nfs client by the way...
185	* However, this function was correct in any case. 8)	216	* However, this function was correct in any case. 8)
186	*/	217	*/
187	unsigned long cpu_flags;
188	struct sk_buff_head *queue = &sk->sk_receive_queue;
189	int _off = *off;	218	int _off = *off;
190		219
191	last = (struct sk_buff *)queue;	220	last = (struct sk_buff *)queue;
@@ -199,7 +228,11 @@ struct sk_buff __skb_recv_datagram(struct sock sk, unsigned int flags, · 7 unmodified lines
199	_off -= skb->len;	228	_off -= skb->len;
200	continue;	229	continue;
201	}	230	}
202	skb->peeked = 1;	231
		232	error = skb_set_peeked(skb);
		233	if (error)
		234	goto unlock_err;
		235
203	atomic_inc(&skb->users);	236	atomic_inc(&skb->users);
204	} else	237	} else
205	__skb_unlink(skb, queue);	238	__skb_unlink(skb, queue);
@@ -223,6 +256,8 @@ struct sk_buff __skb_recv_datagram(struct sock sk, unsigned int flags, · 17 unmodified lines
223		256
224	return NULL;	257	return NULL;
225		258
		259	unlock_err:
		260	spin_unlock_irqrestore(&queue->lock, cpu_flags);
226	no_packet:	261	no_packet:
227	*err = error;	262	*err = error;
228	return NULL;	263	return NULL;
@@ -622,7 +657,8 @@ __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len) · 393 unmodified lines
622	!skb->csum_complete_sw)	657	!skb->csum_complete_sw)
623	netdev_rx_csum_fault(skb->dev);	658	netdev_rx_csum_fault(skb->dev);
624	}	659	}
625	skb->csum_valid = !sum;	660	if (!skb_shared(skb))
		661	skb->csum_valid = !sum;
626	return sum;	662	return sum;
627	}	663	}
628	EXPORT_SYMBOL(__skb_checksum_complete_head);	664	EXPORT_SYMBOL(__skb_checksum_complete_head);
@@ -642,11 +678,13 @@ __sum16 __skb_checksum_complete(struct sk_buff *skb) · 13 unmodified lines
642	netdev_rx_csum_fault(skb->dev);	678	netdev_rx_csum_fault(skb->dev);
643	}	679	}
644		680
645	/* Save full packet checksum */	681	if (!skb_shared(skb)) {
646	skb->csum = csum;	682	/* Save full packet checksum */
647	skb->ip_summed = CHECKSUM_COMPLETE;	683	skb->csum = csum;
648	skb->csum_complete_sw = 1;	684	skb->ip_summed = CHECKSUM_COMPLETE;
649	skb->csum_valid = !sum;	685	skb->csum_complete_sw = 1;
		686	skb->csum_valid = !sum;
		687	}
650		688
651	return sum;	689	return sum;
652	}	690	}

net/core/dst.c+3−1

 		int newrefcnt;
 		newrefcnt = atomic_dec_return(&dst->__refcnt);
-		WARN_ON(newrefcnt < 0);
+		if (unlikely(newrefcnt < 0))
+			net_warn_ratelimited("%s: dst:%p refcnt:%d\n",
+					     __func__, dst, newrefcnt);
 		if (unlikely(dst->flags & DST_NOCACHE) && !newrefcnt)
 			call_rcu(&dst->rcu_head, dst_destroy_rcu);
 	}

net/core/rtnetlink.c+7−4

 			goto errout;
 		nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) {
-			if (nla_type(attr) != IFLA_VF_PORT)
+			if (nla_type(attr) != IFLA_VF_PORT ||
-				continue;
+			    nla_len(attr) < NLA_HDRLEN) {
-			err = nla_parse_nested(port, IFLA_PORT_MAX,
+				err = -EINVAL;
-				attr, ifla_port_policy);
+				goto errout;
+			}
+			err = nla_parse_nested(port, IFLA_PORT_MAX, attr,
+					       ifla_port_policy);
 			if (err < 0)
 				goto errout;
 			if (!port[IFLA_PORT_VF]) {

net/ipv4/datagram.c+12−4

 #include <net/route.h>
 #include <net/tcp_states.h>
-int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
+int __ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
 {
 	struct inet_sock *inet = inet_sk(sk);
 	struct sockaddr_in *usin = (struct sockaddr_in *) uaddr;
 	sk_dst_reset(sk);
-	lock_sock(sk);
 	oif = sk->sk_bound_dev_if;
 	saddr = inet->inet_saddr;
 	if (ipv4_is_multicast(usin->sin_addr.s_addr)) {
 	sk_dst_set(sk, &rt->dst);
 	err = 0;
 out:
-	release_sock(sk);
 	return err;
 }
+EXPORT_SYMBOL(__ip4_datagram_connect);
+int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
+{
+	int res;
+	lock_sock(sk);
+	res = __ip4_datagram_connect(sk, uaddr, addr_len);
+	release_sock(sk);
+	return res;
+}
 EXPORT_SYMBOL(ip4_datagram_connect);
 /* Because UDP xmit path can manipulate sk_dst_cache without holding

net/ipv4/inet_hashtables.c+5−6

 int inet_ehash_locks_alloc(struct inet_hashinfo *hashinfo)
 {
+	unsigned int locksz = sizeof(spinlock_t);
 	unsigned int i, nblocks = 1;
-	if (sizeof(spinlock_t) != 0) {
+	if (locksz != 0) {
 		/* allocate 2 cache lines or at least one spinlock per cpu */
-		nblocks = max_t(unsigned int,
+		nblocks = max(2U * L1_CACHE_BYTES / locksz, 1U);
-				2 * L1_CACHE_BYTES / sizeof(spinlock_t),
-				1);
 		nblocks = roundup_pow_of_two(nblocks * num_possible_cpus());
 		/* no more locks than number of hash buckets */
 		nblocks = min(nblocks, hashinfo->ehash_mask + 1);
-		hashinfo->ehash_locks =	kmalloc_array(nblocks, sizeof(spinlock_t),
+		hashinfo->ehash_locks =	kmalloc_array(nblocks, locksz,
 						      GFP_KERNEL | __GFP_NOWARN);
 		if (!hashinfo->ehash_locks)
-			hashinfo->ehash_locks = vmalloc(nblocks * sizeof(spinlock_t));
+			hashinfo->ehash_locks = vmalloc(nblocks * locksz);
 		if (!hashinfo->ehash_locks)
 			return -ENOMEM;

net/ipv4/ip_fragment.c+4−2

 	ihl = ip_hdrlen(skb);
 	/* Determine the position of this fragment. */
-	end = offset + skb->len - ihl;
+	end = offset + skb->len - skb_network_offset(skb) - ihl;
 	err = -EINVAL;
 	/* Is this the final fragment? */
 		goto err;
 	err = -ENOMEM;
-	if (!pskb_pull(skb, ihl))
+	if (!pskb_pull(skb, skb_network_offset(skb) + ihl))
 		goto err;
 	err = pskb_trim_rcsum(skb, end - offset);
 		iph->frag_off = 0;
 	}
+	ip_send_check(iph);
 	IP_INC_STATS_BH(net, IPSTATS_MIB_REASMOKS);
 	qp->q.fragments = NULL;
 	qp->q.fragments_tail = NULL;

net/ipv4/tcp_input.c+1−2

 	const struct inet_connection_sock *icsk = inet_csk(sk);
 	struct tcp_sock *tp = tcp_sk(sk);
 	struct sk_buff *skb;
-	bool new_recovery = false;
+	bool new_recovery = icsk->icsk_ca_state < TCP_CA_Recovery;
 	bool is_reneg;			/* is receiver reneging on SACKs? */
 	/* Reduce ssthresh if it has not yet been made inside this window. */
 	if (icsk->icsk_ca_state <= TCP_CA_Disorder ||
 	    !after(tp->high_seq, tp->snd_una) ||
 	    (icsk->icsk_ca_state == TCP_CA_Loss && !icsk->icsk_retransmits)) {
-		new_recovery = true;
 		tp->prior_ssthresh = tcp_current_ssthresh(sk);
 		tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
 		tcp_ca_event(sk, CA_EVENT_LOSS);

net/ipv6/datagram.c+15−5

 	return ipv6_addr_v4mapped(a) && (a->s6_addr32[3] == 0);
 }
-int ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
+static int __ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
 {
 	struct sockaddr_in6	*usin = (struct sockaddr_in6 *) uaddr;
 	struct inet_sock	*inet = inet_sk(sk);
 	if (usin->sin6_family == AF_INET) {
 		if (__ipv6_only_sock(sk))
 			return -EAFNOSUPPORT;
-		err = ip4_datagram_connect(sk, uaddr, addr_len);
+		err = __ip4_datagram_connect(sk, uaddr, addr_len);
 		goto ipv4_connected;
 	}
 		sin.sin_addr.s_addr = daddr->s6_addr32[3];
 		sin.sin_port = usin->sin6_port;
-		err = ip4_datagram_connect(sk,
+		err = __ip4_datagram_connect(sk,
-					   (struct sockaddr *) &sin,
+					     (struct sockaddr *) &sin,
-					   sizeof(sin));
+					     sizeof(sin));
 ipv4_connected:
 		if (err)
 	fl6_sock_release(flowlabel);
 	return err;
 }
+int ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
+{
+	int res;
+	lock_sock(sk);
+	res = __ip6_datagram_connect(sk, uaddr, addr_len);
+	release_sock(sk);
+	return res;
+}
 EXPORT_SYMBOL_GPL(ip6_datagram_connect);
 int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr *uaddr,

net/ipv6/ip6_offload.c+0−2

@@ -292,8 +292,6 @@ static struct packet_offload ipv6_packet_offload __read_mostly = { · 291 unmodified lines
292	static const struct net_offload sit_offload = {	292	static const struct net_offload sit_offload = {
293	.callbacks = {	293	.callbacks = {
294	.gso_segment = ipv6_gso_segment,	294	.gso_segment = ipv6_gso_segment,
295	.gro_receive = ipv6_gro_receive,
296	.gro_complete = ipv6_gro_complete,
297	},	295	},
298	};	296	};
299		297

net/mac80211/debugfs_netdev.c+1−0

@@ -723,6 +723,7 @@ void ieee80211_debugfs_remove_netdev(struct ieee80211_sub_if_data *sdata) · 722 unmodified lines
723		723
724	debugfs_remove_recursive(sdata->vif.debugfs_dir);	724	debugfs_remove_recursive(sdata->vif.debugfs_dir);
725	sdata->vif.debugfs_dir = NULL;	725	sdata->vif.debugfs_dir = NULL;
		726	sdata->debugfs.subdir_stations = NULL;
726	}	727	}
727		728
728	void ieee80211_debugfs_rename_netdev(struct ieee80211_sub_if_data *sdata)	729	void ieee80211_debugfs_rename_netdev(struct ieee80211_sub_if_data *sdata)

net/mac80211/iface.c+14−11

@@ -1863,10 +1863,6 @@ void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata) · 1862 unmodified lines
1863	ieee80211_teardown_sdata(sdata);	1863	ieee80211_teardown_sdata(sdata);
1864	}	1864	}
1865		1865
1866	/*
1867	* Remove all interfaces, may only be called at hardware unregistration
1868	* time because it doesn't do RCU-safe list removals.
1869	*/
1870	void ieee80211_remove_interfaces(struct ieee80211_local *local)	1866	void ieee80211_remove_interfaces(struct ieee80211_local *local)
1871	{	1867	{
1872	struct ieee80211_sub_if_data sdata, tmp;	1868	struct ieee80211_sub_if_data sdata, tmp;
@@ -1875,14 +1871,21 @@ void ieee80211_remove_interfaces(struct ieee80211_local *local) · 2 unmodified lines
1875		1871
1876	ASSERT_RTNL();	1872	ASSERT_RTNL();
1877		1873
1878	/*	1874	/* Before destroying the interfaces, make sure they're all stopped so
1879	* Close all AP_VLAN interfaces first, as otherwise they	1875	* that the hardware is stopped. Otherwise, the driver might still be
1880	* might be closed while the AP interface they belong to	1876	* iterating the interfaces during the shutdown, e.g. from a worker
1881	* is closed, causing unregister_netdevice_many() to crash.	1877	* or from RX processing or similar, and if it does so (using atomic
		1878	* iteration) while we're manipulating the list, the iteration will
		1879	* crash.
		1880	*
		1881	* After this, the hardware should be stopped and the driver should
		1882	* have stopped all of its activities, so that we can do RCU-unaware
		1883	* manipulations of the interface list below.
1882	*/	1884	*/
1883	list_for_each_entry(sdata, &local->interfaces, list)	1885	cfg80211_shutdown_all_interfaces(local->hw.wiphy);
1884	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)	1886
1885	dev_close(sdata->dev);	1887	WARN(local->open_count, "%s: open count remains %d\n",
		1888	wiphy_name(local->hw.wiphy), local->open_count);
1886		1889
1887	mutex_lock(&local->iflist_mtx);	1890	mutex_lock(&local->iflist_mtx);
1888	list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {	1891	list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {

net/mac80211/mesh_plink.c+4−1

 		if (action == WLAN_SP_MESH_PEERING_CONFIRM) {
 			/* AID */
 			pos = skb_put(skb, 2);
-			put_unaligned_le16(plid, pos + 2);
+			put_unaligned_le16(plid, pos);
 		}
 		if (ieee80211_add_srates_ie(sdata, skb, true, band) ||
 		    ieee80211_add_ext_srates_ie(sdata, skb, true, band) ||
 						WLAN_SP_MESH_PEERING_CONFIRM) {
 		baseaddr += 4;
 		baselen += 4;
+		if (baselen > len)
+			return;
 	}
 	ieee802_11_parse_elems(baseaddr, len - baselen, true, &elems);
 	mesh_process_plink_frame(sdata, mgmt, &elems);

net/mac80211/pm.c+16−0

@@ -76,6 +76,22 @@ int __ieee80211_suspend(struct ieee80211_hw hw, struct cfg80211_wowlan wowlan) · 75 unmodified lines
76	if (sdata->vif.type != NL80211_IFTYPE_STATION)	76	if (sdata->vif.type != NL80211_IFTYPE_STATION)
77	continue;	77	continue;
78	ieee80211_mgd_quiesce(sdata);	78	ieee80211_mgd_quiesce(sdata);
		79	/* If suspended during TX in progress, and wowlan
		80	* is enabled (connection will be active) there
		81	* can be a race where the driver is put out
		82	* of power-save due to TX and during suspend
		83	* dynamic_ps_timer is cancelled and TX packet
		84	* is flushed, leaving the driver in ACTIVE even
		85	* after resuming until dynamic_ps_timer puts
		86	* driver back in DOZE.
		87	*/
		88	if (sdata->u.mgd.associated &&
		89	sdata->u.mgd.powersave &&
		90	!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
		91	local->hw.conf.flags \|= IEEE80211_CONF_PS;
		92	ieee80211_hw_config(local,
		93	IEEE80211_CONF_CHANGE_PS);
		94	}
79	}	95	}
80		96
81	err = drv_suspend(local, wowlan);	97	err = drv_suspend(local, wowlan);

net/mac80211/tdls.c+3−3

 	struct ieee80211_channel *ch;
 	struct cfg80211_chan_def chandef;
 	int i, subband_start;
+	struct wiphy *wiphy = sdata->local->hw.wiphy;
 	for (i = start; i <= end; i += spacing) {
 		if (!ch_cnt)
 			/* we will be active on the channel */
 			cfg80211_chandef_create(&chandef, ch,
 						NL80211_CHAN_NO_HT);
-			if (cfg80211_reg_can_beacon(sdata->local->hw.wiphy,
+			if (cfg80211_reg_can_beacon_relax(wiphy, &chandef,
-						    &chandef,
+							  sdata->wdev.iftype)) {
-						    sdata->wdev.iftype)) {
 				ch_cnt++;
 				/*
 				 * check if the next channel is also part of

net/mac80211/tx.c+3−1

 			queued = true;
 			info->control.vif = &tx->sdata->vif;
 			info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
-			info->flags &= ~IEEE80211_TX_TEMPORARY_FLAGS;
+			info->flags &= ~IEEE80211_TX_TEMPORARY_FLAGS |
+					IEEE80211_TX_CTL_NO_PS_BUFFER |
+					IEEE80211_TX_STATUS_EOSP;
 			__skb_queue_tail(&tid_tx->pending, skb);
 			if (skb_queue_len(&tid_tx->pending) > STA_MAX_TX_BUFFER)
 				purge_skb = __skb_dequeue(&tid_tx->pending);

net/netlink/af_netlink.c+47−32

@@ -357,25 +357,52 @@ err1: · 356 unmodified lines
357	return NULL;	357	return NULL;
358	}	358	}
359		359
		360
		361	static void
		362	__netlink_set_ring(struct sock sk, struct nl_mmap_req req, bool tx_ring, void **pg_vec,
		363	unsigned int order)
		364	{
		365	struct netlink_sock *nlk = nlk_sk(sk);
		366	struct sk_buff_head *queue;
		367	struct netlink_ring *ring;
		368
		369	queue = tx_ring ? &sk->sk_write_queue : &sk->sk_receive_queue;
		370	ring = tx_ring ? &nlk->tx_ring : &nlk->rx_ring;
		371
		372	spin_lock_bh(&queue->lock);
		373
		374	ring->frame_max = req->nm_frame_nr - 1;
		375	ring->head = 0;
		376	ring->frame_size = req->nm_frame_size;
		377	ring->pg_vec_pages = req->nm_block_size / PAGE_SIZE;
		378
		379	swap(ring->pg_vec_len, req->nm_block_nr);
		380	swap(ring->pg_vec_order, order);
		381	swap(ring->pg_vec, pg_vec);
		382
		383	__skb_queue_purge(queue);
		384	spin_unlock_bh(&queue->lock);
		385
		386	WARN_ON(atomic_read(&nlk->mapped));
		387
		388	if (pg_vec)
		389	free_pg_vec(pg_vec, order, req->nm_block_nr);
		390	}
		391
360	static int netlink_set_ring(struct sock sk, struct nl_mmap_req req,	392	static int netlink_set_ring(struct sock sk, struct nl_mmap_req req,
361	bool closing, bool tx_ring)	393	bool tx_ring)
362	{	394	{
363	struct netlink_sock *nlk = nlk_sk(sk);	395	struct netlink_sock *nlk = nlk_sk(sk);
364	struct netlink_ring *ring;	396	struct netlink_ring *ring;
365	struct sk_buff_head *queue;
366	void **pg_vec = NULL;	397	void **pg_vec = NULL;
367	unsigned int order = 0;	398	unsigned int order = 0;
368	int err;
369		399
370	ring = tx_ring ? &nlk->tx_ring : &nlk->rx_ring;	400	ring = tx_ring ? &nlk->tx_ring : &nlk->rx_ring;
371	queue = tx_ring ? &sk->sk_write_queue : &sk->sk_receive_queue;
372		401
373	if (!closing) {	402	if (atomic_read(&nlk->mapped))
374	if (atomic_read(&nlk->mapped))	403	return -EBUSY;
375	return -EBUSY;	404	if (atomic_read(&ring->pending))
376	if (atomic_read(&ring->pending))	405	return -EBUSY;
377	return -EBUSY;
378	}
379		406
380	if (req->nm_block_nr) {	407	if (req->nm_block_nr) {
381	if (ring->pg_vec != NULL)	408	if (ring->pg_vec != NULL)
@@ -407,31 +434,19 @@ static int netlink_set_ring(struct sock sk, struct nl_mmap_req req, · 25 unmodified lines
407	return -EINVAL;	434	return -EINVAL;
408	}	435	}
409		436
410	err = -EBUSY;
411	mutex_lock(&nlk->pg_vec_lock);	437	mutex_lock(&nlk->pg_vec_lock);
412	if (closing \|\| atomic_read(&nlk->mapped) == 0) {	438	if (atomic_read(&nlk->mapped) == 0) {
413	err = 0;	439	__netlink_set_ring(sk, req, tx_ring, pg_vec, order);
414	spin_lock_bh(&queue->lock);	440	mutex_unlock(&nlk->pg_vec_lock);
415		441	return 0;
416	ring->frame_max = req->nm_frame_nr - 1;
417	ring->head = 0;
418	ring->frame_size = req->nm_frame_size;
419	ring->pg_vec_pages = req->nm_block_size / PAGE_SIZE;
420
421	swap(ring->pg_vec_len, req->nm_block_nr);
422	swap(ring->pg_vec_order, order);
423	swap(ring->pg_vec, pg_vec);
424
425	__skb_queue_purge(queue);
426	spin_unlock_bh(&queue->lock);
427
428	WARN_ON(atomic_read(&nlk->mapped));
429	}	442	}
		443
430	mutex_unlock(&nlk->pg_vec_lock);	444	mutex_unlock(&nlk->pg_vec_lock);
431		445
432	if (pg_vec)	446	if (pg_vec)
433	free_pg_vec(pg_vec, order, req->nm_block_nr);	447	free_pg_vec(pg_vec, order, req->nm_block_nr);
434	return err;	448
		449	return -EBUSY;
435	}	450	}
436		451
437	static void netlink_mm_open(struct vm_area_struct *vma)	452	static void netlink_mm_open(struct vm_area_struct *vma)
@@ -900,10 +915,10 @@ static void netlink_sock_destruct(struct sock *sk) · 462 unmodified lines
900		915
901	memset(&req, 0, sizeof(req));	916	memset(&req, 0, sizeof(req));
902	if (nlk->rx_ring.pg_vec)	917	if (nlk->rx_ring.pg_vec)
903	netlink_set_ring(sk, &req, true, false);	918	__netlink_set_ring(sk, &req, false, NULL, 0);
904	memset(&req, 0, sizeof(req));	919	memset(&req, 0, sizeof(req));
905	if (nlk->tx_ring.pg_vec)	920	if (nlk->tx_ring.pg_vec)
906	netlink_set_ring(sk, &req, true, true);	921	__netlink_set_ring(sk, &req, true, NULL, 0);
907	}	922	}
908	#endif /* CONFIG_NETLINK_MMAP */	923	#endif /* CONFIG_NETLINK_MMAP */
909		924
@@ -2223,7 +2238,7 @@ static int netlink_setsockopt(struct socket *sock, int level, int optname, · 1313 unmodified lines
2223	return -EINVAL;	2238	return -EINVAL;
2224	if (copy_from_user(&req, optval, sizeof(req)))	2239	if (copy_from_user(&req, optval, sizeof(req)))
2225	return -EFAULT;	2240	return -EFAULT;
2226	err = netlink_set_ring(sk, &req, false,	2241	err = netlink_set_ring(sk, &req,
2227	optname == NETLINK_TX_RING);	2242	optname == NETLINK_TX_RING);
2228	break;	2243	break;
2229	}	2244	}

net/openvswitch/flow_table.c+1−1

@@ -752,7 +752,7 @@ int ovs_flow_init(void) · 751 unmodified lines
752	BUILD_BUG_ON(sizeof(struct sw_flow_key) % sizeof(long));	752	BUILD_BUG_ON(sizeof(struct sw_flow_key) % sizeof(long));
753		753
754	flow_cache = kmem_cache_create("sw_flow", sizeof(struct sw_flow)	754	flow_cache = kmem_cache_create("sw_flow", sizeof(struct sw_flow)
755	+ (num_possible_nodes()	755	+ (nr_node_ids
756	* sizeof(struct flow_stats *)),	756	* sizeof(struct flow_stats *)),
757	0, 0, NULL);	757	0, 0, NULL);
758	if (flow_cache == NULL)	758	if (flow_cache == NULL)

net/sched/act_bpf.c+3−0

@@ -339,6 +339,9 @@ static void tcf_bpf_cleanup(struct tc_action *act, int bind) · 338 unmodified lines
339	bpf_prog_put(prog->filter);	339	bpf_prog_put(prog->filter);
340	else	340	else
341	bpf_prog_destroy(prog->filter);	341	bpf_prog_destroy(prog->filter);
		342
		343	kfree(prog->bpf_ops);
		344	kfree(prog->bpf_name);
342	}	345	}
343		346
344	static struct tc_action_ops act_bpf_ops __read_mostly = {	347	static struct tc_action_ops act_bpf_ops __read_mostly = {

net/sched/cls_bpf.c+1−1

@@ -378,7 +378,7 @@ static int cls_bpf_change(struct net net, struct sk_buff in_skb, · 377 unmodified lines
378	goto errout;	378	goto errout;
379		379
380	if (oldprog) {	380	if (oldprog) {
381	list_replace_rcu(&prog->link, &oldprog->link);	381	list_replace_rcu(&oldprog->link, &prog->link);
382	tcf_unbind_filter(tp, &oldprog->res);	382	tcf_unbind_filter(tp, &oldprog->res);
383	call_rcu(&oldprog->rcu, __cls_bpf_delete_prog);	383	call_rcu(&oldprog->rcu, __cls_bpf_delete_prog);
384	} else {	384	} else {

net/sched/cls_flow.c+3−2

 	if (!fnew)
 		goto err2;
+	tcf_exts_init(&fnew->exts, TCA_FLOW_ACT, TCA_FLOW_POLICE);
 	fold = (struct flow_filter *)*arg;
 	if (fold) {
 		err = -EINVAL;
 		fnew->mask  = ~0U;
 		fnew->tp = tp;
 		get_random_bytes(&fnew->hashrnd, 4);
-		tcf_exts_init(&fnew->exts, TCA_FLOW_ACT, TCA_FLOW_POLICE);
 	}
 	fnew->perturb_timer.function = flow_perturbation;
 	if (*arg == 0)
 		list_add_tail_rcu(&fnew->list, &head->filters);
 	else
-		list_replace_rcu(&fnew->list, &fold->list);
+		list_replace_rcu(&fold->list, &fnew->list);
 	*arg = (unsigned long)fnew;

net/sched/cls_flower.c+1−1

@@ -499,7 +499,7 @@ static int fl_change(struct net net, struct sk_buff in_skb, · 498 unmodified lines
499	*arg = (unsigned long) fnew;	499	*arg = (unsigned long) fnew;
500		500
501	if (fold) {	501	if (fold) {
502	list_replace_rcu(&fnew->list, &fold->list);	502	list_replace_rcu(&fold->list, &fnew->list);
503	tcf_unbind_filter(tp, &fold->res);	503	tcf_unbind_filter(tp, &fold->res);
504	call_rcu(&fold->rcu, fl_destroy_filter);	504	call_rcu(&fold->rcu, fl_destroy_filter);
505	} else {	505	} else {

net/sched/sch_fq_codel.c+11−2

 	skb = dequeue_head(flow);
 	len = qdisc_pkt_len(skb);
 	q->backlogs[idx] -= len;
-	kfree_skb(skb);
 	sch->q.qlen--;
 	qdisc_qstats_drop(sch);
 	qdisc_qstats_backlog_dec(sch, skb);
+	kfree_skb(skb);
 	flow->dropped++;
 	return idx;
 }
+static unsigned int fq_codel_qdisc_drop(struct Qdisc *sch)
+{
+	unsigned int prev_backlog;
+	prev_backlog = sch->qstats.backlog;
+	fq_codel_drop(sch);
+	return prev_backlog - sch->qstats.backlog;
+}
 static int fq_codel_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 {
 	struct fq_codel_sched_data *q = qdisc_priv(sch);
 	.enqueue	=	fq_codel_enqueue,
 	.dequeue	=	fq_codel_dequeue,
 	.peek		=	qdisc_peek_dequeued,
-	.drop		=	fq_codel_drop,
+	.drop		=	fq_codel_qdisc_drop,
 	.init		=	fq_codel_init,
 	.reset		=	fq_codel_reset,
 	.destroy	=	fq_codel_destroy,

net/sched/sch_sfq.c+1−1

 		len = qdisc_pkt_len(skb);
 		slot->backlog -= len;
 		sfq_dec(q, x);
-		kfree_skb(skb);
 		sch->q.qlen--;
 		qdisc_qstats_drop(sch);
 		qdisc_qstats_backlog_dec(sch, skb);
+		kfree_skb(skb);
 		return len;
 	}

net/wireless/chan.c+34−11

 	return false;
 }
-bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
+static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
-			     struct cfg80211_chan_def *chandef,
+				     struct cfg80211_chan_def *chandef,
-			     enum nl80211_iftype iftype)
+				     enum nl80211_iftype iftype,
+				     bool check_no_ir)
 {
 	bool res;
 	u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
 			       IEEE80211_CHAN_RADAR;
-	trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype);
+	trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
-	/*
+	if (check_no_ir)
-	 * Under certain conditions suggested by some regulatory bodies a
-	 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
-	 * only if such relaxations are not enabled and the conditions are not
-	 * met.
-	 */
-	if (!cfg80211_ir_permissive_chan(wiphy, iftype, chandef->chan))
 		prohibited_flags |= IEEE80211_CHAN_NO_IR;
 	if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
 	trace_cfg80211_return_bool(res);
 	return res;
 }
+bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
+			     struct cfg80211_chan_def *chandef,
+			     enum nl80211_iftype iftype)
+{
+	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
+}
 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
+bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
+				   struct cfg80211_chan_def *chandef,
+				   enum nl80211_iftype iftype)
+{
+	bool check_no_ir;
+	ASSERT_RTNL();
+	/*
+	 * Under certain conditions suggested by some regulatory bodies a
+	 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
+	 * only if such relaxations are not enabled and the conditions are not
+	 * met.
+	 */
+	check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
+						   chandef->chan);
+	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
+}
+EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
 				 struct cfg80211_chan_def *chandef)
 {

net/wireless/nl80211.c+8−6

 	switch (iftype) {
 	case NL80211_IFTYPE_AP:
 	case NL80211_IFTYPE_P2P_GO:
-		if (!cfg80211_reg_can_beacon(&rdev->wiphy, &chandef, iftype)) {
+		if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
+						   iftype)) {
 			result = -EINVAL;
 			break;
 		}
 	} else if (!nl80211_get_ap_channel(rdev, &params))
 		return -EINVAL;
-	if (!cfg80211_reg_can_beacon(&rdev->wiphy, &params.chandef,
+	if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &params.chandef,
-				     wdev->iftype))
+					   wdev->iftype))
 		return -EINVAL;
 	if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
 	if (err)
 		return err;
-	if (!cfg80211_reg_can_beacon(&rdev->wiphy, &params.chandef,
+	if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &params.chandef,
-				     wdev->iftype))
+					   wdev->iftype))
 		return -EINVAL;
 	err = cfg80211_chandef_dfs_required(wdev->wiphy,
 		return -EINVAL;
 	/* we will be active on the TDLS link */
-	if (!cfg80211_reg_can_beacon(&rdev->wiphy, &chandef, wdev->iftype))
+	if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
+					   wdev->iftype))
 		return -EINVAL;
 	/* don't allow switching to DFS channels */

net/wireless/reg.c+4−4

@@ -544,15 +544,15 @@ static int call_crda(const char *alpha2) · 543 unmodified lines
544	reg_regdb_query(alpha2);	544	reg_regdb_query(alpha2);
545		545
546	if (reg_crda_timeouts > REG_MAX_CRDA_TIMEOUTS) {	546	if (reg_crda_timeouts > REG_MAX_CRDA_TIMEOUTS) {
547	pr_info("Exceeded CRDA call max attempts. Not calling CRDA\n");	547	pr_debug("Exceeded CRDA call max attempts. Not calling CRDA\n");
548	return -EINVAL;	548	return -EINVAL;
549	}	549	}
550		550
551	if (!is_world_regdom((char *) alpha2))	551	if (!is_world_regdom((char *) alpha2))
552	pr_info("Calling CRDA for country: %c%c\n",	552	pr_debug("Calling CRDA for country: %c%c\n",
553	alpha2[0], alpha2[1]);	553	alpha2[0], alpha2[1]);
554	else	554	else
555	pr_info("Calling CRDA to update world regulatory domain\n");	555	pr_debug("Calling CRDA to update world regulatory domain\n");
556		556
557	return kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, env);	557	return kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, env);
558	}	558	}
@@ -1589,7 +1589,7 @@ static bool reg_wdev_chan_valid(struct wiphy wiphy, struct wireless_dev wdev) · 1030 unmodified lines
1589	case NL80211_IFTYPE_AP:	1589	case NL80211_IFTYPE_AP:
1590	case NL80211_IFTYPE_P2P_GO:	1590	case NL80211_IFTYPE_P2P_GO:
1591	case NL80211_IFTYPE_ADHOC:	1591	case NL80211_IFTYPE_ADHOC:
1592	return cfg80211_reg_can_beacon(wiphy, &chandef, iftype);	1592	return cfg80211_reg_can_beacon_relax(wiphy, &chandef, iftype);
1593	case NL80211_IFTYPE_STATION:	1593	case NL80211_IFTYPE_STATION:
1594	case NL80211_IFTYPE_P2P_CLIENT:	1594	case NL80211_IFTYPE_P2P_CLIENT:
1595	return cfg80211_chandef_usable(wiphy, &chandef,	1595	return cfg80211_chandef_usable(wiphy, &chandef,

net/wireless/trace.h+7−4

 TRACE_EVENT(cfg80211_reg_can_beacon,
 	TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef,
-		 enum nl80211_iftype iftype),
+		 enum nl80211_iftype iftype, bool check_no_ir),
-	TP_ARGS(wiphy, chandef, iftype),
+	TP_ARGS(wiphy, chandef, iftype, check_no_ir),
 	TP_STRUCT__entry(
 		WIPHY_ENTRY
 		CHAN_DEF_ENTRY
 		__field(enum nl80211_iftype, iftype)
+		__field(bool, check_no_ir)
 	),
 	TP_fast_assign(
 		WIPHY_ASSIGN;
 		CHAN_DEF_ASSIGN(chandef);
 		__entry->iftype = iftype;
+		__entry->check_no_ir = check_no_ir;
 	),
-	TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d",
+	TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d check_no_ir=%s",
-		  WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype)
+		  WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype,
+		  BOOL_TO_STR(__entry->check_no_ir))
 );
 TRACE_EVENT(cfg80211_chandef_dfs_required,

samples/trace_events/trace-events-sample.h+5−2

  *
  *      For __dynamic_array(int, foo, bar) use __get_dynamic_array(foo)
  *            Use __get_dynamic_array_len(foo) to get the length of the array
- *            saved.
+ *            saved. Note, __get_dynamic_array_len() returns the total allocated
+ *            length of the dynamic array; __print_array() expects the second
+ *            parameter to be the number of elements. To get that, the array length
+ *            needs to be divided by the element size.
  *
  *      For __string(foo, bar) use __get_str(foo)
  *
  *    This prints out the array that is defined by __array in a nice format.
  */
 		  __print_array(__get_dynamic_array(list),
-				__get_dynamic_array_len(list),
+				__get_dynamic_array_len(list) / sizeof(int),
 				sizeof(int)),
 		  __get_str(str), __get_bitmask(cpus))
 );

sound/core/pcm_native.c+1−1

@@ -85,7 +85,7 @@ static DECLARE_RWSEM(snd_pcm_link_rwsem); · 84 unmodified lines
85	void snd_pcm_stream_lock(struct snd_pcm_substream *substream)	85	void snd_pcm_stream_lock(struct snd_pcm_substream *substream)
86	{	86	{
87	if (substream->pcm->nonatomic) {	87	if (substream->pcm->nonatomic) {
88	down_read(&snd_pcm_link_rwsem);	88	down_read_nested(&snd_pcm_link_rwsem, SINGLE_DEPTH_NESTING);
89	mutex_lock(&substream->self_group.mutex);	89	mutex_lock(&substream->self_group.mutex);
90	} else {	90	} else {
91	read_lock(&snd_pcm_link_rwlock);	91	read_lock(&snd_pcm_link_rwlock);

sound/hda/hdac_i915.c+4−1

 		enable ? "enable" : "disable");
 	if (enable) {
-		if (!bus->i915_power_refcount++)
+		if (!bus->i915_power_refcount++) {
 			acomp->ops->get_power(acomp->dev);
+			snd_hdac_set_codec_wakeup(bus, true);
+			snd_hdac_set_codec_wakeup(bus, false);
+		}
 	} else {
 		WARN_ON(!bus->i915_power_refcount);
 		if (!--bus->i915_power_refcount)

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

 	if (!azx_has_pm_runtime(chip))
 		return 0;
-	if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL
+	if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
-		&& hda->need_i915_power) {
+		bus = azx_bus(chip);
-		bus =  azx_bus(chip);
+		if (hda->need_i915_power) {
-		snd_hdac_display_power(bus, true);
+			snd_hdac_display_power(bus, true);
-		haswell_set_bclk(hda);
+			haswell_set_bclk(hda);
-		/* toggle codec wakeup bit for STATESTS read */
+		} else {
-		snd_hdac_set_codec_wakeup(bus, true);
+			/* toggle codec wakeup bit for STATESTS read */
-		snd_hdac_set_codec_wakeup(bus, false);
+			snd_hdac_set_codec_wakeup(bus, true);
+			snd_hdac_set_codec_wakeup(bus, false);
+		}
 	}
 	/* Read STATESTS before controller reset */
 	/* ATI HDMI */
 	{ PCI_DEVICE(0x1002, 0x1308),
 	  .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
+	{ PCI_DEVICE(0x1002, 0x157a),
+	  .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
 	{ PCI_DEVICE(0x1002, 0x793b),
 	  .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
 	{ PCI_DEVICE(0x1002, 0x7919),
 	  .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
 	{ PCI_DEVICE(0x1002, 0xaab0),
 	  .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
+	{ PCI_DEVICE(0x1002, 0xaac0),
+	  .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
 	{ PCI_DEVICE(0x1002, 0xaac8),
 	  .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
+	{ PCI_DEVICE(0x1002, 0xaad8),
+	  .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
+	{ PCI_DEVICE(0x1002, 0xaae8),
+	  .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
 	/* VIA VT8251/VT8237A */
 	{ PCI_DEVICE(0x1106, 0x3288),
 	  .driver_data = AZX_DRIVER_VIA | AZX_DCAPS_POSFIX_VIA },

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

 { .id = 0x10de0070, .name = "GPU 70 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0071, .name = "GPU 71 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0072, .name = "GPU 72 HDMI/DP",	.patch = patch_nvhdmi },
+{ .id = 0x10de007d, .name = "GPU 7d HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de8001, .name = "MCP73 HDMI",	.patch = patch_nvhdmi_2ch },
 { .id = 0x11069f80, .name = "VX900 HDMI/DP",	.patch = patch_via_hdmi },
 { .id = 0x11069f81, .name = "VX900 HDMI/DP",	.patch = patch_via_hdmi },
 MODULE_ALIAS("snd-hda-codec-id:10de0070");
 MODULE_ALIAS("snd-hda-codec-id:10de0071");
 MODULE_ALIAS("snd-hda-codec-id:10de0072");
+MODULE_ALIAS("snd-hda-codec-id:10de007d");
 MODULE_ALIAS("snd-hda-codec-id:10de8001");
 MODULE_ALIAS("snd-hda-codec-id:11069f80");
 MODULE_ALIAS("snd-hda-codec-id:11069f81");

sound/pci/hda/patch_realtek.c+31−8

 			{ 0x14, 0x90170110 },
 			{ 0x17, 0x40000008 },
 			{ 0x18, 0x411111f0 },
-			{ 0x19, 0x411111f0 },
+			{ 0x19, 0x01a1913c },
 			{ 0x1a, 0x411111f0 },
 			{ 0x1b, 0x411111f0 },
 			{ 0x1d, 0x40f89b2d },
 	{0x15, 0x0221401f}, \
 	{0x1a, 0x411111f0}, \
 	{0x1b, 0x411111f0}, \
-	{0x1d, 0x40700001}, \
+	{0x1d, 0x40700001}
-	{0x1e, 0x411111f0}
 #define ALC298_STANDARD_PINS \
 	{0x18, 0x411111f0}, \
 		{0x17, 0x40000000},
 		{0x1d, 0x40700001},
 		{0x21, 0x02211030}),
+	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
+		{0x12, 0x40000000},
+		{0x14, 0x90170130},
+		{0x17, 0x411111f0},
+		{0x18, 0x411111f0},
+		{0x19, 0x411111f0},
+		{0x1a, 0x411111f0},
+		{0x1b, 0x01014020},
+		{0x1d, 0x4054c029},
+		{0x1e, 0x411111f0},
+		{0x21, 0x0221103f}),
 	SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
 		{0x12, 0x90a60160},
 		{0x14, 0x90170120},
 		{0x13, 0x411111f0},
 		{0x16, 0x01014020},
 		{0x18, 0x411111f0},
-		{0x19, 0x01a19030}),
+		{0x19, 0x01a19030},
+		{0x1e, 0x411111f0}),
 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
 		ALC292_STANDARD_PINS,
 		{0x12, 0x90a60140},
 		{0x13, 0x411111f0},
 		{0x16, 0x01014020},
 		{0x18, 0x02a19031},
-		{0x19, 0x01a1903e}),
+		{0x19, 0x01a1903e},
+		{0x1e, 0x411111f0}),
 	SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
 		ALC292_STANDARD_PINS,
 		{0x12, 0x90a60140},
 		{0x13, 0x411111f0},
 		{0x16, 0x411111f0},
 		{0x18, 0x411111f0},
-		{0x19, 0x411111f0}),
+		{0x19, 0x411111f0},
+		{0x1e, 0x411111f0}),
 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC292_STANDARD_PINS,
 		{0x12, 0x40000000},
 		{0x13, 0x90a60140},
 		{0x16, 0x21014020},
 		{0x18, 0x411111f0},
-		{0x19, 0x21a19030}),
+		{0x19, 0x21a19030},
+		{0x1e, 0x411111f0}),
 	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC292_STANDARD_PINS,
 		{0x12, 0x40000000},
 		{0x13, 0x90a60140},
 		{0x16, 0x411111f0},
 		{0x18, 0x411111f0},
-		{0x19, 0x411111f0}),
+		{0x19, 0x411111f0},
+		{0x1e, 0x411111f0}),
+	SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
+		ALC292_STANDARD_PINS,
+		{0x12, 0x40000000},
+		{0x13, 0x90a60140},
+		{0x16, 0x21014020},
+		{0x18, 0x411111f0},
+		{0x19, 0x21a19030},
+		{0x1e, 0x411111ff}),
 	SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
 		ALC298_STANDARD_PINS,
 		{0x12, 0x90a60130},

sound/sparc/amd7930.c+1−0

@@ -956,6 +956,7 @@ static int snd_amd7930_create(struct snd_card *card, · 955 unmodified lines
956	if (!amd->regs) {	956	if (!amd->regs) {
957	snd_printk(KERN_ERR	957	snd_printk(KERN_ERR
958	"amd7930-%d: Unable to map chip registers.\n", dev);	958	"amd7930-%d: Unable to map chip registers.\n", dev);
		959	kfree(amd);
959	return -EIO;	960	return -EIO;
960	}	961	}
961		962

Merge 4.2-rc4 into tty-next

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code