lael-labs/linux

MAINTAINERS+1−2

@@ -10195,7 +10195,6 @@ F: drivers/media/tuners/qt1010* · 10194 unmodified lines
10195	QUALCOMM ATHEROS ATH9K WIRELESS DRIVER	10195	QUALCOMM ATHEROS ATH9K WIRELESS DRIVER
10196	M: QCA ath9k Development <ath9k-devel@qca.qualcomm.com>	10196	M: QCA ath9k Development <ath9k-devel@qca.qualcomm.com>
10197	L: linux-wireless@vger.kernel.org	10197	L: linux-wireless@vger.kernel.org
10198	L: ath9k-devel@lists.ath9k.org
10199	W: http://wireless.kernel.org/en/users/Drivers/ath9k	10198	W: http://wireless.kernel.org/en/users/Drivers/ath9k
10200	S: Supported	10199	S: Supported
10201	F: drivers/net/wireless/ath/ath9k/	10200	F: drivers/net/wireless/ath/ath9k/
@@ -13066,7 +13065,7 @@ F: drivers/input/serio/userio.c · 2864 unmodified lines
13066	F: include/uapi/linux/userio.h	13065	F: include/uapi/linux/userio.h
13067		13066
13068	VIRTIO CONSOLE DRIVER	13067	VIRTIO CONSOLE DRIVER
13069	M: Amit Shah <amit.shah@redhat.com>	13068	M: Amit Shah <amit@kernel.org>
13070	L: virtualization@lists.linux-foundation.org	13069	L: virtualization@lists.linux-foundation.org
13071	S: Maintained	13070	S: Maintained
13072	F: drivers/char/virtio_console.c	13071	F: drivers/char/virtio_console.c

Makefile+2−2

@@ -1,7 +1,7 @@
1	VERSION = 4	1	VERSION = 4
2	PATCHLEVEL = 10	2	PATCHLEVEL = 10
3	SUBLEVEL = 0	3	SUBLEVEL = 0
4	EXTRAVERSION = -rc6	4	EXTRAVERSION = -rc7
5	NAME = Fearless Coyote	5	NAME = Fearless Coyote
6		6
7	# DOCUMENTATION	7	# DOCUMENTATION
@@ -797,7 +797,7 @@ KBUILD_CFLAGS += $(call cc-option,-Werror=incompatible-pointer-types) · 789 unmodified lines
797	KBUILD_ARFLAGS := $(call ar-option,D)	797	KBUILD_ARFLAGS := $(call ar-option,D)
798		798
799	# check for 'asm goto'	799	# check for 'asm goto'
800	ifeq ($(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-goto.sh $(CC)), y)	800	ifeq ($(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-goto.sh $(CC) $(KBUILD_CFLAGS)), y)
801	KBUILD_CFLAGS += -DCC_HAVE_ASM_GOTO	801	KBUILD_CFLAGS += -DCC_HAVE_ASM_GOTO
802	KBUILD_AFLAGS += -DCC_HAVE_ASM_GOTO	802	KBUILD_AFLAGS += -DCC_HAVE_ASM_GOTO
803	endif	803	endif

arch/arm64/crypto/aes-modes.S+42−46

@@ -193,15 +193,16 @@ AES_ENTRY(aes_cbc_encrypt) · 192 unmodified lines
193	cbz w6, .Lcbcencloop	193	cbz w6, .Lcbcencloop
194		194
195	ld1 {v0.16b}, [x5] /* get iv */	195	ld1 {v0.16b}, [x5] /* get iv */
196	enc_prepare w3, x2, x5	196	enc_prepare w3, x2, x6
197		197
198	.Lcbcencloop:	198	.Lcbcencloop:
199	ld1 {v1.16b}, [x1], #16 /* get next pt block */	199	ld1 {v1.16b}, [x1], #16 /* get next pt block */
200	eor v0.16b, v0.16b, v1.16b /* ..and xor with iv */	200	eor v0.16b, v0.16b, v1.16b /* ..and xor with iv */
201	encrypt_block v0, w3, x2, x5, w6	201	encrypt_block v0, w3, x2, x6, w7
202	st1 {v0.16b}, [x0], #16	202	st1 {v0.16b}, [x0], #16
203	subs w4, w4, #1	203	subs w4, w4, #1
204	bne .Lcbcencloop	204	bne .Lcbcencloop
		205	st1 {v0.16b}, [x5] /* return iv */
205	ret	206	ret
206	AES_ENDPROC(aes_cbc_encrypt)	207	AES_ENDPROC(aes_cbc_encrypt)
207		208
@@ -211,7 +212,7 @@ AES_ENTRY(aes_cbc_decrypt) · 3 unmodified lines
211	cbz w6, .LcbcdecloopNx	212	cbz w6, .LcbcdecloopNx
212		213
213	ld1 {v7.16b}, [x5] /* get iv */	214	ld1 {v7.16b}, [x5] /* get iv */
214	dec_prepare w3, x2, x5	215	dec_prepare w3, x2, x6
215		216
216	.LcbcdecloopNx:	217	.LcbcdecloopNx:
217	#if INTERLEAVE >= 2	218	#if INTERLEAVE >= 2
@@ -248,7 +249,7 @@ AES_ENTRY(aes_cbc_decrypt) · 30 unmodified lines
248	.Lcbcdecloop:	249	.Lcbcdecloop:
249	ld1 {v1.16b}, [x1], #16 /* get next ct block */	250	ld1 {v1.16b}, [x1], #16 /* get next ct block */
250	mov v0.16b, v1.16b /* ...and copy to v0 */	251	mov v0.16b, v1.16b /* ...and copy to v0 */
251	decrypt_block v0, w3, x2, x5, w6	252	decrypt_block v0, w3, x2, x6, w7
252	eor v0.16b, v0.16b, v7.16b /* xor with iv => pt */	253	eor v0.16b, v0.16b, v7.16b /* xor with iv => pt */
253	mov v7.16b, v1.16b /* ct is next iv */	254	mov v7.16b, v1.16b /* ct is next iv */
254	st1 {v0.16b}, [x0], #16	255	st1 {v0.16b}, [x0], #16
@@ -256,6 +257,7 @@ AES_ENTRY(aes_cbc_decrypt) · 1 unmodified line
256	bne .Lcbcdecloop	257	bne .Lcbcdecloop
257	.Lcbcdecout:	258	.Lcbcdecout:
258	FRAME_POP	259	FRAME_POP
		260	st1 {v7.16b}, [x5] /* return iv */
259	ret	261	ret
260	AES_ENDPROC(aes_cbc_decrypt)	262	AES_ENDPROC(aes_cbc_decrypt)
261		263
@@ -267,24 +269,15 @@ AES_ENDPROC(aes_cbc_decrypt) · 5 unmodified lines
267		269
268	AES_ENTRY(aes_ctr_encrypt)	270	AES_ENTRY(aes_ctr_encrypt)
269	FRAME_PUSH	271	FRAME_PUSH
270	cbnz w6, .Lctrfirst /* 1st time around? */	272	cbz w6, .Lctrnotfirst /* 1st time around? */
271	umov x5, v4.d[1] /* keep swabbed ctr in reg */
272	rev x5, x5
273	#if INTERLEAVE >= 2
274	cmn w5, w4 /* 32 bit overflow? */
275	bcs .Lctrinc
276	add x5, x5, #1 /* increment BE ctr */
277	b .LctrincNx
278	#else
279	b .Lctrinc
280	#endif
281	.Lctrfirst:
282	enc_prepare w3, x2, x6	273	enc_prepare w3, x2, x6
283	ld1 {v4.16b}, [x5]	274	ld1 {v4.16b}, [x5]
284	umov x5, v4.d[1] /* keep swabbed ctr in reg */	275
285	rev x5, x5	276	.Lctrnotfirst:
		277	umov x8, v4.d[1] /* keep swabbed ctr in reg */
		278	rev x8, x8
286	#if INTERLEAVE >= 2	279	#if INTERLEAVE >= 2
287	cmn w5, w4 /* 32 bit overflow? */	280	cmn w8, w4 /* 32 bit overflow? */
288	bcs .Lctrloop	281	bcs .Lctrloop
289	.LctrloopNx:	282	.LctrloopNx:
290	subs w4, w4, #INTERLEAVE	283	subs w4, w4, #INTERLEAVE
@@ -292,11 +285,11 @@ AES_ENTRY(aes_ctr_encrypt) · 1 unmodified line
292	#if INTERLEAVE == 2	285	#if INTERLEAVE == 2
293	mov v0.8b, v4.8b	286	mov v0.8b, v4.8b
294	mov v1.8b, v4.8b	287	mov v1.8b, v4.8b
295	rev x7, x5	288	rev x7, x8
296	add x5, x5, #1	289	add x8, x8, #1
297	ins v0.d[1], x7	290	ins v0.d[1], x7
298	rev x7, x5	291	rev x7, x8
299	add x5, x5, #1	292	add x8, x8, #1
300	ins v1.d[1], x7	293	ins v1.d[1], x7
301	ld1 {v2.16b-v3.16b}, [x1], #32 /* get 2 input blocks */	294	ld1 {v2.16b-v3.16b}, [x1], #32 /* get 2 input blocks */
302	do_encrypt_block2x	295	do_encrypt_block2x
@@ -305,7 +298,7 @@ AES_ENTRY(aes_ctr_encrypt) · 2 unmodified lines
305	st1 {v0.16b-v1.16b}, [x0], #32	298	st1 {v0.16b-v1.16b}, [x0], #32
306	#else	299	#else
307	ldr q8, =0x30000000200000001 /* addends 1,2,3[,0] */	300	ldr q8, =0x30000000200000001 /* addends 1,2,3[,0] */
308	dup v7.4s, w5	301	dup v7.4s, w8
309	mov v0.16b, v4.16b	302	mov v0.16b, v4.16b
310	add v7.4s, v7.4s, v8.4s	303	add v7.4s, v7.4s, v8.4s
311	mov v1.16b, v4.16b	304	mov v1.16b, v4.16b
@@ -323,18 +316,12 @@ AES_ENTRY(aes_ctr_encrypt) · 11 unmodified lines
323	eor v2.16b, v7.16b, v2.16b	316	eor v2.16b, v7.16b, v2.16b
324	eor v3.16b, v5.16b, v3.16b	317	eor v3.16b, v5.16b, v3.16b
325	st1 {v0.16b-v3.16b}, [x0], #64	318	st1 {v0.16b-v3.16b}, [x0], #64
326	add x5, x5, #INTERLEAVE	319	add x8, x8, #INTERLEAVE
327	#endif	320	#endif
328	cbz w4, .LctroutNx	321	rev x7, x8
329	.LctrincNx:
330	rev x7, x5
331	ins v4.d[1], x7	322	ins v4.d[1], x7
		323	cbz w4, .Lctrout
332	b .LctrloopNx	324	b .LctrloopNx
333	.LctroutNx:
334	sub x5, x5, #1
335	rev x7, x5
336	ins v4.d[1], x7
337	b .Lctrout
338	.Lctr1x:	325	.Lctr1x:
339	adds w4, w4, #INTERLEAVE	326	adds w4, w4, #INTERLEAVE
340	beq .Lctrout	327	beq .Lctrout
@@ -342,30 +329,39 @@ AES_ENTRY(aes_ctr_encrypt) · 1 unmodified line
342	.Lctrloop:	329	.Lctrloop:
343	mov v0.16b, v4.16b	330	mov v0.16b, v4.16b
344	encrypt_block v0, w3, x2, x6, w7	331	encrypt_block v0, w3, x2, x6, w7
		332
		333	adds x8, x8, #1 /* increment BE ctr */
		334	rev x7, x8
		335	ins v4.d[1], x7
		336	bcs .Lctrcarry /* overflow? */
		337
		338	.Lctrcarrydone:
345	subs w4, w4, #1	339	subs w4, w4, #1
346	bmi .Lctrhalfblock /* blocks < 0 means 1/2 block */	340	bmi .Lctrhalfblock /* blocks < 0 means 1/2 block */
347	ld1 {v3.16b}, [x1], #16	341	ld1 {v3.16b}, [x1], #16
348	eor v3.16b, v0.16b, v3.16b	342	eor v3.16b, v0.16b, v3.16b
349	st1 {v3.16b}, [x0], #16	343	st1 {v3.16b}, [x0], #16
350	beq .Lctrout	344	bne .Lctrloop
351	.Lctrinc:	345
352	adds x5, x5, #1 /* increment BE ctr */	346	.Lctrout:
353	rev x7, x5	347	st1 {v4.16b}, [x5] /* return next CTR value */
354	ins v4.d[1], x7	348	FRAME_POP
355	bcc .Lctrloop /* no overflow? */	349	ret
356	umov x7, v4.d[0] /* load upper word of ctr */	350
357	rev x7, x7 /* ... to handle the carry */
358	add x7, x7, #1
359	rev x7, x7
360	ins v4.d[0], x7
361	b .Lctrloop
362	.Lctrhalfblock:	351	.Lctrhalfblock:
363	ld1 {v3.8b}, [x1]	352	ld1 {v3.8b}, [x1]
364	eor v3.8b, v0.8b, v3.8b	353	eor v3.8b, v0.8b, v3.8b
365	st1 {v3.8b}, [x0]	354	st1 {v3.8b}, [x0]
366	.Lctrout:
367	FRAME_POP	355	FRAME_POP
368	ret	356	ret
		357
		358	.Lctrcarry:
		359	umov x7, v4.d[0] /* load upper word of ctr */
		360	rev x7, x7 /* ... to handle the carry */
		361	add x7, x7, #1
		362	rev x7, x7
		363	ins v4.d[0], x7
		364	b .Lctrcarrydone
369	AES_ENDPROC(aes_ctr_encrypt)	365	AES_ENDPROC(aes_ctr_encrypt)
370	.ltorg	366	.ltorg
371		367

arch/powerpc/Kconfig+1−1

 	select ARCH_HAS_SCALED_CPUTIME if VIRT_CPU_ACCOUNTING_NATIVE
 	select HAVE_ARCH_HARDENED_USERCOPY
 	select HAVE_KERNEL_GZIP
-	select HAVE_CC_STACKPROTECTOR
 config GENERIC_CSUM
 	def_bool CPU_LITTLE_ENDIAN
 	bool "Build a relocatable kernel"
 	depends on (PPC64 && !COMPILE_TEST) || (FLATMEM && (44x || FSL_BOOKE))
 	select NONSTATIC_KERNEL
+	select MODULE_REL_CRCS if MODVERSIONS
 	help
 	  This builds a kernel image that is capable of running at the
 	  location the kernel is loaded at. For ppc32, there is no any

arch/powerpc/include/asm/cpu_has_feature.h+2−0

@@ -23,7 +23,9 @@ static __always_inline bool cpu_has_feature(unsigned long feature) · 22 unmodified lines
23	{	23	{
24	int i;	24	int i;
25		25
		26	#ifndef __clang__ /* clang can't cope with this */
26	BUILD_BUG_ON(!__builtin_constant_p(feature));	27	BUILD_BUG_ON(!__builtin_constant_p(feature));
		28	#endif
27		29
28	#ifdef CONFIG_JUMP_LABEL_FEATURE_CHECK_DEBUG	30	#ifdef CONFIG_JUMP_LABEL_FEATURE_CHECK_DEBUG
29	if (!static_key_initialized) {	31	if (!static_key_initialized) {

arch/powerpc/include/asm/mmu.h+2−0

@@ -160,7 +160,9 @@ static __always_inline bool mmu_has_feature(unsigned long feature) · 159 unmodified lines
160	{	160	{
161	int i;	161	int i;
162		162
		163	#ifndef __clang__ /* clang can't cope with this */
163	BUILD_BUG_ON(!__builtin_constant_p(feature));	164	BUILD_BUG_ON(!__builtin_constant_p(feature));
		165	#endif
164		166
165	#ifdef CONFIG_JUMP_LABEL_FEATURE_CHECK_DEBUG	167	#ifdef CONFIG_JUMP_LABEL_FEATURE_CHECK_DEBUG
166	if (!static_key_initialized) {	168	if (!static_key_initialized) {

arch/powerpc/include/asm/module.h+0−4

 }
 #endif
-#if defined(CONFIG_MODVERSIONS) && defined(CONFIG_PPC64)
-#define ARCH_RELOCATES_KCRCTAB
-#define reloc_start PHYSICAL_START
-#endif
 #endif /* __KERNEL__ */
 #endif	/* _ASM_POWERPC_MODULE_H */

arch/powerpc/include/asm/stackprotector.h+0−40

@@ -1,40 +0,0 @@
1	/*
2	* GCC stack protector support.
3	*
4	* Stack protector works by putting predefined pattern at the start of
5	* the stack frame and verifying that it hasn't been overwritten when
6	* returning from the function. The pattern is called stack canary
7	* and gcc expects it to be defined by a global variable called
8	* "__stack_chk_guard" on PPC. This unfortunately means that on SMP
9	* we cannot have a different canary value per task.
10	*/
11
12	#ifndef _ASM_STACKPROTECTOR_H
13	#define _ASM_STACKPROTECTOR_H
14
15	#include <linux/random.h>
16	#include <linux/version.h>
17	#include <asm/reg.h>
18
19	extern unsigned long __stack_chk_guard;
20
21	/*
22	* Initialize the stackprotector canary value.
23	*
24	* NOTE: this must only be called from functions that never return,
25	* and it must always be inlined.
26	*/
27	static __always_inline void boot_init_stack_canary(void)
28	{
29	unsigned long canary;
30
31	/* Try to get a semi random initial value. */
32	get_random_bytes(&canary, sizeof(canary));
33	canary ^= mftb();
34	canary ^= LINUX_VERSION_CODE;
35
36	current->stack_canary = canary;
37	__stack_chk_guard = current->stack_canary;
38	}
39
40	#endif /* _ASM_STACKPROTECTOR_H */

arch/powerpc/kernel/Makefile+0−4

 CFLAGS_btext.o += $(DISABLE_LATENT_ENTROPY_PLUGIN)
 CFLAGS_prom.o += $(DISABLE_LATENT_ENTROPY_PLUGIN)
-# -fstack-protector triggers protection checks in this code,
-# but it is being used too early to link to meaningful stack_chk logic.
-CFLAGS_prom_init.o += $(call cc-option, -fno-stack-protector)
 ifdef CONFIG_FUNCTION_TRACER
 # Do not trace early boot code
 CFLAGS_REMOVE_cputable.o = -mno-sched-epilog $(CC_FLAGS_FTRACE)

arch/powerpc/kernel/asm-offsets.c+0−3

 	DEFINE(TI_livepatch_sp, offsetof(struct thread_info, livepatch_sp));
 #endif
-#ifdef CONFIG_CC_STACKPROTECTOR
-	DEFINE(TSK_STACK_CANARY, offsetof(struct task_struct, stack_canary));
-#endif
 	DEFINE(KSP, offsetof(struct thread_struct, ksp));
 	DEFINE(PT_REGS, offsetof(struct thread_struct, regs));
 #ifdef CONFIG_BOOKE

arch/powerpc/kernel/eeh_driver.c+1−1

@@ -545,7 +545,7 @@ static void eeh_pe_detach_dev(void data, void *userdata) · 544 unmodified lines
545	static void __eeh_clear_pe_frozen_state(void data, void *flag)	545	static void __eeh_clear_pe_frozen_state(void data, void *flag)
546	{	546	{
547	struct eeh_pe pe = (struct eeh_pe )data;	547	struct eeh_pe pe = (struct eeh_pe )data;
548	bool *clear_sw_state = flag;	548	bool clear_sw_state = (bool )flag;
549	int i, rc = 1;	549	int i, rc = 1;
550		550
551	for (i = 0; rc && i < 3; i++)	551	for (i = 0; rc && i < 3; i++)

arch/powerpc/kernel/entry_32.S+1−5

@@ -674,11 +674,7 @@ BEGIN_FTR_SECTION · 673 unmodified lines
674	mtspr SPRN_SPEFSCR,r0 /* restore SPEFSCR reg */	674	mtspr SPRN_SPEFSCR,r0 /* restore SPEFSCR reg */
675	END_FTR_SECTION_IFSET(CPU_FTR_SPE)	675	END_FTR_SECTION_IFSET(CPU_FTR_SPE)
676	#endif /* CONFIG_SPE */	676	#endif /* CONFIG_SPE */
677	#if defined(CONFIG_CC_STACKPROTECTOR) && !defined(CONFIG_SMP)	677
678	lwz r0,TSK_STACK_CANARY(r2)
679	lis r4,__stack_chk_guard@ha
680	stw r0,__stack_chk_guard@l(r4)
681	#endif
682	lwz r0,_CCR(r1)	678	lwz r0,_CCR(r1)
683	mtcrf 0xFF,r0	679	mtcrf 0xFF,r0
684	/* r3-r12 are destroyed -- Cort */	680	/* r3-r12 are destroyed -- Cort */

arch/powerpc/kernel/module_64.c+0−8

@@ -286,14 +286,6 @@ static void dedotify_versions(struct modversion_info *vers, · 285 unmodified lines
286	for (end = (void *)vers + size; vers < end; vers++)	286	for (end = (void *)vers + size; vers < end; vers++)
287	if (vers->name[0] == '.') {	287	if (vers->name[0] == '.') {
288	memmove(vers->name, vers->name+1, strlen(vers->name));	288	memmove(vers->name, vers->name+1, strlen(vers->name));
289	#ifdef ARCH_RELOCATES_KCRCTAB
290	/* The TOC symbol has no CRC computed. To avoid CRC
291	* check failing, we must force it to the expected
292	* value (see CRC check in module.c).
293	*/
294	if (!strcmp(vers->name, "TOC."))
295	vers->crc = -(unsigned long)reloc_start;
296	#endif
297	}	289	}
298	}	290	}
299		291

arch/powerpc/kernel/process.c+0−6

 #include <linux/kprobes.h>
 #include <linux/kdebug.h>
-#ifdef CONFIG_CC_STACKPROTECTOR
-#include <linux/stackprotector.h>
-unsigned long __stack_chk_guard __read_mostly;
-EXPORT_SYMBOL(__stack_chk_guard);
-#endif
 /* Transactional Memory debug */
 #ifdef TM_DEBUG_SW
 #define TM_DEBUG(x...) printk(KERN_INFO x)

arch/powerpc/kernel/prom_init.c+3−0

@@ -2834,6 +2834,9 @@ static void __init prom_find_boot_cpu(void) · 2833 unmodified lines
2834		2834
2835	cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);	2835	cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
2836		2836
		2837	if (!PHANDLE_VALID(cpu_pkg))
		2838	return;
		2839
2837	prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval));	2840	prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval));
2838	prom.cpu = be32_to_cpu(rval);	2841	prom.cpu = be32_to_cpu(rval);
2839		2842

arch/powerpc/mm/pgtable-radix.c+2−2

@@ -65,7 +65,7 @@ int radix__map_kernel_page(unsigned long ea, unsigned long pa, · 64 unmodified lines
65	if (!pmdp)	65	if (!pmdp)
66	return -ENOMEM;	66	return -ENOMEM;
67	if (map_page_size == PMD_SIZE) {	67	if (map_page_size == PMD_SIZE) {
68	ptep = (pte_t *)pudp;	68	ptep = pmdp_ptep(pmdp);
69	goto set_the_pte;	69	goto set_the_pte;
70	}	70	}
71	ptep = pte_alloc_kernel(pmdp, ea);	71	ptep = pte_alloc_kernel(pmdp, ea);
@@ -90,7 +90,7 @@ int radix__map_kernel_page(unsigned long ea, unsigned long pa, · 18 unmodified lines
90	}	90	}
91	pmdp = pmd_offset(pudp, ea);	91	pmdp = pmd_offset(pudp, ea);
92	if (map_page_size == PMD_SIZE) {	92	if (map_page_size == PMD_SIZE) {
93	ptep = (pte_t *)pudp;	93	ptep = pmdp_ptep(pmdp);
94	goto set_the_pte;	94	goto set_the_pte;
95	}	95	}
96	if (!pmd_present(*pmdp)) {	96	if (!pmd_present(*pmdp)) {

arch/sparc/include/asm/mmu_context_64.h+4−4

@@ -35,15 +35,15 @@ void __tsb_context_switch(unsigned long pgd_pa, · 34 unmodified lines
35	static inline void tsb_context_switch(struct mm_struct *mm)	35	static inline void tsb_context_switch(struct mm_struct *mm)
36	{	36	{
37	__tsb_context_switch(__pa(mm->pgd),	37	__tsb_context_switch(__pa(mm->pgd),
38	&mm->context.tsb_block[0],	38	&mm->context.tsb_block[MM_TSB_BASE],
39	#if defined(CONFIG_HUGETLB_PAGE) \|\| defined(CONFIG_TRANSPARENT_HUGEPAGE)	39	#if defined(CONFIG_HUGETLB_PAGE) \|\| defined(CONFIG_TRANSPARENT_HUGEPAGE)
40	(mm->context.tsb_block[1].tsb ?	40	(mm->context.tsb_block[MM_TSB_HUGE].tsb ?
41	&mm->context.tsb_block[1] :	41	&mm->context.tsb_block[MM_TSB_HUGE] :
42	NULL)	42	NULL)
43	#else	43	#else
44	NULL	44	NULL
45	#endif	45	#endif
46	, __pa(&mm->context.tsb_descr[0]));	46	, __pa(&mm->context.tsb_descr[MM_TSB_BASE]));
47	}	47	}
48		48
49	void tsb_grow(struct mm_struct *mm,	49	void tsb_grow(struct mm_struct *mm,

arch/sparc/kernel/irq_64.c+1−1

@@ -1021,7 +1021,7 @@ static void __init alloc_one_queue(unsigned long *pa_ptr, unsigned long qmask) · 1020 unmodified lines
1021	unsigned long order = get_order(size);	1021	unsigned long order = get_order(size);
1022	unsigned long p;	1022	unsigned long p;
1023		1023
1024	p = __get_free_pages(GFP_KERNEL, order);	1024	p = __get_free_pages(GFP_KERNEL \| __GFP_ZERO, order);
1025	if (!p) {	1025	if (!p) {
1026	prom_printf("SUN4V: Error, cannot allocate queue.\n");	1026	prom_printf("SUN4V: Error, cannot allocate queue.\n");
1027	prom_halt();	1027	prom_halt();

arch/sparc/kernel/sstate.c+3−3

@@ -43,8 +43,8 @@ static const char poweroff_msg[32] __attribute__((aligned(32))) = · 42 unmodified lines
43	"Linux powering off";	43	"Linux powering off";
44	static const char rebooting_msg[32] __attribute__((aligned(32))) =	44	static const char rebooting_msg[32] __attribute__((aligned(32))) =
45	"Linux rebooting";	45	"Linux rebooting";
46	static const char panicing_msg[32] __attribute__((aligned(32))) =	46	static const char panicking_msg[32] __attribute__((aligned(32))) =
47	"Linux panicing";	47	"Linux panicking";
48		48
49	static int sstate_reboot_call(struct notifier_block np, unsigned long type, void _unused)	49	static int sstate_reboot_call(struct notifier_block np, unsigned long type, void _unused)
50	{	50	{
@@ -76,7 +76,7 @@ static struct notifier_block sstate_reboot_notifier = { · 25 unmodified lines
76		76
77	static int sstate_panic_event(struct notifier_block n, unsigned long event, void ptr)	77	static int sstate_panic_event(struct notifier_block n, unsigned long event, void ptr)
78	{	78	{
79	do_set_sstate(HV_SOFT_STATE_TRANSITION, panicing_msg);	79	do_set_sstate(HV_SOFT_STATE_TRANSITION, panicking_msg);
80		80
81	return NOTIFY_DONE;	81	return NOTIFY_DONE;
82	}	82	}

arch/sparc/kernel/traps_64.c+73−0

@@ -2051,6 +2051,73 @@ void sun4v_resum_overflow(struct pt_regs *regs) · 2050 unmodified lines
2051	atomic_inc(&sun4v_resum_oflow_cnt);	2051	atomic_inc(&sun4v_resum_oflow_cnt);
2052	}	2052	}
2053		2053
		2054	/* Given a set of registers, get the virtual addressi that was being accessed
		2055	* by the faulting instructions at tpc.
		2056	*/
		2057	static unsigned long sun4v_get_vaddr(struct pt_regs *regs)
		2058	{
		2059	unsigned int insn;
		2060
		2061	if (!copy_from_user(&insn, (void __user *)regs->tpc, 4)) {
		2062	return compute_effective_address(regs, insn,
		2063	(insn >> 25) & 0x1f);
		2064	}
		2065	return 0;
		2066	}
		2067
		2068	/* Attempt to handle non-resumable errors generated from userspace.
		2069	* Returns true if the signal was handled, false otherwise.
		2070	*/
		2071	bool sun4v_nonresum_error_user_handled(struct pt_regs *regs,
		2072	struct sun4v_error_entry *ent) {
		2073
		2074	unsigned int attrs = ent->err_attrs;
		2075
		2076	if (attrs & SUN4V_ERR_ATTRS_MEMORY) {
		2077	unsigned long addr = ent->err_raddr;
		2078	siginfo_t info;
		2079
		2080	if (addr == ~(u64)0) {
		2081	/* This seems highly unlikely to ever occur */
		2082	pr_emerg("SUN4V NON-RECOVERABLE ERROR: Memory error detected in unknown location!\n");
		2083	} else {
		2084	unsigned long page_cnt = DIV_ROUND_UP(ent->err_size,
		2085	PAGE_SIZE);
		2086
		2087	/* Break the unfortunate news. */
		2088	pr_emerg("SUN4V NON-RECOVERABLE ERROR: Memory failed at %016lX\n",
		2089	addr);
		2090	pr_emerg("SUN4V NON-RECOVERABLE ERROR: Claiming %lu ages.\n",
		2091	page_cnt);
		2092
		2093	while (page_cnt-- > 0) {
		2094	if (pfn_valid(addr >> PAGE_SHIFT))
		2095	get_page(pfn_to_page(addr >> PAGE_SHIFT));
		2096	addr += PAGE_SIZE;
		2097	}
		2098	}
		2099	info.si_signo = SIGKILL;
		2100	info.si_errno = 0;
		2101	info.si_trapno = 0;
		2102	force_sig_info(info.si_signo, &info, current);
		2103
		2104	return true;
		2105	}
		2106	if (attrs & SUN4V_ERR_ATTRS_PIO) {
		2107	siginfo_t info;
		2108
		2109	info.si_signo = SIGBUS;
		2110	info.si_code = BUS_ADRERR;
		2111	info.si_addr = (void __user *)sun4v_get_vaddr(regs);
		2112	force_sig_info(info.si_signo, &info, current);
		2113
		2114	return true;
		2115	}
		2116
		2117	/* Default to doing nothing */
		2118	return false;
		2119	}
		2120
2054	/* We run with %pil set to PIL_NORMAL_MAX and PSTATE_IE enabled in %pstate.	2121	/* We run with %pil set to PIL_NORMAL_MAX and PSTATE_IE enabled in %pstate.
2055	* Log the event, clear the first word of the entry, and die.	2122	* Log the event, clear the first word of the entry, and die.
2056	*/	2123	*/
@@ -2075,6 +2142,12 @@ void sun4v_nonresum_error(struct pt_regs *regs, unsigned long offset) · 18 unmodified lines
2075		2142
2076	put_cpu();	2143	put_cpu();
2077		2144
		2145	if (!(regs->tstate & TSTATE_PRIV) &&
		2146	sun4v_nonresum_error_user_handled(regs, &local_copy)) {
		2147	/* DON'T PANIC: This userspace error was handled. */
		2148	return;
		2149	}
		2150
2078	#ifdef CONFIG_PCI	2151	#ifdef CONFIG_PCI
2079	/* Check for the special PCI poke sequence. */	2152	/* Check for the special PCI poke sequence. */
2080	if (pci_poke_in_progress && pci_poke_cpu == cpu) {	2153	if (pci_poke_in_progress && pci_poke_cpu == cpu) {

arch/x86/events/intel/rapl.c+26−34

 static inline struct rapl_pmu *cpu_to_rapl_pmu(unsigned int cpu)
 {
-	return rapl_pmus->pmus[topology_logical_package_id(cpu)];
+	unsigned int pkgid = topology_logical_package_id(cpu);
+	/*
+	 * The unsigned check also catches the '-1' return value for non
+	 * existent mappings in the topology map.
+	 */
+	return pkgid < rapl_pmus->maxpkg ? rapl_pmus->pmus[pkgid] : NULL;
 }
 static inline u64 rapl_read_counter(struct perf_event *event)
 	/* must be done before validate_group */
 	pmu = cpu_to_rapl_pmu(event->cpu);
+	if (!pmu)
+		return -EINVAL;
 	event->cpu = pmu->cpu;
 	event->pmu_private = pmu;
 	event->hw.event_base = msr;
 	struct rapl_pmu *pmu = cpu_to_rapl_pmu(cpu);
 	int target;
+	if (!pmu) {
+		pmu = kzalloc_node(sizeof(*pmu), GFP_KERNEL, cpu_to_node(cpu));
+		if (!pmu)
+			return -ENOMEM;
+		raw_spin_lock_init(&pmu->lock);
+		INIT_LIST_HEAD(&pmu->active_list);
+		pmu->pmu = &rapl_pmus->pmu;
+		pmu->timer_interval = ms_to_ktime(rapl_timer_ms);
+		rapl_hrtimer_init(pmu);
+		rapl_pmus->pmus[topology_logical_package_id(cpu)] = pmu;
+	}
 	/*
 	 * Check if there is an online cpu in the package which collects rapl
 	 * events already.
 	return 0;
 }
-static int rapl_cpu_prepare(unsigned int cpu)
-{
-	struct rapl_pmu *pmu = cpu_to_rapl_pmu(cpu);
-	if (pmu)
-		return 0;
-	pmu = kzalloc_node(sizeof(*pmu), GFP_KERNEL, cpu_to_node(cpu));
-	if (!pmu)
-		return -ENOMEM;
-	raw_spin_lock_init(&pmu->lock);
-	INIT_LIST_HEAD(&pmu->active_list);
-	pmu->pmu = &rapl_pmus->pmu;
-	pmu->timer_interval = ms_to_ktime(rapl_timer_ms);
-	pmu->cpu = -1;
-	rapl_hrtimer_init(pmu);
-	rapl_pmus->pmus[topology_logical_package_id(cpu)] = pmu;
-	return 0;
-}
 static int rapl_check_hw_unit(bool apply_quirk)
 {
 	u64 msr_rapl_power_unit_bits;
 	/*
 	 * Install callbacks. Core will call them for each online cpu.
 	 */
-	ret = cpuhp_setup_state(CPUHP_PERF_X86_RAPL_PREP, "perf/x86/rapl:prepare",
-				rapl_cpu_prepare, NULL);
-	if (ret)
-		goto out;
 	ret = cpuhp_setup_state(CPUHP_AP_PERF_X86_RAPL_ONLINE,
 				"perf/x86/rapl:online",
 				rapl_cpu_online, rapl_cpu_offline);
 	if (ret)
-		goto out1;
+		goto out;
 	ret = perf_pmu_register(&rapl_pmus->pmu, "power", -1);
 	if (ret)
-		goto out2;
+		goto out1;
 	rapl_advertise();
 	return 0;
-out2:
-	cpuhp_remove_state(CPUHP_AP_PERF_X86_RAPL_ONLINE);
 out1:
-	cpuhp_remove_state(CPUHP_PERF_X86_RAPL_PREP);
+	cpuhp_remove_state(CPUHP_AP_PERF_X86_RAPL_ONLINE);
 out:
 	pr_warn("Initialization failed (%d), disabled\n", ret);
 	cleanup_rapl_pmus();
 static void __exit intel_rapl_exit(void)
 {
 	cpuhp_remove_state_nocalls(CPUHP_AP_PERF_X86_RAPL_ONLINE);
-	cpuhp_remove_state_nocalls(CPUHP_PERF_X86_RAPL_PREP);
 	perf_pmu_unregister(&rapl_pmus->pmu);
 	cleanup_rapl_pmus();
 }

arch/x86/events/intel/uncore.c+91−141

 struct intel_uncore_box *uncore_pmu_to_box(struct intel_uncore_pmu *pmu, int cpu)
 {
-	return pmu->boxes[topology_logical_package_id(cpu)];
+	unsigned int pkgid = topology_logical_package_id(cpu);
+	/*
+	 * The unsigned check also catches the '-1' return value for non
+	 * existent mappings in the topology map.
+	 */
+	return pkgid < max_packages ? pmu->boxes[pkgid] : NULL;
 }
 u64 uncore_msr_read_counter(struct intel_uncore_box *box, struct perf_event *event)
 	pmu->registered = false;
 }
-static void __uncore_exit_boxes(struct intel_uncore_type *type, int cpu)
-{
-	struct intel_uncore_pmu *pmu = type->pmus;
-	struct intel_uncore_box *box;
-	int i, pkg;
-	if (pmu) {
-		pkg = topology_physical_package_id(cpu);
-		for (i = 0; i < type->num_boxes; i++, pmu++) {
-			box = pmu->boxes[pkg];
-			if (box)
-				uncore_box_exit(box);
-		}
-	}
-}
-static void uncore_exit_boxes(void *dummy)
-{
-	struct intel_uncore_type **types;
-	for (types = uncore_msr_uncores; *types; types++)
-		__uncore_exit_boxes(*types++, smp_processor_id());
-}
 static void uncore_free_boxes(struct intel_uncore_pmu *pmu)
 {
 	int pkg;
 	}
 }
-static int uncore_cpu_dying(unsigned int cpu)
-{
-	struct intel_uncore_type *type, **types = uncore_msr_uncores;
-	struct intel_uncore_pmu *pmu;
-	struct intel_uncore_box *box;
-	int i, pkg;
-	pkg = topology_logical_package_id(cpu);
-	for (; *types; types++) {
-		type = *types;
-		pmu = type->pmus;
-		for (i = 0; i < type->num_boxes; i++, pmu++) {
-			box = pmu->boxes[pkg];
-			if (box && atomic_dec_return(&box->refcnt) == 0)
-				uncore_box_exit(box);
-		}
-	}
-	return 0;
-}
-static int first_init;
-static int uncore_cpu_starting(unsigned int cpu)
-{
-	struct intel_uncore_type *type, **types = uncore_msr_uncores;
-	struct intel_uncore_pmu *pmu;
-	struct intel_uncore_box *box;
-	int i, pkg, ncpus = 1;
-	if (first_init) {
-		/*
-		 * On init we get the number of online cpus in the package
-		 * and set refcount for all of them.
-		 */
-		ncpus = cpumask_weight(topology_core_cpumask(cpu));
-	}
-	pkg = topology_logical_package_id(cpu);
-	for (; *types; types++) {
-		type = *types;
-		pmu = type->pmus;
-		for (i = 0; i < type->num_boxes; i++, pmu++) {
-			box = pmu->boxes[pkg];
-			if (!box)
-				continue;
-			/* The first cpu on a package activates the box */
-			if (atomic_add_return(ncpus, &box->refcnt) == ncpus)
-				uncore_box_init(box);
-		}
-	}
-	return 0;
-}
-static int uncore_cpu_prepare(unsigned int cpu)
-{
-	struct intel_uncore_type *type, **types = uncore_msr_uncores;
-	struct intel_uncore_pmu *pmu;
-	struct intel_uncore_box *box;
-	int i, pkg;
-	pkg = topology_logical_package_id(cpu);
-	for (; *types; types++) {
-		type = *types;
-		pmu = type->pmus;
-		for (i = 0; i < type->num_boxes; i++, pmu++) {
-			if (pmu->boxes[pkg])
-				continue;
-			/* First cpu of a package allocates the box */
-			box = uncore_alloc_box(type, cpu_to_node(cpu));
-			if (!box)
-				return -ENOMEM;
-			box->pmu = pmu;
-			box->pkgid = pkg;
-			pmu->boxes[pkg] = box;
-		}
-	}
-	return 0;
-}
 static void uncore_change_type_ctx(struct intel_uncore_type *type, int old_cpu,
 				   int new_cpu)
 {
 static int uncore_event_cpu_offline(unsigned int cpu)
 {
-	int target;
+	struct intel_uncore_type *type, **types = uncore_msr_uncores;
+	struct intel_uncore_pmu *pmu;
+	struct intel_uncore_box *box;
+	int i, pkg, target;
 	/* Check if exiting cpu is used for collecting uncore events */
 	if (!cpumask_test_and_clear_cpu(cpu, &uncore_cpu_mask))
-		return 0;
+		goto unref;
 	/* Find a new cpu to collect uncore events */
 	target = cpumask_any_but(topology_core_cpumask(cpu), cpu);
 	uncore_change_context(uncore_msr_uncores, cpu, target);
 	uncore_change_context(uncore_pci_uncores, cpu, target);
+unref:
+	/* Clear the references */
+	pkg = topology_logical_package_id(cpu);
+	for (; *types; types++) {
+		type = *types;
+		pmu = type->pmus;
+		for (i = 0; i < type->num_boxes; i++, pmu++) {
+			box = pmu->boxes[pkg];
+			if (box && atomic_dec_return(&box->refcnt) == 0)
+				uncore_box_exit(box);
+		}
+	}
 	return 0;
 }
+static int allocate_boxes(struct intel_uncore_type **types,
+			 unsigned int pkg, unsigned int cpu)
+{
+	struct intel_uncore_box *box, *tmp;
+	struct intel_uncore_type *type;
+	struct intel_uncore_pmu *pmu;
+	LIST_HEAD(allocated);
+	int i;
+	/* Try to allocate all required boxes */
+	for (; *types; types++) {
+		type = *types;
+		pmu = type->pmus;
+		for (i = 0; i < type->num_boxes; i++, pmu++) {
+			if (pmu->boxes[pkg])
+				continue;
+			box = uncore_alloc_box(type, cpu_to_node(cpu));
+			if (!box)
+				goto cleanup;
+			box->pmu = pmu;
+			box->pkgid = pkg;
+			list_add(&box->active_list, &allocated);
+		}
+	}
+	/* Install them in the pmus */
+	list_for_each_entry_safe(box, tmp, &allocated, active_list) {
+		list_del_init(&box->active_list);
+		box->pmu->boxes[pkg] = box;
+	}
+	return 0;
+cleanup:
+	list_for_each_entry_safe(box, tmp, &allocated, active_list) {
+		list_del_init(&box->active_list);
+		kfree(box);
+	}
+	return -ENOMEM;
+}
 static int uncore_event_cpu_online(unsigned int cpu)
 {
-	int target;
+	struct intel_uncore_type *type, **types = uncore_msr_uncores;
+	struct intel_uncore_pmu *pmu;
+	struct intel_uncore_box *box;
+	int i, ret, pkg, target;
+	pkg = topology_logical_package_id(cpu);
+	ret = allocate_boxes(types, pkg, cpu);
+	if (ret)
+		return ret;
+	for (; *types; types++) {
+		type = *types;
+		pmu = type->pmus;
+		for (i = 0; i < type->num_boxes; i++, pmu++) {
+			box = pmu->boxes[pkg];
+			if (!box && atomic_inc_return(&box->refcnt) == 1)
+				uncore_box_init(box);
+		}
+	}
 	/*
 	 * Check if there is an online cpu in the package
 	if (cret && pret)
 		return -ENODEV;
-	/*
+	/* Install hotplug callbacks to setup the targets for each package */
-	 * Install callbacks. Core will call them for each online cpu.
+	ret = cpuhp_setup_state(CPUHP_AP_PERF_X86_UNCORE_ONLINE,
-	 *
+				"perf/x86/intel/uncore:online",
-	 * The first online cpu of each package allocates and takes
+				uncore_event_cpu_online,
-	 * the refcounts for all other online cpus in that package.
+				uncore_event_cpu_offline);
-	 * If msrs are not enabled no allocation is required and
+	if (ret)
-	 * uncore_cpu_prepare() is not called for each online cpu.
+		goto err;
-	 */
-	if (!cret) {
-	       ret = cpuhp_setup_state(CPUHP_PERF_X86_UNCORE_PREP,
-				       "perf/x86/intel/uncore:prepare",
-				       uncore_cpu_prepare, NULL);
-		if (ret)
-			goto err;
-	} else {
-		cpuhp_setup_state_nocalls(CPUHP_PERF_X86_UNCORE_PREP,
-					  "perf/x86/intel/uncore:prepare",
-					  uncore_cpu_prepare, NULL);
-	}
-	first_init = 1;
-	cpuhp_setup_state(CPUHP_AP_PERF_X86_UNCORE_STARTING,
-			  "perf/x86/uncore:starting",
-			  uncore_cpu_starting, uncore_cpu_dying);
-	first_init = 0;
-	cpuhp_setup_state(CPUHP_AP_PERF_X86_UNCORE_ONLINE,
-			  "perf/x86/uncore:online",
-			  uncore_event_cpu_online, uncore_event_cpu_offline);
 	return 0;
 err:
-	/* Undo box->init_box() */
-	on_each_cpu_mask(&uncore_cpu_mask, uncore_exit_boxes, NULL, 1);
 	uncore_types_exit(uncore_msr_uncores);
 	uncore_pci_exit();
 	return ret;
 static void __exit intel_uncore_exit(void)
 {
-	cpuhp_remove_state_nocalls(CPUHP_AP_PERF_X86_UNCORE_ONLINE);
+	cpuhp_remove_state(CPUHP_AP_PERF_X86_UNCORE_ONLINE);
-	cpuhp_remove_state_nocalls(CPUHP_AP_PERF_X86_UNCORE_STARTING);
-	cpuhp_remove_state_nocalls(CPUHP_PERF_X86_UNCORE_PREP);
 	uncore_types_exit(uncore_msr_uncores);
 	uncore_pci_exit();
 }

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

@@ -140,6 +140,7 @@ extern void __init load_ucode_bsp(void); · 139 unmodified lines
140	extern void load_ucode_ap(void);	140	extern void load_ucode_ap(void);
141	void reload_early_microcode(void);	141	void reload_early_microcode(void);
142	extern bool get_builtin_firmware(struct cpio_data cd, const char name);	142	extern bool get_builtin_firmware(struct cpio_data cd, const char name);
		143	extern bool initrd_gone;
143	#else	144	#else
144	static inline int __init microcode_init(void) { return 0; };	145	static inline int __init microcode_init(void) { return 0; };
145	static inline void __init load_ucode_bsp(void) { }	146	static inline void __init load_ucode_bsp(void) { }

arch/x86/kernel/apic/io_apic.c+2−0

 			if (idx != -1 && irq_trigger(idx))
 				unmask_ioapic_irq(irq_get_chip_data(0));
 		}
+		irq_domain_deactivate_irq(irq_data);
 		irq_domain_activate_irq(irq_data);
 		if (timer_irq_works()) {
 			if (disable_timer_pin_1 > 0)
 		 * legacy devices should be connected to IO APIC #0
 		 */
 		replace_pin_at_irq_node(data, node, apic1, pin1, apic2, pin2);
+		irq_domain_deactivate_irq(irq_data);
 		irq_domain_activate_irq(irq_data);
 		legacy_pic->unmask(0);
 		if (timer_irq_works()) {

arch/x86/kernel/cpu/mcheck/mce.c+12−19

@@ -1373,20 +1373,15 @@ static unsigned long mce_adjust_timer_default(unsigned long interval) · 1372 unmodified lines
1373		1373
1374	static unsigned long (*mce_adjust_timer)(unsigned long interval) = mce_adjust_timer_default;	1374	static unsigned long (*mce_adjust_timer)(unsigned long interval) = mce_adjust_timer_default;
1375		1375
1376	static void __restart_timer(struct timer_list *t, unsigned long interval)	1376	static void __start_timer(struct timer_list *t, unsigned long interval)
1377	{	1377	{
1378	unsigned long when = jiffies + interval;	1378	unsigned long when = jiffies + interval;
1379	unsigned long flags;	1379	unsigned long flags;
1380		1380
1381	local_irq_save(flags);	1381	local_irq_save(flags);
1382		1382
1383	if (timer_pending(t)) {	1383	if (!timer_pending(t) \|\| time_before(when, t->expires))
1384	if (time_before(when, t->expires))	1384	mod_timer(t, round_jiffies(when));
1385	mod_timer(t, when);
1386	} else {
1387	t->expires = round_jiffies(when);
1388	add_timer_on(t, smp_processor_id());
1389	}
1390		1385
1391	local_irq_restore(flags);	1386	local_irq_restore(flags);
1392	}	1387	}
@@ -1421,7 +1416,7 @@ static void mce_timer_fn(unsigned long data) · 28 unmodified lines
1421		1416
1422	done:	1417	done:
1423	__this_cpu_write(mce_next_interval, iv);	1418	__this_cpu_write(mce_next_interval, iv);
1424	__restart_timer(t, iv);	1419	__start_timer(t, iv);
1425	}	1420	}
1426		1421
1427	/*	1422	/*
@@ -1432,7 +1427,7 @@ void mce_timer_kick(unsigned long interval) · 4 unmodified lines
1432	struct timer_list *t = this_cpu_ptr(&mce_timer);	1427	struct timer_list *t = this_cpu_ptr(&mce_timer);
1433	unsigned long iv = __this_cpu_read(mce_next_interval);	1428	unsigned long iv = __this_cpu_read(mce_next_interval);
1434		1429
1435	__restart_timer(t, interval);	1430	__start_timer(t, interval);
1436		1431
1437	if (interval < iv)	1432	if (interval < iv)
1438	__this_cpu_write(mce_next_interval, interval);	1433	__this_cpu_write(mce_next_interval, interval);
@@ -1779,17 +1774,15 @@ static void __mcheck_cpu_clear_vendor(struct cpuinfo_x86 *c) · 340 unmodified lines
1779	}	1774	}
1780	}	1775	}
1781		1776
1782	static void mce_start_timer(unsigned int cpu, struct timer_list *t)	1777	static void mce_start_timer(struct timer_list *t)
1783	{	1778	{
1784	unsigned long iv = check_interval * HZ;	1779	unsigned long iv = check_interval * HZ;
1785		1780
1786	if (mca_cfg.ignore_ce \|\| !iv)	1781	if (mca_cfg.ignore_ce \|\| !iv)
1787	return;	1782	return;
1788		1783
1789	per_cpu(mce_next_interval, cpu) = iv;	1784	this_cpu_write(mce_next_interval, iv);
1790		1785	__start_timer(t, iv);
1791	t->expires = round_jiffies(jiffies + iv);
1792	add_timer_on(t, cpu);
1793	}	1786	}
1794		1787
1795	static void __mcheck_cpu_setup_timer(void)	1788	static void __mcheck_cpu_setup_timer(void)
@@ -1806,7 +1799,7 @@ static void __mcheck_cpu_init_timer(void) · 10 unmodified lines
1806	unsigned int cpu = smp_processor_id();	1799	unsigned int cpu = smp_processor_id();
1807		1800
1808	setup_pinned_timer(t, mce_timer_fn, cpu);	1801	setup_pinned_timer(t, mce_timer_fn, cpu);
1809	mce_start_timer(cpu, t);	1802	mce_start_timer(t);
1810	}	1803	}
1811		1804
1812	/* Handle unconfigured int18 (should never happen) */	1805	/* Handle unconfigured int18 (should never happen) */
@@ -2566,7 +2559,7 @@ static int mce_cpu_dead(unsigned int cpu) · 753 unmodified lines
2566		2559
2567	static int mce_cpu_online(unsigned int cpu)	2560	static int mce_cpu_online(unsigned int cpu)
2568	{	2561	{
2569	struct timer_list *t = &per_cpu(mce_timer, cpu);	2562	struct timer_list *t = this_cpu_ptr(&mce_timer);
2570	int ret;	2563	int ret;
2571		2564
2572	mce_device_create(cpu);	2565	mce_device_create(cpu);
@@ -2577,13 +2570,13 @@ static int mce_cpu_online(unsigned int cpu) · 4 unmodified lines
2577	return ret;	2570	return ret;
2578	}	2571	}
2579	mce_reenable_cpu();	2572	mce_reenable_cpu();
2580	mce_start_timer(cpu, t);	2573	mce_start_timer(t);
2581	return 0;	2574	return 0;
2582	}	2575	}
2583		2576
2584	static int mce_cpu_pre_down(unsigned int cpu)	2577	static int mce_cpu_pre_down(unsigned int cpu)
2585	{	2578	{
2586	struct timer_list *t = &per_cpu(mce_timer, cpu);	2579	struct timer_list *t = this_cpu_ptr(&mce_timer);
2587		2580
2588	mce_disable_cpu();	2581	mce_disable_cpu();
2589	del_timer_sync(t);	2582	del_timer_sync(t);

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

 reget:
 		if (!get_builtin_microcode(&cp, family)) {
 #ifdef CONFIG_BLK_DEV_INITRD
-			cp = find_cpio_data(ucode_path, (void *)initrd_start,
+			if (!initrd_gone)
-					    initrd_end - initrd_start, NULL);
+				cp = find_cpio_data(ucode_path, (void *)initrd_start,
+						    initrd_end - initrd_start, NULL);
 #endif
 			if (!(cp.data && cp.size)) {
 				/*

arch/x86/kernel/cpu/microcode/core.c+17−5

 static struct microcode_ops	*microcode_ops;
 static bool dis_ucode_ldr = true;
+bool initrd_gone;
 LIST_HEAD(microcode_cache);
 /*
 static int __init save_microcode_in_initrd(void)
 {
 	struct cpuinfo_x86 *c = &boot_cpu_data;
+	int ret = -EINVAL;
 	switch (c->x86_vendor) {
 	case X86_VENDOR_INTEL:
 		if (c->x86 >= 6)
-			return save_microcode_in_initrd_intel();
+			ret = save_microcode_in_initrd_intel();
 		break;
 	case X86_VENDOR_AMD:
 		if (c->x86 >= 0x10)
-			return save_microcode_in_initrd_amd(c->x86);
+			ret = save_microcode_in_initrd_amd(c->x86);
 		break;
 	default:
 		break;
 	}
-	return -EINVAL;
+	initrd_gone = true;
+	return ret;
 }
 struct cpio_data find_microcode_in_initrd(const char *path, bool use_pa)
 	 * has the virtual address of the beginning of the initrd. It also
 	 * possibly relocates the ramdisk. In either case, initrd_start contains
 	 * the updated address so use that instead.
+	 *
+	 * initrd_gone is for the hotplug case where we've thrown out initrd
+	 * already.
 	 */
-	if (!use_pa && initrd_start)
+	if (!use_pa) {
-		start = initrd_start;
+		if (initrd_gone)
+			return (struct cpio_data){ NULL, 0, "" };
+		if (initrd_start)
+			start = initrd_start;
+	}
 	return find_cpio_data(path, (void *)start, size, NULL);
 #else /* !CONFIG_BLK_DEV_INITRD */

arch/x86/kernel/cpu/microcode/intel.c+1−8

 static const char ucode_path[] = "kernel/x86/microcode/GenuineIntel.bin";
-/* Current microcode patch used in early patching */
+/* Current microcode patch used in early patching on the APs. */
 struct microcode_intel *intel_ucode_patch;
 static inline bool cpu_signatures_match(unsigned int s1, unsigned int p1,
 	struct ucode_cpu_info uci;
 	struct cpio_data cp;
-	/*
-	 * AP loading didn't find any microcode patch, no need to save anything.
-	 */
-	if (!intel_ucode_patch || IS_ERR(intel_ucode_patch))
-		return 0;
 	if (!load_builtin_intel_microcode(&cp))
 		cp = find_microcode_in_initrd(ucode_path, false);
 	return 0;
 }
 /*
  * @res_patch, output: a pointer to the patch we found.
  */

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

 #include <asm/fpu/regset.h>
 #include <asm/fpu/signal.h>
 #include <asm/fpu/types.h>
+#include <asm/fpu/xstate.h>
 #include <asm/traps.h>
 #include <linux/hardirq.h>
 	 * it will #GP. Make sure it is replaced after the memset().
 	 */
 	if (static_cpu_has(X86_FEATURE_XSAVES))
-		state->xsave.header.xcomp_bv = XCOMP_BV_COMPACTED_FORMAT;
+		state->xsave.header.xcomp_bv = XCOMP_BV_COMPACTED_FORMAT |
+					       xfeatures_mask;
 	if (static_cpu_has(X86_FEATURE_FXSR))
 		fpstate_init_fxstate(&state->fxsave);

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

@@ -352,6 +352,7 @@ static int hpet_resume(struct clock_event_device *evt, int timer) · 351 unmodified lines
352	} else {	352	} else {
353	struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);	353	struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
354		354
		355	irq_domain_deactivate_irq(irq_get_irq_data(hdev->irq));
355	irq_domain_activate_irq(irq_get_irq_data(hdev->irq));	356	irq_domain_activate_irq(irq_get_irq_data(hdev->irq));
356	disable_irq(hdev->irq);	357	disable_irq(hdev->irq);
357	irq_set_affinity(hdev->irq, cpumask_of(hdev->cpu));	358	irq_set_affinity(hdev->irq, cpumask_of(hdev->cpu));

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

@@ -3182,6 +3182,7 @@ static void fill_xsave(u8 dest, struct kvm_vcpu vcpu) · 3181 unmodified lines
3182	memcpy(dest, xsave, XSAVE_HDR_OFFSET);	3182	memcpy(dest, xsave, XSAVE_HDR_OFFSET);
3183		3183
3184	/* Set XSTATE_BV */	3184	/* Set XSTATE_BV */
		3185	xstate_bv &= vcpu->arch.guest_supported_xcr0 \| XFEATURE_MASK_FPSSE;
3185	(u64 )(dest + XSAVE_HDR_OFFSET) = xstate_bv;	3186	(u64 )(dest + XSAVE_HDR_OFFSET) = xstate_bv;
3186		3187
3187	/*	3188	/*

arch/x86/platform/efi/efi_64.c+16−0

@@ -268,6 +268,22 @@ int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages) · 267 unmodified lines
268		268
269	efi_scratch.use_pgd = true;	269	efi_scratch.use_pgd = true;
270		270
		271	/*
		272	* Certain firmware versions are way too sentimential and still believe
		273	* they are exclusive and unquestionable owners of the first physical page,
		274	* even though they explicitly mark it as EFI_CONVENTIONAL_MEMORY
		275	* (but then write-access it later during SetVirtualAddressMap()).
		276	*
		277	* Create a 1:1 mapping for this page, to avoid triple faults during early
		278	* boot with such firmware. We are free to hand this page to the BIOS,
		279	* as trim_bios_range() will reserve the first page and isolate it away
		280	* from memory allocators anyway.
		281	*/
		282	if (kernel_map_pages_in_pgd(pgd, 0x0, 0x0, 1, _PAGE_RW)) {
		283	pr_err("Failed to create 1:1 mapping for the first page!\n");
		284	return 1;
		285	}
		286
271	/*	287	/*
272	* When making calls to the firmware everything needs to be 1:1	288	* When making calls to the firmware everything needs to be 1:1
273	* mapped and addressable with 32-bit pointers. Map the kernel	289	* mapped and addressable with 32-bit pointers. Map the kernel

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

@@ -419,7 +419,7 @@ subsys_initcall(topology_init); · 418 unmodified lines
419		419
420	void cpu_reset(void)	420	void cpu_reset(void)
421	{	421	{
422	#if XCHAL_HAVE_PTP_MMU	422	#if XCHAL_HAVE_PTP_MMU && IS_ENABLED(CONFIG_MMU)
423	local_irq_disable();	423	local_irq_disable();
424	/*	424	/*
425	* We have full MMU: all autoload ways, ways 7, 8 and 9 of DTLB must	425	* We have full MMU: all autoload ways, ways 7, 8 and 9 of DTLB must

crypto/algapi.c+1−0

@@ -356,6 +356,7 @@ int crypto_register_alg(struct crypto_alg *alg) · 355 unmodified lines
356	struct crypto_larval *larval;	356	struct crypto_larval *larval;
357	int err;	357	int err;
358		358
		359	alg->cra_flags &= ~CRYPTO_ALG_DEAD;
359	err = crypto_check_alg(alg);	360	err = crypto_check_alg(alg);
360	if (err)	361	if (err)
361	return err;	362	return err;

drivers/ata/libata-core.c+4−2

 		if (qc->err_mask & ~AC_ERR_OTHER)
 			qc->err_mask &= ~AC_ERR_OTHER;
+	} else if (qc->tf.command == ATA_CMD_REQ_SENSE_DATA) {
+		qc->result_tf.command |= ATA_SENSE;
 	}
 	/* finish up */
 	{ "ST380013AS",		"3.20",		ATA_HORKAGE_MAX_SEC_1024 },
 	/*
-	 * Device times out with higher max sects.
+	 * These devices time out with higher max sects.
 	 * https://bugzilla.kernel.org/show_bug.cgi?id=121671
 	 */
-	{ "LITEON CX1-JB256-HP", NULL,		ATA_HORKAGE_MAX_SEC_1024 },
+	{ "LITEON CX1-JB*-HP",	NULL,		ATA_HORKAGE_MAX_SEC_1024 },
 	/* Devices we expect to fail diagnostics */

drivers/ata/sata_mv.c+3−0

@@ -4132,6 +4132,9 @@ static int mv_platform_probe(struct platform_device *pdev) · 4131 unmodified lines
4132	host->iomap = NULL;	4132	host->iomap = NULL;
4133	hpriv->base = devm_ioremap(&pdev->dev, res->start,	4133	hpriv->base = devm_ioremap(&pdev->dev, res->start,
4134	resource_size(res));	4134	resource_size(res));
		4135	if (!hpriv->base)
		4136	return -ENOMEM;
		4137
4135	hpriv->base -= SATAHC0_REG_BASE;	4138	hpriv->base -= SATAHC0_REG_BASE;
4136		4139
4137	hpriv->clk = clk_get(&pdev->dev, NULL);	4140	hpriv->clk = clk_get(&pdev->dev, NULL);

drivers/base/firmware_class.c+1−4

 	struct firmware_buf *buf = fw_priv->buf;
 	__fw_load_abort(buf);
-	/* avoid user action after loading abort */
-	fw_priv->buf = NULL;
 }
 static LIST_HEAD(pending_fw_head);
 	mutex_lock(&fw_lock);
 	fw_buf = fw_priv->buf;
-	if (!fw_buf)
+	if (fw_state_is_aborted(&fw_buf->fw_st))
 		goto out;
 	switch (loading) {

drivers/base/memory.c+6−6

 {
 	struct memory_block *mem = to_memory_block(dev);
 	unsigned long start_pfn, end_pfn;
+	unsigned long valid_start, valid_end, valid_pages;
 	unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
-	struct page *first_page;
 	struct zone *zone;
 	int zone_shift = 0;
 	start_pfn = section_nr_to_pfn(mem->start_section_nr);
 	end_pfn = start_pfn + nr_pages;
-	first_page = pfn_to_page(start_pfn);
 	/* The block contains more than one zone can not be offlined. */
-	if (!test_pages_in_a_zone(start_pfn, end_pfn))
+	if (!test_pages_in_a_zone(start_pfn, end_pfn, &valid_start, &valid_end))
 		return sprintf(buf, "none\n");
-	zone = page_zone(first_page);
+	zone = page_zone(pfn_to_page(valid_start));
+	valid_pages = valid_end - valid_start;
 	/* MMOP_ONLINE_KEEP */
 	sprintf(buf, "%s", zone->name);
 	/* MMOP_ONLINE_KERNEL */
-	zone_can_shift(start_pfn, nr_pages, ZONE_NORMAL, &zone_shift);
+	zone_can_shift(valid_start, valid_pages, ZONE_NORMAL, &zone_shift);
 	if (zone_shift) {
 		strcat(buf, " ");
 		strcat(buf, (zone + zone_shift)->name);
 	}
 	/* MMOP_ONLINE_MOVABLE */
-	zone_can_shift(start_pfn, nr_pages, ZONE_MOVABLE, &zone_shift);
+	zone_can_shift(valid_start, valid_pages, ZONE_MOVABLE, &zone_shift);
 	if (zone_shift) {
 		strcat(buf, " ");
 		strcat(buf, (zone + zone_shift)->name);

drivers/bcma/bcma_private.h+3−0

 void bcma_core_chipcommon_early_init(struct bcma_drv_cc *cc);
 void bcma_core_chipcommon_init(struct bcma_drv_cc *cc);
 void bcma_chipco_bcm4331_ext_pa_lines_ctl(struct bcma_drv_cc *cc, bool enable);
+#ifdef CONFIG_BCMA_DRIVER_MIPS
+void bcma_chipco_serial_init(struct bcma_drv_cc *cc);
+#endif /* CONFIG_BCMA_DRIVER_MIPS */
 /* driver_chipcommon_b.c */
 int bcma_core_chipcommon_b_init(struct bcma_drv_cc_b *ccb);

drivers/bcma/driver_chipcommon.c+3−8

 #include <linux/platform_device.h>
 #include <linux/bcma/bcma.h>
-static void bcma_chipco_serial_init(struct bcma_drv_cc *cc);
 static inline u32 bcma_cc_write32_masked(struct bcma_drv_cc *cc, u16 offset,
 					 u32 mask, u32 value)
 {
 	if (cc->capabilities & BCMA_CC_CAP_PMU)
 		bcma_pmu_early_init(cc);
-	if (IS_BUILTIN(CONFIG_BCM47XX) && bus->hosttype == BCMA_HOSTTYPE_SOC)
-		bcma_chipco_serial_init(cc);
 	if (bus->hosttype == BCMA_HOSTTYPE_SOC)
 		bcma_core_chipcommon_flash_detect(cc);
 	return res;
 }
-static void bcma_chipco_serial_init(struct bcma_drv_cc *cc)
+#ifdef CONFIG_BCMA_DRIVER_MIPS
+void bcma_chipco_serial_init(struct bcma_drv_cc *cc)
 {
-#if IS_BUILTIN(CONFIG_BCM47XX)
 	unsigned int irq;
 	u32 baud_base;
 	u32 i;
 		ports[i].baud_base = baud_base;
 		ports[i].reg_shift = 0;
 	}
-#endif /* CONFIG_BCM47XX */
 }
+#endif /* CONFIG_BCMA_DRIVER_MIPS */

drivers/bcma/driver_mips.c+3−0

 void bcma_core_mips_early_init(struct bcma_drv_mips *mcore)
 {
+	struct bcma_bus *bus = mcore->core->bus;
 	if (mcore->early_setup_done)
 		return;
+	bcma_chipco_serial_init(&bus->drv_cc);
 	bcma_core_mips_nvram_init(mcore);
 	mcore->early_setup_done = true;

drivers/dma/cppi41.c+46−23

 	/* context for suspend/resume */
 	unsigned int dma_tdfdq;
+	bool is_suspended;
 };
 #define FIST_COMPLETION_QUEUE	93
 	BUG_ON(desc_num >= ALLOC_DECS_NUM);
 	c = cdd->chan_busy[desc_num];
 	cdd->chan_busy[desc_num] = NULL;
+	/* Usecount for chan_busy[], paired with push_desc_queue() */
+	pm_runtime_put(cdd->ddev.dev);
 	return c;
 }
 		while (val) {
 			u32 desc, len;
-			int error;
-			error = pm_runtime_get(cdd->ddev.dev);
+			/*
-			if (error < 0)
+			 * This should never trigger, see the comments in
-				dev_err(cdd->ddev.dev, "%s pm runtime get: %i\n",
+			 * push_desc_queue()
-					__func__, error);
+			 */
+			WARN_ON(cdd->is_suspended);
 			q_num = __fls(val);
 			val &= ~(1 << q_num);
 			c->residue = pd_trans_len(c->desc->pd6) - len;
 			dma_cookie_complete(&c->txd);
 			dmaengine_desc_get_callback_invoke(&c->txd, NULL);
-			pm_runtime_mark_last_busy(cdd->ddev.dev);
-			pm_runtime_put_autosuspend(cdd->ddev.dev);
 		}
 	}
 	return IRQ_HANDLED;
 	 */
 	__iowmb();
+	/*
+	 * DMA transfers can take at least 200ms to complete with USB mass
+	 * storage connected. To prevent autosuspend timeouts, we must use
+	 * pm_runtime_get/put() when chan_busy[] is modified. This will get
+	 * cleared in desc_to_chan() or cppi41_stop_chan() depending on the
+	 * outcome of the transfer.
+	 */
+	pm_runtime_get(cdd->ddev.dev);
 	desc_phys = lower_32_bits(c->desc_phys);
 	desc_num = (desc_phys - cdd->descs_phys) / sizeof(struct cppi41_desc);
 	WARN_ON(cdd->chan_busy[desc_num]);
 	cppi_writel(reg, cdd->qmgr_mem + QMGR_QUEUE_D(c->q_num));
 }
-static void pending_desc(struct cppi41_channel *c)
+/*
+ * Caller must hold cdd->lock to prevent push_desc_queue()
+ * getting called out of order. We have both cppi41_dma_issue_pending()
+ * and cppi41_runtime_resume() call this function.
+ */
+static void cppi41_run_queue(struct cppi41_dd *cdd)
 {
-	struct cppi41_dd *cdd = c->cdd;
+	struct cppi41_channel *c, *_c;
-	unsigned long flags;
-	spin_lock_irqsave(&cdd->lock, flags);
+	list_for_each_entry_safe(c, _c, &cdd->pending, node) {
-	list_add_tail(&c->node, &cdd->pending);
+		push_desc_queue(c);
-	spin_unlock_irqrestore(&cdd->lock, flags);
+		list_del(&c->node);
+	}
 }
 static void cppi41_dma_issue_pending(struct dma_chan *chan)
 {
 	struct cppi41_channel *c = to_cpp41_chan(chan);
 	struct cppi41_dd *cdd = c->cdd;
+	unsigned long flags;
 	int error;
 	error = pm_runtime_get(cdd->ddev.dev);
 		return;
 	}
-	if (likely(pm_runtime_active(cdd->ddev.dev)))
+	spin_lock_irqsave(&cdd->lock, flags);
-		push_desc_queue(c);
+	list_add_tail(&c->node, &cdd->pending);
-	else
+	if (!cdd->is_suspended)
-		pending_desc(c);
+		cppi41_run_queue(cdd);
+	spin_unlock_irqrestore(&cdd->lock, flags);
 	pm_runtime_mark_last_busy(cdd->ddev.dev);
 	pm_runtime_put_autosuspend(cdd->ddev.dev);
 	WARN_ON(!cdd->chan_busy[desc_num]);
 	cdd->chan_busy[desc_num] = NULL;
+	/* Usecount for chan_busy[], paired with push_desc_queue() */
+	pm_runtime_put(cdd->ddev.dev);
 	return 0;
 }
 static int __maybe_unused cppi41_runtime_suspend(struct device *dev)
 {
 	struct cppi41_dd *cdd = dev_get_drvdata(dev);
+	unsigned long flags;
+	spin_lock_irqsave(&cdd->lock, flags);
+	cdd->is_suspended = true;
 	WARN_ON(!list_empty(&cdd->pending));
+	spin_unlock_irqrestore(&cdd->lock, flags);
 	return 0;
 }
 static int __maybe_unused cppi41_runtime_resume(struct device *dev)
 {
 	struct cppi41_dd *cdd = dev_get_drvdata(dev);
-	struct cppi41_channel *c, *_c;
 	unsigned long flags;
 	spin_lock_irqsave(&cdd->lock, flags);
-	list_for_each_entry_safe(c, _c, &cdd->pending, node) {
+	cdd->is_suspended = false;
-		push_desc_queue(c);
+	cppi41_run_queue(cdd);
-		list_del(&c->node);
-	}
 	spin_unlock_irqrestore(&cdd->lock, flags);
 	return 0;

drivers/dma/pl330.c+6−13

 static struct pl330_thread *pl330_request_channel(struct pl330_dmac *pl330)
 {
 	struct pl330_thread *thrd = NULL;
-	unsigned long flags;
 	int chans, i;
 	if (pl330->state == DYING)
 	chans = pl330->pcfg.num_chan;
-	spin_lock_irqsave(&pl330->lock, flags);
 	for (i = 0; i < chans; i++) {
 		thrd = &pl330->channels[i];
 		if ((thrd->free) && (!_manager_ns(thrd) ||
 		thrd = NULL;
 	}
-	spin_unlock_irqrestore(&pl330->lock, flags);
 	return thrd;
 }
 static void pl330_release_channel(struct pl330_thread *thrd)
 {
 	struct pl330_dmac *pl330;
-	unsigned long flags;
 	if (!thrd || thrd->free)
 		return;
 	pl330 = thrd->dmac;
-	spin_lock_irqsave(&pl330->lock, flags);
 	_free_event(thrd, thrd->ev);
 	thrd->free = true;
-	spin_unlock_irqrestore(&pl330->lock, flags);
 }
 /* Initialize the structure for PL330 configuration, that can be used
 	struct pl330_dmac *pl330 = pch->dmac;
 	unsigned long flags;
-	spin_lock_irqsave(&pch->lock, flags);
+	spin_lock_irqsave(&pl330->lock, flags);
 	dma_cookie_init(chan);
 	pch->cyclic = false;
 	pch->thread = pl330_request_channel(pl330);
 	if (!pch->thread) {
-		spin_unlock_irqrestore(&pch->lock, flags);
+		spin_unlock_irqrestore(&pl330->lock, flags);
 		return -ENOMEM;
 	}
 	tasklet_init(&pch->task, pl330_tasklet, (unsigned long) pch);
-	spin_unlock_irqrestore(&pch->lock, flags);
+	spin_unlock_irqrestore(&pl330->lock, flags);
 	return 1;
 }
 static void pl330_free_chan_resources(struct dma_chan *chan)
 {
 	struct dma_pl330_chan *pch = to_pchan(chan);
+	struct pl330_dmac *pl330 = pch->dmac;
 	unsigned long flags;
 	tasklet_kill(&pch->task);
 	pm_runtime_get_sync(pch->dmac->ddma.dev);
-	spin_lock_irqsave(&pch->lock, flags);
+	spin_lock_irqsave(&pl330->lock, flags);
 	pl330_release_channel(pch->thread);
 	pch->thread = NULL;
 	if (pch->cyclic)
 		list_splice_tail_init(&pch->work_list, &pch->dmac->desc_pool);
-	spin_unlock_irqrestore(&pch->lock, flags);
+	spin_unlock_irqrestore(&pl330->lock, flags);
 	pm_runtime_mark_last_busy(pch->dmac->ddma.dev);
 	pm_runtime_put_autosuspend(pch->dmac->ddma.dev);
 }

drivers/firmware/efi/libstub/fdt.c+3−11

 struct exit_boot_struct {
 	efi_memory_desc_t *runtime_map;
 	int *runtime_entry_count;
+	void *new_fdt_addr;
 };
 static efi_status_t exit_boot_func(efi_system_table_t *sys_table_arg,
 	efi_get_virtmap(*map->map, *map->map_size, *map->desc_size,
 			p->runtime_map, p->runtime_entry_count);
-	return EFI_SUCCESS;
+	return update_fdt_memmap(p->new_fdt_addr, map);
 }
 /*
 	priv.runtime_map = runtime_map;
 	priv.runtime_entry_count = &runtime_entry_count;
+	priv.new_fdt_addr = (void *)*new_fdt_addr;
 	status = efi_exit_boot_services(sys_table, handle, &map, &priv,
 					exit_boot_func);
 	if (status == EFI_SUCCESS) {
 		efi_set_virtual_address_map_t *svam;
-		status = update_fdt_memmap((void *)*new_fdt_addr, &map);
-		if (status != EFI_SUCCESS) {
-			/*
-			 * The kernel won't get far without the memory map, but
-			 * may still be able to print something meaningful so
-			 * return success here.
-			 */
-			return EFI_SUCCESS;
-		}
 		/* Install the new virtual address map */
 		svam = sys_table->runtime->set_virtual_address_map;
 		status = svam(runtime_entry_count * desc_size, desc_size,

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

 	}
 	WREG32(mmHDP_REG_COHERENCY_FLUSH_CNTL, 0);
+	if (adev->mode_info.num_crtc)
+		amdgpu_display_set_vga_render_state(adev, false);
 	gmc_v6_0_mc_stop(adev, &save);
 	if (gmc_v6_0_wait_for_idle((void *)adev)) {
 		dev_warn(adev->dev, "Wait for MC idle timedout !\n");
 	}
 	gmc_v6_0_mc_resume(adev, &save);
-	amdgpu_display_set_vga_render_state(adev, false);
 }
 static int gmc_v6_0_mc_init(struct amdgpu_device *adev)

drivers/gpu/drm/drm_atomic.c+8−5

 	}
 	for_each_crtc_in_state(state, crtc, crtc_state, i) {
+		struct drm_pending_vblank_event *event = crtc_state->event;
 		/*
-		 * TEST_ONLY and PAGE_FLIP_EVENT are mutually
+		 * Free the allocated event. drm_atomic_helper_setup_commit
-		 * exclusive, if they weren't, this code should be
+		 * can allocate an event too, so only free it if it's ours
-		 * called on success for TEST_ONLY too.
+		 * to prevent a double free in drm_atomic_state_clear.
 		 */
-		if (crtc_state->event)
+		if (event && (event->base.fence || event->base.file_priv)) {
-			drm_event_cancel_free(dev, &crtc_state->event->base);
+			drm_event_cancel_free(dev, &event->base);
+			crtc_state->event = NULL;
+		}
 	}
 	if (!fence_state)

drivers/gpu/drm/drm_atomic_helper.c+0−9

 		funcs = plane->helper_private;
-		if (!drm_atomic_helper_framebuffer_changed(dev, state, plane_state->crtc))
-			continue;
 		if (funcs->prepare_fb) {
 			ret = funcs->prepare_fb(plane, plane_state);
 			if (ret)
 		if (j >= i)
 			continue;
-		if (!drm_atomic_helper_framebuffer_changed(dev, state, plane_state->crtc))
-			continue;
 		funcs = plane->helper_private;
 		if (funcs->cleanup_fb)
 	for_each_plane_in_state(old_state, plane, plane_state, i) {
 		const struct drm_plane_helper_funcs *funcs;
-		if (!drm_atomic_helper_framebuffer_changed(dev, old_state, plane_state->crtc))
-			continue;
 		funcs = plane->helper_private;
 		if (funcs->cleanup_fb)

drivers/gpu/drm/drm_connector.c+18−5

 	INIT_LIST_HEAD(&connector->probed_modes);
 	INIT_LIST_HEAD(&connector->modes);
+	mutex_init(&connector->mutex);
 	connector->edid_blob_ptr = NULL;
 	connector->status = connector_status_unknown;
 		connector->funcs->atomic_destroy_state(connector,
 						       connector->state);
+	mutex_destroy(&connector->mutex);
 	memset(connector, 0, sizeof(*connector));
 }
 EXPORT_SYMBOL(drm_connector_cleanup);
  */
 int drm_connector_register(struct drm_connector *connector)
 {
-	int ret;
+	int ret = 0;
-	if (connector->registered)
+	if (!connector->dev->registered)
 		return 0;
+	mutex_lock(&connector->mutex);
+	if (connector->registered)
+		goto unlock;
 	ret = drm_sysfs_connector_add(connector);
 	if (ret)
-		return ret;
+		goto unlock;
 	ret = drm_debugfs_connector_add(connector);
 	if (ret) {
 	drm_mode_object_register(connector->dev, &connector->base);
 	connector->registered = true;
-	return 0;
+	goto unlock;
 err_debugfs:
 	drm_debugfs_connector_remove(connector);
 err_sysfs:
 	drm_sysfs_connector_remove(connector);
+unlock:
+	mutex_unlock(&connector->mutex);
 	return ret;
 }
 EXPORT_SYMBOL(drm_connector_register);
  */
 void drm_connector_unregister(struct drm_connector *connector)
 {
-	if (!connector->registered)
+	mutex_lock(&connector->mutex);
+	if (!connector->registered) {
+		mutex_unlock(&connector->mutex);
 		return;
+	}
 	if (connector->funcs->early_unregister)
 		connector->funcs->early_unregister(connector);
 	drm_debugfs_connector_remove(connector);
 	connector->registered = false;
+	mutex_unlock(&connector->mutex);
 }
 EXPORT_SYMBOL(drm_connector_unregister);

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

 	if (ret)
 		goto err_minors;
+	dev->registered = true;
 	if (dev->driver->load) {
 		ret = dev->driver->load(dev, flags);
 		if (ret)
 	drm_lastclose(dev);
+	dev->registered = false;
 	if (drm_core_check_feature(dev, DRIVER_MODESET))
 		drm_modeset_unregister_all(dev);

drivers/gpu/drm/i915/i915_drv.h+4−12

 	struct work_struct underrun_work;
 	struct intel_fbc_state_cache {
+		struct i915_vma *vma;
 		struct {
 			unsigned int mode_flags;
 			uint32_t hsw_bdw_pixel_rate;
 		} plane;
 		struct {
-			u64 ilk_ggtt_offset;
 			uint32_t pixel_format;
 			unsigned int stride;
-			int fence_reg;
-			unsigned int tiling_mode;
 		} fb;
 	} state_cache;
 	struct intel_fbc_reg_params {
+		struct i915_vma *vma;
 		struct {
 			enum pipe pipe;
 			enum plane plane;
 		} crtc;
 		struct {
-			u64 ggtt_offset;
 			uint32_t pixel_format;
 			unsigned int stride;
-			int fence_reg;
 		} fb;
 		int cfb_size;
 	return i915_gem_obj_to_vma(obj, &to_i915(obj->base.dev)->ggtt.base, view);
 }
-static inline unsigned long
-i915_gem_object_ggtt_offset(struct drm_i915_gem_object *o,
-			    const struct i915_ggtt_view *view)
-{
-	return i915_ggtt_offset(i915_gem_object_to_ggtt(o, view));
-}
 /* i915_gem_fence_reg.c */
 int __must_check i915_vma_get_fence(struct i915_vma *vma);
 int __must_check i915_vma_put_fence(struct i915_vma *vma);

drivers/gpu/drm/i915/intel_atomic_plane.c+20−0

@@ -85,6 +85,8 @@ intel_plane_duplicate_state(struct drm_plane *plane) · 84 unmodified lines
85		85
86	__drm_atomic_helper_plane_duplicate_state(plane, state);	86	__drm_atomic_helper_plane_duplicate_state(plane, state);
87		87
		88	intel_state->vma = NULL;
		89
88	return state;	90	return state;
89	}	91	}
90		92
@@ -100,6 +102,24 @@ void · 9 unmodified lines
100	intel_plane_destroy_state(struct drm_plane *plane,	102	intel_plane_destroy_state(struct drm_plane *plane,
101	struct drm_plane_state *state)	103	struct drm_plane_state *state)
102	{	104	{
		105	struct i915_vma *vma;
		106
		107	vma = fetch_and_zero(&to_intel_plane_state(state)->vma);
		108
		109	/*
		110	* FIXME: Normally intel_cleanup_plane_fb handles destruction of vma.
		111	* We currently don't clear all planes during driver unload, so we have
		112	* to be able to unpin vma here for now.
		113	*
		114	* Normally this can only happen during unload when kmscon is disabled
		115	* and userspace doesn't attempt to set a framebuffer at all.
		116	*/
		117	if (vma) {
		118	mutex_lock(&plane->dev->struct_mutex);
		119	intel_unpin_fb_vma(vma);
		120	mutex_unlock(&plane->dev->struct_mutex);
		121	}
		122
103	drm_atomic_helper_plane_destroy_state(plane, state);	123	drm_atomic_helper_plane_destroy_state(plane, state);
104	}	124	}
105		125

drivers/gpu/drm/i915/intel_display.c+42−83

 			i915_vma_pin_fence(vma);
 	}
+	i915_vma_get(vma);
 err:
 	intel_runtime_pm_put(dev_priv);
 	return vma;
 }
-void intel_unpin_fb_obj(struct drm_framebuffer *fb, unsigned int rotation)
+void intel_unpin_fb_vma(struct i915_vma *vma)
 {
-	struct drm_i915_gem_object *obj = intel_fb_obj(fb);
+	lockdep_assert_held(&vma->vm->dev->struct_mutex);
-	struct i915_ggtt_view view;
-	struct i915_vma *vma;
-	WARN_ON(!mutex_is_locked(&obj->base.dev->struct_mutex));
-	intel_fill_fb_ggtt_view(&view, fb, rotation);
-	vma = i915_gem_object_to_ggtt(obj, &view);
 	if (WARN_ON_ONCE(!vma))
 		return;
 	i915_vma_unpin_fence(vma);
 	i915_gem_object_unpin_from_display_plane(vma);
+	i915_vma_put(vma);
 }
 static int intel_fb_pitch(const struct drm_framebuffer *fb, int plane,
 	struct drm_device *dev = intel_crtc->base.dev;
 	struct drm_i915_private *dev_priv = to_i915(dev);
 	struct drm_crtc *c;
-	struct intel_crtc *i;
 	struct drm_i915_gem_object *obj;
 	struct drm_plane *primary = intel_crtc->base.primary;
 	struct drm_plane_state *plane_state = primary->state;
 	 * an fb with another CRTC instead
 	 */
 	for_each_crtc(dev, c) {
-		i = to_intel_crtc(c);
+		struct intel_plane_state *state;
 		if (c == &intel_crtc->base)
 			continue;
-		if (!i->active)
+		if (!to_intel_crtc(c)->active)
 			continue;
-		fb = c->primary->fb;
+		state = to_intel_plane_state(c->primary->state);
-		if (!fb)
+		if (!state->vma)
 			continue;
-		obj = intel_fb_obj(fb);
+		if (intel_plane_ggtt_offset(state) == plane_config->base) {
-		if (i915_gem_object_ggtt_offset(obj, NULL) == plane_config->base) {
+			fb = c->primary->fb;
 			drm_framebuffer_reference(fb);
 			goto valid_fb;
 		}
 	return;
 valid_fb:
+	mutex_lock(&dev->struct_mutex);
+	intel_state->vma =
+		intel_pin_and_fence_fb_obj(fb, primary->state->rotation);
+	mutex_unlock(&dev->struct_mutex);
+	if (IS_ERR(intel_state->vma)) {
+		DRM_ERROR("failed to pin boot fb on pipe %d: %li\n",
+			  intel_crtc->pipe, PTR_ERR(intel_state->vma));
+		intel_state->vma = NULL;
+		drm_framebuffer_unreference(fb);
+		return;
+	}
 	plane_state->src_x = 0;
 	plane_state->src_y = 0;
 	plane_state->src_w = fb->width << 16;
 	I915_WRITE(DSPSTRIDE(plane), fb->pitches[0]);
 	if (INTEL_GEN(dev_priv) >= 4) {
 		I915_WRITE(DSPSURF(plane),
-			   intel_fb_gtt_offset(fb, rotation) +
+			   intel_plane_ggtt_offset(plane_state) +
 			   intel_crtc->dspaddr_offset);
 		I915_WRITE(DSPTILEOFF(plane), (y << 16) | x);
 		I915_WRITE(DSPLINOFF(plane), linear_offset);
 	} else {
 		I915_WRITE(DSPADDR(plane),
-			   intel_fb_gtt_offset(fb, rotation) +
+			   intel_plane_ggtt_offset(plane_state) +
 			   intel_crtc->dspaddr_offset);
 	}
 	POSTING_READ(reg);
 	I915_WRITE(DSPSTRIDE(plane), fb->pitches[0]);
 	I915_WRITE(DSPSURF(plane),
-		   intel_fb_gtt_offset(fb, rotation) +
+		   intel_plane_ggtt_offset(plane_state) +
 		   intel_crtc->dspaddr_offset);
 	if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) {
 		I915_WRITE(DSPOFFSET(plane), (y << 16) | x);
 	}
 }
-u32 intel_fb_gtt_offset(struct drm_framebuffer *fb,
-			unsigned int rotation)
-{
-	struct drm_i915_gem_object *obj = intel_fb_obj(fb);
-	struct i915_ggtt_view view;
-	struct i915_vma *vma;
-	intel_fill_fb_ggtt_view(&view, fb, rotation);
-	vma = i915_gem_object_to_ggtt(obj, &view);
-	if (WARN(!vma, "ggtt vma for display object not found! (view=%u)\n",
-		 view.type))
-		return -1;
-	return i915_ggtt_offset(vma);
-}
 static void skl_detach_scaler(struct intel_crtc *intel_crtc, int id)
 {
 	struct drm_device *dev = intel_crtc->base.dev;
 	}
 	I915_WRITE(PLANE_SURF(pipe, 0),
-		   intel_fb_gtt_offset(fb, rotation) + surf_addr);
+		   intel_plane_ggtt_offset(plane_state) + surf_addr);
 	POSTING_READ(PLANE_SURF(pipe, 0));
 }
 		flush_work(&work->mmio_work);
 	mutex_lock(&dev->struct_mutex);
-	intel_unpin_fb_obj(work->old_fb, primary->state->rotation);
+	intel_unpin_fb_vma(work->old_vma);
 	i915_gem_object_put(work->pending_flip_obj);
 	mutex_unlock(&dev->struct_mutex);
 		goto cleanup_pending;
 	}
-	work->gtt_offset = intel_fb_gtt_offset(fb, primary->state->rotation);
+	work->old_vma = to_intel_plane_state(primary->state)->vma;
-	work->gtt_offset += intel_crtc->dspaddr_offset;
+	to_intel_plane_state(primary->state)->vma = vma;
+	work->gtt_offset = i915_ggtt_offset(vma) + intel_crtc->dspaddr_offset;
 	work->rotation = crtc->primary->state->rotation;
 	/*
 cleanup_request:
 	i915_add_request_no_flush(request);
 cleanup_unpin:
-	intel_unpin_fb_obj(fb, crtc->primary->state->rotation);
+	to_intel_plane_state(primary->state)->vma = work->old_vma;
+	intel_unpin_fb_vma(vma);
 cleanup_pending:
 	atomic_dec(&intel_crtc->unpin_work_count);
 unlock:
 			DRM_DEBUG_KMS("failed to pin object\n");
 			return PTR_ERR(vma);
 		}
+		to_intel_plane_state(new_state)->vma = vma;
 	}
 	return 0;
 intel_cleanup_plane_fb(struct drm_plane *plane,
 		       struct drm_plane_state *old_state)
 {
-	struct drm_i915_private *dev_priv = to_i915(plane->dev);
+	struct i915_vma *vma;
-	struct intel_plane_state *old_intel_state;
-	struct drm_i915_gem_object *old_obj = intel_fb_obj(old_state->fb);
-	struct drm_i915_gem_object *obj = intel_fb_obj(plane->state->fb);
-	old_intel_state = to_intel_plane_state(old_state);
-	if (!obj && !old_obj)
-		return;
-	if (old_obj && (plane->type != DRM_PLANE_TYPE_CURSOR ||
+	/* Should only be called after a successful intel_prepare_plane_fb()! */
-	    !INTEL_INFO(dev_priv)->cursor_needs_physical))
+	vma = fetch_and_zero(&to_intel_plane_state(old_state)->vma);
-		intel_unpin_fb_obj(old_state->fb, old_state->rotation);
+	if (vma)
+		intel_unpin_fb_vma(vma);
 }
 int
 	if (!obj)
 		addr = 0;
 	else if (!INTEL_INFO(dev_priv)->cursor_needs_physical)
-		addr = i915_gem_object_ggtt_offset(obj, NULL);
+		addr = intel_plane_ggtt_offset(state);
 	else
 		addr = obj->phys_handle->busaddr;
 void intel_modeset_gem_init(struct drm_device *dev)
 {
 	struct drm_i915_private *dev_priv = to_i915(dev);
-	struct drm_crtc *c;
-	struct drm_i915_gem_object *obj;
 	intel_init_gt_powersave(dev_priv);
 	intel_modeset_init_hw(dev);
 	intel_setup_overlay(dev_priv);
-	/*
-	 * Make sure any fbs we allocated at startup are properly
-	 * pinned & fenced.  When we do the allocation it's too early
-	 * for this.
-	 */
-	for_each_crtc(dev, c) {
-		struct i915_vma *vma;
-		obj = intel_fb_obj(c->primary->fb);
-		if (obj == NULL)
-			continue;
-		mutex_lock(&dev->struct_mutex);
-		vma = intel_pin_and_fence_fb_obj(c->primary->fb,
-						 c->primary->state->rotation);
-		mutex_unlock(&dev->struct_mutex);
-		if (IS_ERR(vma)) {
-			DRM_ERROR("failed to pin boot fb on pipe %d\n",
-				  to_intel_crtc(c)->pipe);
-			drm_framebuffer_unreference(c->primary->fb);
-			c->primary->fb = NULL;
-			c->primary->crtc = c->primary->state->crtc = NULL;
-			update_state_fb(c->primary);
-			c->state->plane_mask &= ~(1 << drm_plane_index(c->primary));
-		}
-	}
 }
 int intel_connector_register(struct drm_connector *connector)

drivers/gpu/drm/i915/intel_drv.h+7−2

 struct intel_plane_state {
 	struct drm_plane_state base;
 	struct drm_rect clip;
+	struct i915_vma *vma;
 	struct {
 		u32 offset;
 	struct work_struct mmio_work;
 	struct drm_crtc *crtc;
+	struct i915_vma *old_vma;
 	struct drm_framebuffer *old_fb;
 	struct drm_i915_gem_object *pending_flip_obj;
 	struct drm_pending_vblank_event *event;
 				    struct drm_modeset_acquire_ctx *ctx);
 struct i915_vma *
 intel_pin_and_fence_fb_obj(struct drm_framebuffer *fb, unsigned int rotation);
-void intel_unpin_fb_obj(struct drm_framebuffer *fb, unsigned int rotation);
+void intel_unpin_fb_vma(struct i915_vma *vma);
 struct drm_framebuffer *
 __intel_framebuffer_create(struct drm_device *dev,
 			   struct drm_mode_fb_cmd2 *mode_cmd,
 int skl_update_scaler_crtc(struct intel_crtc_state *crtc_state);
 int skl_max_scale(struct intel_crtc *crtc, struct intel_crtc_state *crtc_state);
-u32 intel_fb_gtt_offset(struct drm_framebuffer *fb, unsigned int rotation);
+static inline u32 intel_plane_ggtt_offset(const struct intel_plane_state *state)
+{
+	return i915_ggtt_offset(state->vma);
+}
 u32 skl_plane_ctl_format(uint32_t pixel_format);
 u32 skl_plane_ctl_tiling(uint64_t fb_modifier);

drivers/gpu/drm/i915/intel_fbc.c+20−32

@@ -173,7 +173,7 @@ static void i8xx_fbc_activate(struct drm_i915_private *dev_priv) · 172 unmodified lines
173	if (IS_I945GM(dev_priv))	173	if (IS_I945GM(dev_priv))
174	fbc_ctl \|= FBC_CTL_C3_IDLE; /* 945 needs special SR handling */	174	fbc_ctl \|= FBC_CTL_C3_IDLE; /* 945 needs special SR handling */
175	fbc_ctl \|= (cfb_pitch & 0xff) << FBC_CTL_STRIDE_SHIFT;	175	fbc_ctl \|= (cfb_pitch & 0xff) << FBC_CTL_STRIDE_SHIFT;
176	fbc_ctl \|= params->fb.fence_reg;	176	fbc_ctl \|= params->vma->fence->id;
177	I915_WRITE(FBC_CONTROL, fbc_ctl);	177	I915_WRITE(FBC_CONTROL, fbc_ctl);
178	}	178	}
179		179
@@ -193,8 +193,8 @@ static void g4x_fbc_activate(struct drm_i915_private *dev_priv) · 13 unmodified lines
193	else	193	else
194	dpfc_ctl \|= DPFC_CTL_LIMIT_1X;	194	dpfc_ctl \|= DPFC_CTL_LIMIT_1X;
195		195
196	if (params->fb.fence_reg != I915_FENCE_REG_NONE) {	196	if (params->vma->fence) {
197	dpfc_ctl \|= DPFC_CTL_FENCE_EN \| params->fb.fence_reg;	197	dpfc_ctl \|= DPFC_CTL_FENCE_EN \| params->vma->fence->id;
198	I915_WRITE(DPFC_FENCE_YOFF, params->crtc.fence_y_offset);	198	I915_WRITE(DPFC_FENCE_YOFF, params->crtc.fence_y_offset);
199	} else {	199	} else {
200	I915_WRITE(DPFC_FENCE_YOFF, 0);	200	I915_WRITE(DPFC_FENCE_YOFF, 0);
@@ -251,13 +251,14 @@ static void ilk_fbc_activate(struct drm_i915_private *dev_priv) · 50 unmodified lines
251	break;	251	break;
252	}	252	}
253		253
254	if (params->fb.fence_reg != I915_FENCE_REG_NONE) {	254	if (params->vma->fence) {
255	dpfc_ctl \|= DPFC_CTL_FENCE_EN;	255	dpfc_ctl \|= DPFC_CTL_FENCE_EN;
256	if (IS_GEN5(dev_priv))	256	if (IS_GEN5(dev_priv))
257	dpfc_ctl \|= params->fb.fence_reg;	257	dpfc_ctl \|= params->vma->fence->id;
258	if (IS_GEN6(dev_priv)) {	258	if (IS_GEN6(dev_priv)) {
259	I915_WRITE(SNB_DPFC_CTL_SA,	259	I915_WRITE(SNB_DPFC_CTL_SA,
260	SNB_CPU_FENCE_ENABLE \| params->fb.fence_reg);	260	SNB_CPU_FENCE_ENABLE \|
		261	params->vma->fence->id);
261	I915_WRITE(DPFC_CPU_FENCE_OFFSET,	262	I915_WRITE(DPFC_CPU_FENCE_OFFSET,
262	params->crtc.fence_y_offset);	263	params->crtc.fence_y_offset);
263	}	264	}
@@ -269,7 +270,8 @@ static void ilk_fbc_activate(struct drm_i915_private *dev_priv) · 5 unmodified lines
269	}	270	}
270		271
271	I915_WRITE(ILK_DPFC_FENCE_YOFF, params->crtc.fence_y_offset);	272	I915_WRITE(ILK_DPFC_FENCE_YOFF, params->crtc.fence_y_offset);
272	I915_WRITE(ILK_FBC_RT_BASE, params->fb.ggtt_offset \| ILK_FBC_RT_VALID);	273	I915_WRITE(ILK_FBC_RT_BASE,
		274	i915_ggtt_offset(params->vma) \| ILK_FBC_RT_VALID);
273	/* enable it... */	275	/* enable it... */
274	I915_WRITE(ILK_DPFC_CONTROL, dpfc_ctl \| DPFC_CTL_EN);	276	I915_WRITE(ILK_DPFC_CONTROL, dpfc_ctl \| DPFC_CTL_EN);
275		277
@@ -319,10 +321,11 @@ static void gen7_fbc_activate(struct drm_i915_private *dev_priv) · 43 unmodified lines
319	break;	321	break;
320	}	322	}
321		323
322	if (params->fb.fence_reg != I915_FENCE_REG_NONE) {	324	if (params->vma->fence) {
323	dpfc_ctl \|= IVB_DPFC_CTL_FENCE_EN;	325	dpfc_ctl \|= IVB_DPFC_CTL_FENCE_EN;
324	I915_WRITE(SNB_DPFC_CTL_SA,	326	I915_WRITE(SNB_DPFC_CTL_SA,
325	SNB_CPU_FENCE_ENABLE \| params->fb.fence_reg);	327	SNB_CPU_FENCE_ENABLE \|
		328	params->vma->fence->id);
326	I915_WRITE(DPFC_CPU_FENCE_OFFSET, params->crtc.fence_y_offset);	329	I915_WRITE(DPFC_CPU_FENCE_OFFSET, params->crtc.fence_y_offset);
327	} else {	330	} else {
328	I915_WRITE(SNB_DPFC_CTL_SA,0);	331	I915_WRITE(SNB_DPFC_CTL_SA,0);
@@ -727,14 +730,6 @@ static bool intel_fbc_hw_tracking_covers_screen(struct intel_crtc *crtc) · 398 unmodified lines
727	return effective_w <= max_w && effective_h <= max_h;	730	return effective_w <= max_w && effective_h <= max_h;
728	}	731	}
729		732
730	/* XXX replace me when we have VMA tracking for intel_plane_state */
731	static int get_fence_id(struct drm_framebuffer *fb)
732	{
733	struct i915_vma *vma = i915_gem_object_to_ggtt(intel_fb_obj(fb), NULL);
734
735	return vma && vma->fence ? vma->fence->id : I915_FENCE_REG_NONE;
736	}
737
738	static void intel_fbc_update_state_cache(struct intel_crtc *crtc,	733	static void intel_fbc_update_state_cache(struct intel_crtc *crtc,
739	struct intel_crtc_state *crtc_state,	734	struct intel_crtc_state *crtc_state,
740	struct intel_plane_state *plane_state)	735	struct intel_plane_state *plane_state)
@@ -743,7 +738,8 @@ static void intel_fbc_update_state_cache(struct intel_crtc *crtc, · 2 unmodified lines
743	struct intel_fbc *fbc = &dev_priv->fbc;	738	struct intel_fbc *fbc = &dev_priv->fbc;
744	struct intel_fbc_state_cache *cache = &fbc->state_cache;	739	struct intel_fbc_state_cache *cache = &fbc->state_cache;
745	struct drm_framebuffer *fb = plane_state->base.fb;	740	struct drm_framebuffer *fb = plane_state->base.fb;
746	struct drm_i915_gem_object *obj;	741
		742	cache->vma = NULL;
747		743
748	cache->crtc.mode_flags = crtc_state->base.adjusted_mode.flags;	744	cache->crtc.mode_flags = crtc_state->base.adjusted_mode.flags;
749	if (IS_HASWELL(dev_priv) \|\| IS_BROADWELL(dev_priv))	745	if (IS_HASWELL(dev_priv) \|\| IS_BROADWELL(dev_priv))
@@ -758,16 +754,10 @@ static void intel_fbc_update_state_cache(struct intel_crtc *crtc, · 8 unmodified lines
758	if (!cache->plane.visible)	754	if (!cache->plane.visible)
759	return;	755	return;
760		756
761	obj = intel_fb_obj(fb);
762
763	/* FIXME: We lack the proper locking here, so only run this on the
764	* platforms that need. */
765	if (IS_GEN(dev_priv, 5, 6))
766	cache->fb.ilk_ggtt_offset = i915_gem_object_ggtt_offset(obj, NULL);
767	cache->fb.pixel_format = fb->pixel_format;	757	cache->fb.pixel_format = fb->pixel_format;
768	cache->fb.stride = fb->pitches[0];	758	cache->fb.stride = fb->pitches[0];
769	cache->fb.fence_reg = get_fence_id(fb);	759
770	cache->fb.tiling_mode = i915_gem_object_get_tiling(obj);	760	cache->vma = plane_state->vma;
771	}	761	}
772		762
773	static bool intel_fbc_can_activate(struct intel_crtc *crtc)	763	static bool intel_fbc_can_activate(struct intel_crtc *crtc)
@@ -784,7 +774,7 @@ static bool intel_fbc_can_activate(struct intel_crtc *crtc) · 10 unmodified lines
784	return false;	774	return false;
785	}	775	}
786		776
787	if (!cache->plane.visible) {	777	if (!cache->vma) {
788	fbc->no_fbc_reason = "primary plane not visible";	778	fbc->no_fbc_reason = "primary plane not visible";
789	return false;	779	return false;
790	}	780	}
@@ -807,8 +797,7 @@ static bool intel_fbc_can_activate(struct intel_crtc *crtc) · 16 unmodified lines
807	* so have no fence associated with it) due to aperture constaints	797	* so have no fence associated with it) due to aperture constaints
808	* at the time of pinning.	798	* at the time of pinning.
809	*/	799	*/
810	if (cache->fb.tiling_mode != I915_TILING_X \|\|	800	if (!cache->vma->fence) {
811	cache->fb.fence_reg == I915_FENCE_REG_NONE) {
812	fbc->no_fbc_reason = "framebuffer not tiled or fenced";	801	fbc->no_fbc_reason = "framebuffer not tiled or fenced";
813	return false;	802	return false;
814	}	803	}
@@ -888,17 +877,16 @@ static void intel_fbc_get_reg_params(struct intel_crtc *crtc, · 73 unmodified lines
888	* zero. */	877	* zero. */
889	memset(params, 0, sizeof(*params));	878	memset(params, 0, sizeof(*params));
890		879
		880	params->vma = cache->vma;
		881
891	params->crtc.pipe = crtc->pipe;	882	params->crtc.pipe = crtc->pipe;
892	params->crtc.plane = crtc->plane;	883	params->crtc.plane = crtc->plane;
893	params->crtc.fence_y_offset = get_crtc_fence_y_offset(crtc);	884	params->crtc.fence_y_offset = get_crtc_fence_y_offset(crtc);
894		885
895	params->fb.pixel_format = cache->fb.pixel_format;	886	params->fb.pixel_format = cache->fb.pixel_format;
896	params->fb.stride = cache->fb.stride;	887	params->fb.stride = cache->fb.stride;
897	params->fb.fence_reg = cache->fb.fence_reg;
898		888
899	params->cfb_size = intel_fbc_calculate_cfb_size(dev_priv, cache);	889	params->cfb_size = intel_fbc_calculate_cfb_size(dev_priv, cache);
900
901	params->fb.ggtt_offset = cache->fb.ilk_ggtt_offset;
902	}	890	}
903		891
904	static bool intel_fbc_reg_params_equal(struct intel_fbc_reg_params *params1,	892	static bool intel_fbc_reg_params_equal(struct intel_fbc_reg_params *params1,

drivers/gpu/drm/i915/intel_fbdev.c+2−2

@@ -284,7 +284,7 @@ static int intelfb_create(struct drm_fb_helper *helper, · 283 unmodified lines
284	out_destroy_fbi:	284	out_destroy_fbi:
285	drm_fb_helper_release_fbi(helper);	285	drm_fb_helper_release_fbi(helper);
286	out_unpin:	286	out_unpin:
287	intel_unpin_fb_obj(&ifbdev->fb->base, DRM_ROTATE_0);	287	intel_unpin_fb_vma(vma);
288	out_unlock:	288	out_unlock:
289	mutex_unlock(&dev->struct_mutex);	289	mutex_unlock(&dev->struct_mutex);
290	return ret;	290	return ret;
@@ -549,7 +549,7 @@ static void intel_fbdev_destroy(struct intel_fbdev *ifbdev) · 258 unmodified lines
549		549
550	if (ifbdev->fb) {	550	if (ifbdev->fb) {
551	mutex_lock(&ifbdev->helper.dev->struct_mutex);	551	mutex_lock(&ifbdev->helper.dev->struct_mutex);
552	intel_unpin_fb_obj(&ifbdev->fb->base, DRM_ROTATE_0);	552	intel_unpin_fb_vma(ifbdev->vma);
553	mutex_unlock(&ifbdev->helper.dev->struct_mutex);	553	mutex_unlock(&ifbdev->helper.dev->struct_mutex);
554		554
555	drm_framebuffer_remove(&ifbdev->fb->base);	555	drm_framebuffer_remove(&ifbdev->fb->base);

drivers/gpu/drm/i915/intel_sprite.c+4−4

@@ -273,7 +273,7 @@ skl_update_plane(struct drm_plane *drm_plane, · 272 unmodified lines
273		273
274	I915_WRITE(PLANE_CTL(pipe, plane), plane_ctl);	274	I915_WRITE(PLANE_CTL(pipe, plane), plane_ctl);
275	I915_WRITE(PLANE_SURF(pipe, plane),	275	I915_WRITE(PLANE_SURF(pipe, plane),
276	intel_fb_gtt_offset(fb, rotation) + surf_addr);	276	intel_plane_ggtt_offset(plane_state) + surf_addr);
277	POSTING_READ(PLANE_SURF(pipe, plane));	277	POSTING_READ(PLANE_SURF(pipe, plane));
278	}	278	}
279		279
@@ -458,7 +458,7 @@ vlv_update_plane(struct drm_plane *dplane, · 178 unmodified lines
458	I915_WRITE(SPSIZE(pipe, plane), (crtc_h << 16) \| crtc_w);	458	I915_WRITE(SPSIZE(pipe, plane), (crtc_h << 16) \| crtc_w);
459	I915_WRITE(SPCNTR(pipe, plane), sprctl);	459	I915_WRITE(SPCNTR(pipe, plane), sprctl);
460	I915_WRITE(SPSURF(pipe, plane),	460	I915_WRITE(SPSURF(pipe, plane),
461	intel_fb_gtt_offset(fb, rotation) + sprsurf_offset);	461	intel_plane_ggtt_offset(plane_state) + sprsurf_offset);
462	POSTING_READ(SPSURF(pipe, plane));	462	POSTING_READ(SPSURF(pipe, plane));
463	}	463	}
464		464
@@ -594,7 +594,7 @@ ivb_update_plane(struct drm_plane *plane, · 129 unmodified lines
594	I915_WRITE(SPRSCALE(pipe), sprscale);	594	I915_WRITE(SPRSCALE(pipe), sprscale);
595	I915_WRITE(SPRCTL(pipe), sprctl);	595	I915_WRITE(SPRCTL(pipe), sprctl);
596	I915_WRITE(SPRSURF(pipe),	596	I915_WRITE(SPRSURF(pipe),
597	intel_fb_gtt_offset(fb, rotation) + sprsurf_offset);	597	intel_plane_ggtt_offset(plane_state) + sprsurf_offset);
598	POSTING_READ(SPRSURF(pipe));	598	POSTING_READ(SPRSURF(pipe));
599	}	599	}
600		600
@@ -721,7 +721,7 @@ ilk_update_plane(struct drm_plane *plane, · 120 unmodified lines
721	I915_WRITE(DVSSCALE(pipe), dvsscale);	721	I915_WRITE(DVSSCALE(pipe), dvsscale);
722	I915_WRITE(DVSCNTR(pipe), dvscntr);	722	I915_WRITE(DVSCNTR(pipe), dvscntr);
723	I915_WRITE(DVSSURF(pipe),	723	I915_WRITE(DVSSURF(pipe),
724	intel_fb_gtt_offset(fb, rotation) + dvssurf_offset);	724	intel_plane_ggtt_offset(plane_state) + dvssurf_offset);
725	POSTING_READ(DVSSURF(pipe));	725	POSTING_READ(DVSSURF(pipe));
726	}	726	}
727		727

drivers/gpu/drm/nouveau/dispnv04/hw.c+2−1

 		uint32_t mpllP;
 		pci_read_config_dword(pci_get_bus_and_slot(0, 3), 0x6c, &mpllP);
+		mpllP = (mpllP >> 8) & 0xf;
 		if (!mpllP)
 			mpllP = 4;
 		uint32_t clock;
 		pci_read_config_dword(pci_get_bus_and_slot(0, 5), 0x4c, &clock);
-		return clock;
+		return clock / 1000;
 	}
 	ret = nouveau_hw_get_pllvals(dev, plltype, &pllvals);

drivers/gpu/drm/nouveau/nouveau_fence.h+1−0

@@ -99,6 +99,7 @@ struct nv84_fence_priv { · 98 unmodified lines
99	struct nouveau_bo *bo;	99	struct nouveau_bo *bo;
100	struct nouveau_bo *bo_gart;	100	struct nouveau_bo *bo_gart;
101	u32 *suspend;	101	u32 *suspend;
		102	struct mutex mutex;
102	};	103	};
103		104
104	int nv84_fence_context_new(struct nouveau_channel *);	105	int nv84_fence_context_new(struct nouveau_channel *);

drivers/gpu/drm/nouveau/nouveau_led.h+1−1

@@ -42,7 +42,7 @@ nouveau_led(struct drm_device *dev) · 41 unmodified lines
42	}	42	}
43		43
44	/* nouveau_led.c */	44	/* nouveau_led.c */
45	#if IS_ENABLED(CONFIG_LEDS_CLASS)	45	#if IS_REACHABLE(CONFIG_LEDS_CLASS)
46	int nouveau_led_init(struct drm_device *dev);	46	int nouveau_led_init(struct drm_device *dev);
47	void nouveau_led_suspend(struct drm_device *dev);	47	void nouveau_led_suspend(struct drm_device *dev);
48	void nouveau_led_resume(struct drm_device *dev);	48	void nouveau_led_resume(struct drm_device *dev);

drivers/gpu/drm/nouveau/nouveau_usif.c+2−1

 	if (!(ret = nvif_unpack(-ENOSYS, &data, &size, argv->v0, 0, 0, true))) {
 		/* block access to objects not created via this interface */
 		owner = argv->v0.owner;
-		if (argv->v0.object == 0ULL)
+		if (argv->v0.object == 0ULL &&
+		    argv->v0.type != NVIF_IOCTL_V0_DEL)
 			argv->v0.owner = NVDRM_OBJECT_ANY; /* except client */
 		else
 			argv->v0.owner = NVDRM_OBJECT_USIF;

drivers/gpu/drm/nouveau/nv50_display.c+6−0

 		}
 	}
+	for_each_crtc_in_state(state, crtc, crtc_state, i) {
+		if (crtc->state->event)
+			drm_crtc_vblank_get(crtc);
+	}
 	/* Update plane(s). */
 	for_each_plane_in_state(state, plane, plane_state, i) {
 		struct nv50_wndw_atom *asyw = nv50_wndw_atom(plane->state);
 			drm_crtc_send_vblank_event(crtc, crtc->state->event);
 			spin_unlock_irqrestore(&crtc->dev->event_lock, flags);
 			crtc->state->event = NULL;
+			drm_crtc_vblank_put(crtc);
 		}
 	}

drivers/gpu/drm/nouveau/nv84_fence.c+6−0

 	struct nv84_fence_chan *fctx = chan->fence;
 	nouveau_bo_wr32(priv->bo, chan->chid * 16 / 4, fctx->base.sequence);
+	mutex_lock(&priv->mutex);
 	nouveau_bo_vma_del(priv->bo, &fctx->vma_gart);
 	nouveau_bo_vma_del(priv->bo, &fctx->vma);
+	mutex_unlock(&priv->mutex);
 	nouveau_fence_context_del(&fctx->base);
 	chan->fence = NULL;
 	nouveau_fence_context_free(&fctx->base);
 	fctx->base.sync32 = nv84_fence_sync32;
 	fctx->base.sequence = nv84_fence_read(chan);
+	mutex_lock(&priv->mutex);
 	ret = nouveau_bo_vma_add(priv->bo, cli->vm, &fctx->vma);
 	if (ret == 0) {
 		ret = nouveau_bo_vma_add(priv->bo_gart, cli->vm,
 					&fctx->vma_gart);
 	}
+	mutex_unlock(&priv->mutex);
 	if (ret)
 		nv84_fence_context_del(chan);
 	priv->base.context_base = dma_fence_context_alloc(priv->base.contexts);
 	priv->base.uevent = true;
+	mutex_init(&priv->mutex);
 	/* Use VRAM if there is any ; otherwise fallback to system memory */
 	domain = drm->device.info.ram_size != 0 ? TTM_PL_FLAG_VRAM :
 			 /*

drivers/gpu/drm/nouveau/nvkm/engine/disp/hdagt215.c+1−1

@@ -59,7 +59,7 @@ gt215_hda_eld(NV50_DISP_MTHD_V1) · 58 unmodified lines
59	);	59	);
60	}	60	}
61	for (i = 0; i < size; i++)	61	for (i = 0; i < size; i++)
62	nvkm_wr32(device, 0x61c440 + soff, (i << 8) \| args->v0.data[0]);	62	nvkm_wr32(device, 0x61c440 + soff, (i << 8) \| args->v0.data[i]);
63	for (; i < 0x60; i++)	63	for (; i < 0x60; i++)
64	nvkm_wr32(device, 0x61c440 + soff, (i << 8));	64	nvkm_wr32(device, 0x61c440 + soff, (i << 8));
65	nvkm_mask(device, 0x61c448 + soff, 0x80000003, 0x80000003);	65	nvkm_mask(device, 0x61c448 + soff, 0x80000003, 0x80000003);

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c+0−2

 	case 0x94:
 	case 0x96:
 	case 0x98:
-	case 0xaa:
-	case 0xac:
 		return true;
 	default:
 		break;

drivers/gpu/drm/radeon/radeon_drv.c+2−1

  *   2.46.0 - Add PFP_SYNC_ME support on evergreen
  *   2.47.0 - Add UVD_NO_OP register support
  *   2.48.0 - TA_CS_BC_BASE_ADDR allowed on SI
+ *   2.49.0 - DRM_RADEON_GEM_INFO ioctl returns correct vram_size/visible values
  */
 #define KMS_DRIVER_MAJOR	2
-#define KMS_DRIVER_MINOR	48
+#define KMS_DRIVER_MINOR	49
 #define KMS_DRIVER_PATCHLEVEL	0
 int radeon_driver_load_kms(struct drm_device *dev, unsigned long flags);
 int radeon_driver_unload_kms(struct drm_device *dev);

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

@@ -220,8 +220,8 @@ int radeon_gem_info_ioctl(struct drm_device dev, void data, · 219 unmodified lines
220		220
221	man = &rdev->mman.bdev.man[TTM_PL_VRAM];	221	man = &rdev->mman.bdev.man[TTM_PL_VRAM];
222		222
223	args->vram_size = rdev->mc.real_vram_size;	223	args->vram_size = (u64)man->size << PAGE_SHIFT;
224	args->vram_visible = (u64)man->size << PAGE_SHIFT;	224	args->vram_visible = rdev->mc.visible_vram_size;
225	args->vram_visible -= rdev->vram_pin_size;	225	args->vram_visible -= rdev->vram_pin_size;
226	args->gart_size = rdev->mc.gtt_size;	226	args->gart_size = rdev->mc.gtt_size;
227	args->gart_size -= rdev->gart_pin_size;	227	args->gart_size -= rdev->gart_pin_size;

drivers/hid/hid-cp2112.c+12−16

 	atomic_t xfer_avail;
 	struct gpio_chip gc;
 	u8 *in_out_buffer;
-	spinlock_t lock;
+	struct mutex lock;
 	struct gpio_desc *desc[8];
 	bool gpio_poll;
 	struct cp2112_device *dev = gpiochip_get_data(chip);
 	struct hid_device *hdev = dev->hdev;
 	u8 *buf = dev->in_out_buffer;
-	unsigned long flags;
 	int ret;
-	spin_lock_irqsave(&dev->lock, flags);
+	mutex_lock(&dev->lock);
 	ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
 				 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
 	ret = 0;
 exit:
-	spin_unlock_irqrestore(&dev->lock, flags);
+	mutex_unlock(&dev->lock);
-	return ret <= 0 ? ret : -EIO;
+	return ret < 0 ? ret : -EIO;
 }
 static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 	struct cp2112_device *dev = gpiochip_get_data(chip);
 	struct hid_device *hdev = dev->hdev;
 	u8 *buf = dev->in_out_buffer;
-	unsigned long flags;
 	int ret;
-	spin_lock_irqsave(&dev->lock, flags);
+	mutex_lock(&dev->lock);
 	buf[0] = CP2112_GPIO_SET;
 	buf[1] = value ? 0xff : 0;
 	if (ret < 0)
 		hid_err(hdev, "error setting GPIO values: %d\n", ret);
-	spin_unlock_irqrestore(&dev->lock, flags);
+	mutex_unlock(&dev->lock);
 }
 static int cp2112_gpio_get_all(struct gpio_chip *chip)
 	struct cp2112_device *dev = gpiochip_get_data(chip);
 	struct hid_device *hdev = dev->hdev;
 	u8 *buf = dev->in_out_buffer;
-	unsigned long flags;
 	int ret;
-	spin_lock_irqsave(&dev->lock, flags);
+	mutex_lock(&dev->lock);
 	ret = hid_hw_raw_request(hdev, CP2112_GPIO_GET, buf,
 				 CP2112_GPIO_GET_LENGTH, HID_FEATURE_REPORT,
 	ret = buf[1];
 exit:
-	spin_unlock_irqrestore(&dev->lock, flags);
+	mutex_unlock(&dev->lock);
 	return ret;
 }
 	struct cp2112_device *dev = gpiochip_get_data(chip);
 	struct hid_device *hdev = dev->hdev;
 	u8 *buf = dev->in_out_buffer;
-	unsigned long flags;
 	int ret;
-	spin_lock_irqsave(&dev->lock, flags);
+	mutex_lock(&dev->lock);
 	ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
 				 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
 		goto fail;
 	}
-	spin_unlock_irqrestore(&dev->lock, flags);
+	mutex_unlock(&dev->lock);
 	/*
 	 * Set gpio value when output direction is already set,
 	return 0;
 fail:
-	spin_unlock_irqrestore(&dev->lock, flags);
+	mutex_unlock(&dev->lock);
 	return ret < 0 ? ret : -EIO;
 }
 	if (!dev->in_out_buffer)
 		return -ENOMEM;
-	spin_lock_init(&dev->lock);
+	mutex_init(&dev->lock);
 	ret = hid_parse(hdev);
 	if (ret) {

drivers/hid/hid-ids.h+3−0

@@ -76,6 +76,9 @@ · 75 unmodified lines
76	#define USB_VENDOR_ID_ALPS_JP 0x044E	76	#define USB_VENDOR_ID_ALPS_JP 0x044E
77	#define HID_DEVICE_ID_ALPS_U1_DUAL 0x120B	77	#define HID_DEVICE_ID_ALPS_U1_DUAL 0x120B
78		78
		79	#define USB_VENDOR_ID_AMI 0x046b
		80	#define USB_DEVICE_ID_AMI_VIRT_KEYBOARD_AND_MOUSE 0xff10
		81
79	#define USB_VENDOR_ID_ANTON 0x1130	82	#define USB_VENDOR_ID_ANTON 0x1130
80	#define USB_DEVICE_ID_ANTON_TOUCH_PAD 0x3101	83	#define USB_DEVICE_ID_ANTON_TOUCH_PAD 0x3101
81		84

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

@@ -872,7 +872,7 @@ static const struct hid_device_id lg_devices[] = { · 871 unmodified lines
872	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG),	872	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG),
873	.driver_data = LG_NOGET \| LG_FF4 },	873	.driver_data = LG_NOGET \| LG_FF4 },
874	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2),	874	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2),
875	.driver_data = LG_FF2 },	875	.driver_data = LG_NOGET \| LG_FF2 },
876	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940),	876	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940),
877	.driver_data = LG_FF3 },	877	.driver_data = LG_FF3 },
878	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR),	878	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR),

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

@@ -57,6 +57,7 @@ static const struct hid_blacklist { · 56 unmodified lines
57	{ USB_VENDOR_ID_AIREN, USB_DEVICE_ID_AIREN_SLIMPLUS, HID_QUIRK_NOGET },	57	{ USB_VENDOR_ID_AIREN, USB_DEVICE_ID_AIREN_SLIMPLUS, HID_QUIRK_NOGET },
58	{ USB_VENDOR_ID_AKAI, USB_DEVICE_ID_AKAI_MPKMINI2, HID_QUIRK_NO_INIT_REPORTS },	58	{ USB_VENDOR_ID_AKAI, USB_DEVICE_ID_AKAI_MPKMINI2, HID_QUIRK_NO_INIT_REPORTS },
59	{ USB_VENDOR_ID_AKAI_09E8, USB_DEVICE_ID_AKAI_09E8_MIDIMIX, HID_QUIRK_NO_INIT_REPORTS },	59	{ USB_VENDOR_ID_AKAI_09E8, USB_DEVICE_ID_AKAI_09E8_MIDIMIX, HID_QUIRK_NO_INIT_REPORTS },
		60	{ USB_VENDOR_ID_AMI, USB_DEVICE_ID_AMI_VIRT_KEYBOARD_AND_MOUSE, HID_QUIRK_ALWAYS_POLL },
60	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM, HID_QUIRK_NOGET },	61	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM, HID_QUIRK_NOGET },
61	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_CS124U, HID_QUIRK_NOGET },	62	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_CS124U, HID_QUIRK_NOGET },
62	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET },	63	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET },

drivers/hid/wacom_wac.c+15−13

@@ -166,19 +166,21 @@ static int wacom_pl_irq(struct wacom_wac *wacom) · 165 unmodified lines
166	wacom->id[0] = STYLUS_DEVICE_ID;	166	wacom->id[0] = STYLUS_DEVICE_ID;
167	}	167	}
168		168
169	pressure = (signed char)((data[7] << 1) \| ((data[4] >> 2) & 1));	169	if (prox) {
170	if (features->pressure_max > 255)	170	pressure = (signed char)((data[7] << 1) \| ((data[4] >> 2) & 1));
171	pressure = (pressure << 1) \| ((data[4] >> 6) & 1);	171	if (features->pressure_max > 255)
172	pressure += (features->pressure_max + 1) / 2;	172	pressure = (pressure << 1) \| ((data[4] >> 6) & 1);
173		173	pressure += (features->pressure_max + 1) / 2;
174	input_report_abs(input, ABS_X, data[3] \| (data[2] << 7) \| ((data[1] & 0x03) << 14));	174
175	input_report_abs(input, ABS_Y, data[6] \| (data[5] << 7) \| ((data[4] & 0x03) << 14));	175	input_report_abs(input, ABS_X, data[3] \| (data[2] << 7) \| ((data[1] & 0x03) << 14));
176	input_report_abs(input, ABS_PRESSURE, pressure);	176	input_report_abs(input, ABS_Y, data[6] \| (data[5] << 7) \| ((data[4] & 0x03) << 14));
177		177	input_report_abs(input, ABS_PRESSURE, pressure);
178	input_report_key(input, BTN_TOUCH, data[4] & 0x08);	178
179	input_report_key(input, BTN_STYLUS, data[4] & 0x10);	179	input_report_key(input, BTN_TOUCH, data[4] & 0x08);
180	/* Only allow the stylus2 button to be reported for the pen tool. */	180	input_report_key(input, BTN_STYLUS, data[4] & 0x10);
181	input_report_key(input, BTN_STYLUS2, (wacom->tool[0] == BTN_TOOL_PEN) && (data[4] & 0x20));	181	/* Only allow the stylus2 button to be reported for the pen tool. */
		182	input_report_key(input, BTN_STYLUS2, (wacom->tool[0] == BTN_TOOL_PEN) && (data[4] & 0x20));
		183	}
182		184
183	if (!prox)	185	if (!prox)
184	wacom->id[0] = 0;	186	wacom->id[0] = 0;

drivers/hv/ring_buffer.c+1−0

@@ -383,6 +383,7 @@ int hv_ringbuffer_read(struct vmbus_channel *channel, · 382 unmodified lines
383	return ret;	383	return ret;
384	}	384	}
385		385
		386	init_cached_read_index(channel);
386	next_read_location = hv_get_next_read_location(inring_info);	387	next_read_location = hv_get_next_read_location(inring_info);
387	next_read_location = hv_copyfrom_ringbuffer(inring_info, &desc,	388	next_read_location = hv_copyfrom_ringbuffer(inring_info, &desc,
388	sizeof(desc),	389	sizeof(desc),

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

@@ -775,7 +775,7 @@ static int palmas_adc_wakeup_reset(struct palmas_gpadc *adc) · 774 unmodified lines
775		775
776	static int palmas_gpadc_suspend(struct device *dev)	776	static int palmas_gpadc_suspend(struct device *dev)
777	{	777	{
778	struct iio_dev *indio_dev = dev_to_iio_dev(dev);	778	struct iio_dev *indio_dev = dev_get_drvdata(dev);
779	struct palmas_gpadc *adc = iio_priv(indio_dev);	779	struct palmas_gpadc *adc = iio_priv(indio_dev);
780	int wakeup = adc->wakeup1_enable \|\| adc->wakeup2_enable;	780	int wakeup = adc->wakeup1_enable \|\| adc->wakeup2_enable;
781	int ret;	781	int ret;
@@ -798,7 +798,7 @@ static int palmas_gpadc_suspend(struct device *dev) · 16 unmodified lines
798		798
799	static int palmas_gpadc_resume(struct device *dev)	799	static int palmas_gpadc_resume(struct device *dev)
800	{	800	{
801	struct iio_dev *indio_dev = dev_to_iio_dev(dev);	801	struct iio_dev *indio_dev = dev_get_drvdata(dev);
802	struct palmas_gpadc *adc = iio_priv(indio_dev);	802	struct palmas_gpadc *adc = iio_priv(indio_dev);
803	int wakeup = adc->wakeup1_enable \|\| adc->wakeup2_enable;	803	int wakeup = adc->wakeup1_enable \|\| adc->wakeup2_enable;
804	int ret;	804	int ret;

drivers/iio/health/afe4403.c+2−2

@@ -422,7 +422,7 @@ MODULE_DEVICE_TABLE(of, afe4403_of_match); · 421 unmodified lines
422		422
423	static int __maybe_unused afe4403_suspend(struct device *dev)	423	static int __maybe_unused afe4403_suspend(struct device *dev)
424	{	424	{
425	struct iio_dev *indio_dev = dev_to_iio_dev(dev);	425	struct iio_dev *indio_dev = spi_get_drvdata(to_spi_device(dev));
426	struct afe4403_data *afe = iio_priv(indio_dev);	426	struct afe4403_data *afe = iio_priv(indio_dev);
427	int ret;	427	int ret;
428		428
@@ -443,7 +443,7 @@ static int __maybe_unused afe4403_suspend(struct device *dev) · 14 unmodified lines
443		443
444	static int __maybe_unused afe4403_resume(struct device *dev)	444	static int __maybe_unused afe4403_resume(struct device *dev)
445	{	445	{
446	struct iio_dev *indio_dev = dev_to_iio_dev(dev);	446	struct iio_dev *indio_dev = spi_get_drvdata(to_spi_device(dev));
447	struct afe4403_data *afe = iio_priv(indio_dev);	447	struct afe4403_data *afe = iio_priv(indio_dev);
448	int ret;	448	int ret;
449		449

drivers/iio/health/afe4404.c+2−2

@@ -428,7 +428,7 @@ MODULE_DEVICE_TABLE(of, afe4404_of_match); · 427 unmodified lines
428		428
429	static int __maybe_unused afe4404_suspend(struct device *dev)	429	static int __maybe_unused afe4404_suspend(struct device *dev)
430	{	430	{
431	struct iio_dev *indio_dev = dev_to_iio_dev(dev);	431	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
432	struct afe4404_data *afe = iio_priv(indio_dev);	432	struct afe4404_data *afe = iio_priv(indio_dev);
433	int ret;	433	int ret;
434		434
@@ -449,7 +449,7 @@ static int __maybe_unused afe4404_suspend(struct device *dev) · 14 unmodified lines
449		449
450	static int __maybe_unused afe4404_resume(struct device *dev)	450	static int __maybe_unused afe4404_resume(struct device *dev)
451	{	451	{
452	struct iio_dev *indio_dev = dev_to_iio_dev(dev);	452	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
453	struct afe4404_data *afe = iio_priv(indio_dev);	453	struct afe4404_data *afe = iio_priv(indio_dev);
454	int ret;	454	int ret;
455		455

drivers/iio/health/max30100.c+1−1

@@ -238,7 +238,7 @@ static irqreturn_t max30100_interrupt_handler(int irq, void *private) · 237 unmodified lines
238		238
239	mutex_lock(&data->lock);	239	mutex_lock(&data->lock);
240		240
241	while (cnt \|\| (cnt = max30100_fifo_count(data) > 0)) {	241	while (cnt \|\| (cnt = max30100_fifo_count(data)) > 0) {
242	ret = max30100_read_measurement(data);	242	ret = max30100_read_measurement(data);
243	if (ret)	243	if (ret)
244	break;	244	break;

drivers/iio/humidity/dht11.c+4−2

  * a) select an implementation using busy loop polling on those systems
  * b) use the checksum to do some probabilistic decoding
  */
-#define DHT11_START_TRANSMISSION	18  /* ms */
+#define DHT11_START_TRANSMISSION_MIN	18000  /* us */
+#define DHT11_START_TRANSMISSION_MAX	20000  /* us */
 #define DHT11_MIN_TIMERES	34000  /* ns */
 #define DHT11_THRESHOLD		49000  /* ns */
 #define DHT11_AMBIG_LOW		23000  /* ns */
 		ret = gpio_direction_output(dht11->gpio, 0);
 		if (ret)
 			goto err;
-		msleep(DHT11_START_TRANSMISSION);
+		usleep_range(DHT11_START_TRANSMISSION_MIN,
+			     DHT11_START_TRANSMISSION_MAX);
 		ret = gpio_direction_input(dht11->gpio);
 		if (ret)
 			goto err;

drivers/input/rmi4/rmi_driver.c+2−2

@@ -901,7 +901,7 @@ void rmi_enable_irq(struct rmi_device *rmi_dev, bool clear_wake) · 900 unmodified lines
901	data->enabled = true;	901	data->enabled = true;
902	if (clear_wake && device_may_wakeup(rmi_dev->xport->dev)) {	902	if (clear_wake && device_may_wakeup(rmi_dev->xport->dev)) {
903	retval = disable_irq_wake(irq);	903	retval = disable_irq_wake(irq);
904	if (!retval)	904	if (retval)
905	dev_warn(&rmi_dev->dev,	905	dev_warn(&rmi_dev->dev,
906	"Failed to disable irq for wake: %d\n",	906	"Failed to disable irq for wake: %d\n",
907	retval);	907	retval);
@@ -936,7 +936,7 @@ void rmi_disable_irq(struct rmi_device *rmi_dev, bool enable_wake) · 28 unmodified lines
936	disable_irq(irq);	936	disable_irq(irq);
937	if (enable_wake && device_may_wakeup(rmi_dev->xport->dev)) {	937	if (enable_wake && device_may_wakeup(rmi_dev->xport->dev)) {
938	retval = enable_irq_wake(irq);	938	retval = enable_irq_wake(irq);
939	if (!retval)	939	if (retval)
940	dev_warn(&rmi_dev->dev,	940	dev_warn(&rmi_dev->dev,
941	"Failed to enable irq for wake: %d\n",	941	"Failed to enable irq for wake: %d\n",
942	retval);	942	retval);

drivers/input/touchscreen/wm97xx-core.c+1−1

@@ -682,7 +682,7 @@ static int wm97xx_probe(struct device *dev) · 681 unmodified lines
682	}	682	}
683	platform_set_drvdata(wm->battery_dev, wm);	683	platform_set_drvdata(wm->battery_dev, wm);
684	wm->battery_dev->dev.parent = dev;	684	wm->battery_dev->dev.parent = dev;
685	wm->battery_dev->dev.platform_data = pdata->batt_pdata;	685	wm->battery_dev->dev.platform_data = pdata ? pdata->batt_pdata : NULL;
686	ret = platform_device_add(wm->battery_dev);	686	ret = platform_device_add(wm->battery_dev);
687	if (ret < 0)	687	if (ret < 0)
688	goto batt_reg_err;	688	goto batt_reg_err;

drivers/mmc/host/sdhci.c+2−1

@@ -2733,7 +2733,8 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id) · 2732 unmodified lines
2733	if (intmask & SDHCI_INT_RETUNE)	2733	if (intmask & SDHCI_INT_RETUNE)
2734	mmc_retune_needed(host->mmc);	2734	mmc_retune_needed(host->mmc);
2735		2735
2736	if (intmask & SDHCI_INT_CARD_INT) {	2736	if ((intmask & SDHCI_INT_CARD_INT) &&
		2737	(host->ier & SDHCI_INT_CARD_INT)) {
2737	sdhci_enable_sdio_irq_nolock(host, false);	2738	sdhci_enable_sdio_irq_nolock(host, false);
2738	host->thread_isr \|= SDHCI_INT_CARD_INT;	2739	host->thread_isr \|= SDHCI_INT_CARD_INT;
2739	result = IRQ_WAKE_THREAD;	2740	result = IRQ_WAKE_THREAD;

drivers/net/ethernet/adaptec/starfire.c+43−2

@@ -1152,6 +1152,12 @@ static void init_ring(struct net_device *dev) · 1151 unmodified lines
1152	if (skb == NULL)	1152	if (skb == NULL)
1153	break;	1153	break;
1154	np->rx_info[i].mapping = pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);	1154	np->rx_info[i].mapping = pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
		1155	if (pci_dma_mapping_error(np->pci_dev,
		1156	np->rx_info[i].mapping)) {
		1157	dev_kfree_skb(skb);
		1158	np->rx_info[i].skb = NULL;
		1159	break;
		1160	}
1155	/* Grrr, we cannot offset to correctly align the IP header. */	1161	/* Grrr, we cannot offset to correctly align the IP header. */
1156	np->rx_ring[i].rxaddr = cpu_to_dma(np->rx_info[i].mapping \| RxDescValid);	1162	np->rx_ring[i].rxaddr = cpu_to_dma(np->rx_info[i].mapping \| RxDescValid);
1157	}	1163	}
@@ -1182,8 +1188,9 @@ static netdev_tx_t start_tx(struct sk_buff skb, struct net_device dev) · 24 unmodified lines
1182	{	1188	{
1183	struct netdev_private *np = netdev_priv(dev);	1189	struct netdev_private *np = netdev_priv(dev);
1184	unsigned int entry;	1190	unsigned int entry;
		1191	unsigned int prev_tx;
1185	u32 status;	1192	u32 status;
1186	int i;	1193	int i, j;
1187		1194
1188	/*	1195	/*
1189	* be cautious here, wrapping the queue has weird semantics	1196	* be cautious here, wrapping the queue has weird semantics
@@ -1201,6 +1208,7 @@ static netdev_tx_t start_tx(struct sk_buff skb, struct net_device dev) · 11 unmodified lines
1201	}	1208	}
1202	#endif /* ZEROCOPY && HAS_BROKEN_FIRMWARE */	1209	#endif /* ZEROCOPY && HAS_BROKEN_FIRMWARE */
1203		1210
		1211	prev_tx = np->cur_tx;
1204	entry = np->cur_tx % TX_RING_SIZE;	1212	entry = np->cur_tx % TX_RING_SIZE;
1205	for (i = 0; i < skb_num_frags(skb); i++) {	1213	for (i = 0; i < skb_num_frags(skb); i++) {
1206	int wrap_ring = 0;	1214	int wrap_ring = 0;
@@ -1234,6 +1242,11 @@ static netdev_tx_t start_tx(struct sk_buff skb, struct net_device dev) · 27 unmodified lines
1234	skb_frag_size(this_frag),	1242	skb_frag_size(this_frag),
1235	PCI_DMA_TODEVICE);	1243	PCI_DMA_TODEVICE);
1236	}	1244	}
		1245	if (pci_dma_mapping_error(np->pci_dev,
		1246	np->tx_info[entry].mapping)) {
		1247	dev->stats.tx_dropped++;
		1248	goto err_out;
		1249	}
1237		1250
1238	np->tx_ring[entry].addr = cpu_to_dma(np->tx_info[entry].mapping);	1251	np->tx_ring[entry].addr = cpu_to_dma(np->tx_info[entry].mapping);
1239	np->tx_ring[entry].status = cpu_to_le32(status);	1252	np->tx_ring[entry].status = cpu_to_le32(status);
@@ -1268,8 +1281,30 @@ static netdev_tx_t start_tx(struct sk_buff skb, struct net_device dev) · 28 unmodified lines
1268	netif_stop_queue(dev);	1281	netif_stop_queue(dev);
1269		1282
1270	return NETDEV_TX_OK;	1283	return NETDEV_TX_OK;
1271	}
1272		1284
		1285	err_out:
		1286	entry = prev_tx % TX_RING_SIZE;
		1287	np->tx_info[entry].skb = NULL;
		1288	if (i > 0) {
		1289	pci_unmap_single(np->pci_dev,
		1290	np->tx_info[entry].mapping,
		1291	skb_first_frag_len(skb),
		1292	PCI_DMA_TODEVICE);
		1293	np->tx_info[entry].mapping = 0;
		1294	entry = (entry + np->tx_info[entry].used_slots) % TX_RING_SIZE;
		1295	for (j = 1; j < i; j++) {
		1296	pci_unmap_single(np->pci_dev,
		1297	np->tx_info[entry].mapping,
		1298	skb_frag_size(
		1299	&skb_shinfo(skb)->frags[j-1]),
		1300	PCI_DMA_TODEVICE);
		1301	entry++;
		1302	}
		1303	}
		1304	dev_kfree_skb_any(skb);
		1305	np->cur_tx = prev_tx;
		1306	return NETDEV_TX_OK;
		1307	}
1273		1308
1274	/* The interrupt handler does all of the Rx thread work and cleans up	1309	/* The interrupt handler does all of the Rx thread work and cleans up
1275	after the Tx thread. */	1310	after the Tx thread. */
@@ -1569,6 +1604,12 @@ static void refill_rx_ring(struct net_device *dev) · 293 unmodified lines
1569	break; /* Better luck next round. */	1604	break; /* Better luck next round. */
1570	np->rx_info[entry].mapping =	1605	np->rx_info[entry].mapping =
1571	pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);	1606	pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
		1607	if (pci_dma_mapping_error(np->pci_dev,
		1608	np->rx_info[entry].mapping)) {
		1609	dev_kfree_skb(skb);
		1610	np->rx_info[entry].skb = NULL;
		1611	break;
		1612	}
1572	np->rx_ring[entry].rxaddr =	1613	np->rx_ring[entry].rxaddr =
1573	cpu_to_dma(np->rx_info[entry].mapping \| RxDescValid);	1614	cpu_to_dma(np->rx_info[entry].mapping \| RxDescValid);
1574	}	1615	}

drivers/net/ethernet/cadence/macb.c+130−58

@@ -43,13 +43,13 @@ · 42 unmodified lines
43	#define DEFAULT_RX_RING_SIZE 512 /* must be power of 2 */	43	#define DEFAULT_RX_RING_SIZE 512 /* must be power of 2 */
44	#define MIN_RX_RING_SIZE 64	44	#define MIN_RX_RING_SIZE 64
45	#define MAX_RX_RING_SIZE 8192	45	#define MAX_RX_RING_SIZE 8192
46	#define RX_RING_BYTES(bp) (sizeof(struct macb_dma_desc) \	46	#define RX_RING_BYTES(bp) (macb_dma_desc_get_size(bp) \
47	* (bp)->rx_ring_size)	47	* (bp)->rx_ring_size)
48		48
49	#define DEFAULT_TX_RING_SIZE 512 /* must be power of 2 */	49	#define DEFAULT_TX_RING_SIZE 512 /* must be power of 2 */
50	#define MIN_TX_RING_SIZE 64	50	#define MIN_TX_RING_SIZE 64
51	#define MAX_TX_RING_SIZE 4096	51	#define MAX_TX_RING_SIZE 4096
52	#define TX_RING_BYTES(bp) (sizeof(struct macb_dma_desc) \	52	#define TX_RING_BYTES(bp) (macb_dma_desc_get_size(bp) \
53	* (bp)->tx_ring_size)	53	* (bp)->tx_ring_size)
54		54
55	/* level of occupied TX descriptors under which we wake up TX process */	55	/* level of occupied TX descriptors under which we wake up TX process */
@@ -78,6 +78,37 @@ · 22 unmodified lines
78	*/	78	*/
79	#define MACB_HALT_TIMEOUT 1230	79	#define MACB_HALT_TIMEOUT 1230
80		80
		81	/* DMA buffer descriptor might be different size
		82	* depends on hardware configuration.
		83	*/
		84	static unsigned int macb_dma_desc_get_size(struct macb *bp)
		85	{
		86	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
		87	if (bp->hw_dma_cap == HW_DMA_CAP_64B)
		88	return sizeof(struct macb_dma_desc) + sizeof(struct macb_dma_desc_64);
		89	#endif
		90	return sizeof(struct macb_dma_desc);
		91	}
		92
		93	static unsigned int macb_adj_dma_desc_idx(struct macb *bp, unsigned int idx)
		94	{
		95	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
		96	/* Dma buffer descriptor is 4 words length (instead of 2 words)
		97	* for 64b GEM.
		98	*/
		99	if (bp->hw_dma_cap == HW_DMA_CAP_64B)
		100	idx <<= 1;
		101	#endif
		102	return idx;
		103	}
		104
		105	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
		106	static struct macb_dma_desc_64 macb_64b_desc(struct macb bp, struct macb_dma_desc *desc)
		107	{
		108	return (struct macb_dma_desc_64 )((void )desc + sizeof(struct macb_dma_desc));
		109	}
		110	#endif
		111
81	/* Ring buffer accessors */	112	/* Ring buffer accessors */
82	static unsigned int macb_tx_ring_wrap(struct macb *bp, unsigned int index)	113	static unsigned int macb_tx_ring_wrap(struct macb *bp, unsigned int index)
83	{	114	{
@@ -87,7 +118,9 @@ static unsigned int macb_tx_ring_wrap(struct macb *bp, unsigned int index) · 3 unmodified lines
87	static struct macb_dma_desc macb_tx_desc(struct macb_queue queue,	118	static struct macb_dma_desc macb_tx_desc(struct macb_queue queue,
88	unsigned int index)	119	unsigned int index)
89	{	120	{
90	return &queue->tx_ring[macb_tx_ring_wrap(queue->bp, index)];	121	index = macb_tx_ring_wrap(queue->bp, index);
		122	index = macb_adj_dma_desc_idx(queue->bp, index);
		123	return &queue->tx_ring[index];
91	}	124	}
92		125
93	static struct macb_tx_skb macb_tx_skb(struct macb_queue queue,	126	static struct macb_tx_skb macb_tx_skb(struct macb_queue queue,
@@ -101,7 +134,7 @@ static dma_addr_t macb_tx_dma(struct macb_queue *queue, unsigned int index) · 7 unmodified lines
101	dma_addr_t offset;	134	dma_addr_t offset;
102		135
103	offset = macb_tx_ring_wrap(queue->bp, index) *	136	offset = macb_tx_ring_wrap(queue->bp, index) *
104	sizeof(struct macb_dma_desc);	137	macb_dma_desc_get_size(queue->bp);
105		138
106	return queue->tx_ring_dma + offset;	139	return queue->tx_ring_dma + offset;
107	}	140	}
@@ -113,7 +146,9 @@ static unsigned int macb_rx_ring_wrap(struct macb *bp, unsigned int index) · 5 unmodified lines
113		146
114	static struct macb_dma_desc macb_rx_desc(struct macb bp, unsigned int index)	147	static struct macb_dma_desc macb_rx_desc(struct macb bp, unsigned int index)
115	{	148	{
116	return &bp->rx_ring[macb_rx_ring_wrap(bp, index)];	149	index = macb_rx_ring_wrap(bp, index);
		150	index = macb_adj_dma_desc_idx(bp, index);
		151	return &bp->rx_ring[index];
117	}	152	}
118		153
119	static void macb_rx_buffer(struct macb bp, unsigned int index)	154	static void macb_rx_buffer(struct macb bp, unsigned int index)
@@ -560,12 +595,32 @@ static void macb_tx_unmap(struct macb bp, struct macb_tx_skb tx_skb) · 440 unmodified lines
560	}	595	}
561	}	596	}
562		597
563	static inline void macb_set_addr(struct macb_dma_desc *desc, dma_addr_t addr)	598	static void macb_set_addr(struct macb bp, struct macb_dma_desc desc, dma_addr_t addr)
564	{	599	{
565	desc->addr = (u32)addr;
566	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT	600	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
567	desc->addrh = (u32)(addr >> 32);	601	struct macb_dma_desc_64 *desc_64;
		602
		603	if (bp->hw_dma_cap == HW_DMA_CAP_64B) {
		604	desc_64 = macb_64b_desc(bp, desc);
		605	desc_64->addrh = upper_32_bits(addr);
		606	}
568	#endif	607	#endif
		608	desc->addr = lower_32_bits(addr);
		609	}
		610
		611	static dma_addr_t macb_get_addr(struct macb bp, struct macb_dma_desc desc)
		612	{
		613	dma_addr_t addr = 0;
		614	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
		615	struct macb_dma_desc_64 *desc_64;
		616
		617	if (bp->hw_dma_cap == HW_DMA_CAP_64B) {
		618	desc_64 = macb_64b_desc(bp, desc);
		619	addr = ((u64)(desc_64->addrh) << 32);
		620	}
		621	#endif
		622	addr \|= MACB_BF(RX_WADDR, MACB_BFEXT(RX_WADDR, desc->addr));
		623	return addr;
569	}	624	}
570		625
571	static void macb_tx_error_task(struct work_struct *work)	626	static void macb_tx_error_task(struct work_struct *work)
@@ -649,16 +704,17 @@ static void macb_tx_error_task(struct work_struct *work) · 77 unmodified lines
649		704
650	/* Set end of TX queue */	705	/* Set end of TX queue */
651	desc = macb_tx_desc(queue, 0);	706	desc = macb_tx_desc(queue, 0);
652	macb_set_addr(desc, 0);	707	macb_set_addr(bp, desc, 0);
653	desc->ctrl = MACB_BIT(TX_USED);	708	desc->ctrl = MACB_BIT(TX_USED);
654		709
655	/* Make descriptor updates visible to hardware */	710	/* Make descriptor updates visible to hardware */
656	wmb();	711	wmb();
657		712
658	/* Reinitialize the TX desc queue */	713	/* Reinitialize the TX desc queue */
659	queue_writel(queue, TBQP, (u32)(queue->tx_ring_dma));	714	queue_writel(queue, TBQP, lower_32_bits(queue->tx_ring_dma));
660	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT	715	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
661	queue_writel(queue, TBQPH, (u32)(queue->tx_ring_dma >> 32));	716	if (bp->hw_dma_cap == HW_DMA_CAP_64B)
		717	queue_writel(queue, TBQPH, upper_32_bits(queue->tx_ring_dma));
662	#endif	718	#endif
663	/* Make TX ring reflect state of hardware */	719	/* Make TX ring reflect state of hardware */
664	queue->tx_head = 0;	720	queue->tx_head = 0;
@@ -750,6 +806,7 @@ static void gem_rx_refill(struct macb *bp) · 85 unmodified lines
750	unsigned int entry;	806	unsigned int entry;
751	struct sk_buff *skb;	807	struct sk_buff *skb;
752	dma_addr_t paddr;	808	dma_addr_t paddr;
		809	struct macb_dma_desc *desc;
753		810
754	while (CIRC_SPACE(bp->rx_prepared_head, bp->rx_tail,	811	while (CIRC_SPACE(bp->rx_prepared_head, bp->rx_tail,
755	bp->rx_ring_size) > 0) {	812	bp->rx_ring_size) > 0) {
@@ -759,6 +816,7 @@ static void gem_rx_refill(struct macb *bp) · 3 unmodified lines
759	rmb();	816	rmb();
760		817
761	bp->rx_prepared_head++;	818	bp->rx_prepared_head++;
		819	desc = macb_rx_desc(bp, entry);
762		820
763	if (!bp->rx_skbuff[entry]) {	821	if (!bp->rx_skbuff[entry]) {
764	/* allocate sk_buff for this free entry in ring */	822	/* allocate sk_buff for this free entry in ring */
@@ -782,14 +840,14 @@ static void gem_rx_refill(struct macb *bp) · 17 unmodified lines
782		840
783	if (entry == bp->rx_ring_size - 1)	841	if (entry == bp->rx_ring_size - 1)
784	paddr \|= MACB_BIT(RX_WRAP);	842	paddr \|= MACB_BIT(RX_WRAP);
785	macb_set_addr(&(bp->rx_ring[entry]), paddr);	843	macb_set_addr(bp, desc, paddr);
786	bp->rx_ring[entry].ctrl = 0;	844	desc->ctrl = 0;
787		845
788	/* properly align Ethernet header */	846	/* properly align Ethernet header */
789	skb_reserve(skb, NET_IP_ALIGN);	847	skb_reserve(skb, NET_IP_ALIGN);
790	} else {	848	} else {
791	bp->rx_ring[entry].addr &= ~MACB_BIT(RX_USED);	849	desc->addr &= ~MACB_BIT(RX_USED);
792	bp->rx_ring[entry].ctrl = 0;	850	desc->ctrl = 0;
793	}	851	}
794	}	852	}
795		853
@@ -835,16 +893,13 @@ static int gem_rx(struct macb *bp, int budget) · 39 unmodified lines
835	bool rxused;	893	bool rxused;
836		894
837	entry = macb_rx_ring_wrap(bp, bp->rx_tail);	895	entry = macb_rx_ring_wrap(bp, bp->rx_tail);
838	desc = &bp->rx_ring[entry];	896	desc = macb_rx_desc(bp, entry);
839		897
840	/* Make hw descriptor updates visible to CPU */	898	/* Make hw descriptor updates visible to CPU */
841	rmb();	899	rmb();
842		900
843	rxused = (desc->addr & MACB_BIT(RX_USED)) ? true : false;	901	rxused = (desc->addr & MACB_BIT(RX_USED)) ? true : false;
844	addr = MACB_BF(RX_WADDR, MACB_BFEXT(RX_WADDR, desc->addr));	902	addr = macb_get_addr(bp, desc);
845	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
846	addr \|= ((u64)(desc->addrh) << 32);
847	#endif
848	ctrl = desc->ctrl;	903	ctrl = desc->ctrl;
849		904
850	if (!rxused)	905	if (!rxused)
@@ -987,15 +1042,17 @@ static int macb_rx_frame(struct macb *bp, unsigned int first_frag, · 136 unmodified lines
987	static inline void macb_init_rx_ring(struct macb *bp)	1042	static inline void macb_init_rx_ring(struct macb *bp)
988	{	1043	{
989	dma_addr_t addr;	1044	dma_addr_t addr;
		1045	struct macb_dma_desc *desc = NULL;
990	int i;	1046	int i;
991		1047
992	addr = bp->rx_buffers_dma;	1048	addr = bp->rx_buffers_dma;
993	for (i = 0; i < bp->rx_ring_size; i++) {	1049	for (i = 0; i < bp->rx_ring_size; i++) {
994	bp->rx_ring[i].addr = addr;	1050	desc = macb_rx_desc(bp, i);
995	bp->rx_ring[i].ctrl = 0;	1051	macb_set_addr(bp, desc, addr);
		1052	desc->ctrl = 0;
996	addr += bp->rx_buffer_size;	1053	addr += bp->rx_buffer_size;
997	}	1054	}
998	bp->rx_ring[bp->rx_ring_size - 1].addr \|= MACB_BIT(RX_WRAP);	1055	desc->addr \|= MACB_BIT(RX_WRAP);
999	bp->rx_tail = 0;	1056	bp->rx_tail = 0;
1000	}	1057	}
1001		1058
@@ -1008,15 +1065,14 @@ static int macb_rx(struct macb *bp, int budget) · 6 unmodified lines
1008		1065
1009	for (tail = bp->rx_tail; budget > 0; tail++) {	1066	for (tail = bp->rx_tail; budget > 0; tail++) {
1010	struct macb_dma_desc *desc = macb_rx_desc(bp, tail);	1067	struct macb_dma_desc *desc = macb_rx_desc(bp, tail);
1011	u32 addr, ctrl;	1068	u32 ctrl;
1012		1069
1013	/* Make hw descriptor updates visible to CPU */	1070	/* Make hw descriptor updates visible to CPU */
1014	rmb();	1071	rmb();
1015		1072
1016	addr = desc->addr;
1017	ctrl = desc->ctrl;	1073	ctrl = desc->ctrl;
1018		1074
1019	if (!(addr & MACB_BIT(RX_USED)))	1075	if (!(desc->addr & MACB_BIT(RX_USED)))
1020	break;	1076	break;
1021		1077
1022	if (ctrl & MACB_BIT(RX_SOF)) {	1078	if (ctrl & MACB_BIT(RX_SOF)) {
@@ -1336,7 +1392,7 @@ static unsigned int macb_tx_map(struct macb *bp, · 313 unmodified lines
1336	i = tx_head;	1392	i = tx_head;
1337	entry = macb_tx_ring_wrap(bp, i);	1393	entry = macb_tx_ring_wrap(bp, i);
1338	ctrl = MACB_BIT(TX_USED);	1394	ctrl = MACB_BIT(TX_USED);
1339	desc = &queue->tx_ring[entry];	1395	desc = macb_tx_desc(queue, entry);
1340	desc->ctrl = ctrl;	1396	desc->ctrl = ctrl;
1341		1397
1342	if (lso_ctrl) {	1398	if (lso_ctrl) {
@@ -1358,7 +1414,7 @@ static unsigned int macb_tx_map(struct macb *bp, · 15 unmodified lines
1358	i--;	1414	i--;
1359	entry = macb_tx_ring_wrap(bp, i);	1415	entry = macb_tx_ring_wrap(bp, i);
1360	tx_skb = &queue->tx_skb[entry];	1416	tx_skb = &queue->tx_skb[entry];
1361	desc = &queue->tx_ring[entry];	1417	desc = macb_tx_desc(queue, entry);
1362		1418
1363	ctrl = (u32)tx_skb->size;	1419	ctrl = (u32)tx_skb->size;
1364	if (eof) {	1420	if (eof) {
@@ -1379,7 +1435,7 @@ static unsigned int macb_tx_map(struct macb *bp, · 14 unmodified lines
1379	ctrl \|= MACB_BF(MSS_MFS, mss_mfs);	1435	ctrl \|= MACB_BF(MSS_MFS, mss_mfs);
1380		1436
1381	/* Set TX buffer descriptor */	1437	/* Set TX buffer descriptor */
1382	macb_set_addr(desc, tx_skb->mapping);	1438	macb_set_addr(bp, desc, tx_skb->mapping);
1383	/* desc->addr must be visible to hardware before clearing	1439	/* desc->addr must be visible to hardware before clearing
1384	* 'TX_USED' bit in desc->ctrl.	1440	* 'TX_USED' bit in desc->ctrl.
1385	*/	1441	*/
@@ -1586,11 +1642,9 @@ static void gem_free_rx_buffers(struct macb *bp) · 200 unmodified lines
1586	if (!skb)	1642	if (!skb)
1587	continue;	1643	continue;
1588		1644
1589	desc = &bp->rx_ring[i];	1645	desc = macb_rx_desc(bp, i);
1590	addr = MACB_BF(RX_WADDR, MACB_BFEXT(RX_WADDR, desc->addr));	1646	addr = macb_get_addr(bp, desc);
1591	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT	1647
1592	addr \|= ((u64)(desc->addrh) << 32);
1593	#endif
1594	dma_unmap_single(&bp->pdev->dev, addr, bp->rx_buffer_size,	1648	dma_unmap_single(&bp->pdev->dev, addr, bp->rx_buffer_size,
1595	DMA_FROM_DEVICE);	1649	DMA_FROM_DEVICE);
1596	dev_kfree_skb_any(skb);	1650	dev_kfree_skb_any(skb);
@@ -1711,15 +1765,17 @@ out_err: · 114 unmodified lines
1711	static void gem_init_rings(struct macb *bp)	1765	static void gem_init_rings(struct macb *bp)
1712	{	1766	{
1713	struct macb_queue *queue;	1767	struct macb_queue *queue;
		1768	struct macb_dma_desc *desc = NULL;
1714	unsigned int q;	1769	unsigned int q;
1715	int i;	1770	int i;
1716		1771
1717	for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {	1772	for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
1718	for (i = 0; i < bp->tx_ring_size; i++) {	1773	for (i = 0; i < bp->tx_ring_size; i++) {
1719	queue->tx_ring[i].addr = 0;	1774	desc = macb_tx_desc(queue, i);
1720	queue->tx_ring[i].ctrl = MACB_BIT(TX_USED);	1775	macb_set_addr(bp, desc, 0);
		1776	desc->ctrl = MACB_BIT(TX_USED);
1721	}	1777	}
1722	queue->tx_ring[bp->tx_ring_size - 1].ctrl \|= MACB_BIT(TX_WRAP);	1778	desc->ctrl \|= MACB_BIT(TX_WRAP);
1723	queue->tx_head = 0;	1779	queue->tx_head = 0;
1724	queue->tx_tail = 0;	1780	queue->tx_tail = 0;
1725	}	1781	}
@@ -1733,16 +1789,18 @@ static void gem_init_rings(struct macb *bp) · 7 unmodified lines
1733	static void macb_init_rings(struct macb *bp)	1789	static void macb_init_rings(struct macb *bp)
1734	{	1790	{
1735	int i;	1791	int i;
		1792	struct macb_dma_desc *desc = NULL;
1736		1793
1737	macb_init_rx_ring(bp);	1794	macb_init_rx_ring(bp);
1738		1795
1739	for (i = 0; i < bp->tx_ring_size; i++) {	1796	for (i = 0; i < bp->tx_ring_size; i++) {
1740	bp->queues[0].tx_ring[i].addr = 0;	1797	desc = macb_tx_desc(&bp->queues[0], i);
1741	bp->queues[0].tx_ring[i].ctrl = MACB_BIT(TX_USED);	1798	macb_set_addr(bp, desc, 0);
		1799	desc->ctrl = MACB_BIT(TX_USED);
1742	}	1800	}
1743	bp->queues[0].tx_head = 0;	1801	bp->queues[0].tx_head = 0;
1744	bp->queues[0].tx_tail = 0;	1802	bp->queues[0].tx_tail = 0;
1745	bp->queues[0].tx_ring[bp->tx_ring_size - 1].ctrl \|= MACB_BIT(TX_WRAP);	1803	desc->ctrl \|= MACB_BIT(TX_WRAP);
1746	}	1804	}
1747		1805
1748	static void macb_reset_hw(struct macb *bp)	1806	static void macb_reset_hw(struct macb *bp)
@@ -1863,7 +1921,8 @@ static void macb_configure_dma(struct macb *bp) · 114 unmodified lines
1863	dmacfg &= ~GEM_BIT(TXCOEN);	1921	dmacfg &= ~GEM_BIT(TXCOEN);
1864		1922
1865	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT	1923	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
1866	dmacfg \|= GEM_BIT(ADDR64);	1924	if (bp->hw_dma_cap == HW_DMA_CAP_64B)
		1925	dmacfg \|= GEM_BIT(ADDR64);
1867	#endif	1926	#endif
1868	netdev_dbg(bp->dev, "Cadence configure DMA with 0x%08x\n",	1927	netdev_dbg(bp->dev, "Cadence configure DMA with 0x%08x\n",
1869	dmacfg);	1928	dmacfg);
@@ -1910,14 +1969,16 @@ static void macb_init_hw(struct macb *bp) · 40 unmodified lines
1910	macb_configure_dma(bp);	1969	macb_configure_dma(bp);
1911		1970
1912	/* Initialize TX and RX buffers */	1971	/* Initialize TX and RX buffers */
1913	macb_writel(bp, RBQP, (u32)(bp->rx_ring_dma));	1972	macb_writel(bp, RBQP, lower_32_bits(bp->rx_ring_dma));
1914	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT	1973	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
1915	macb_writel(bp, RBQPH, (u32)(bp->rx_ring_dma >> 32));	1974	if (bp->hw_dma_cap == HW_DMA_CAP_64B)
		1975	macb_writel(bp, RBQPH, upper_32_bits(bp->rx_ring_dma));
1916	#endif	1976	#endif
1917	for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {	1977	for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue) {
1918	queue_writel(queue, TBQP, (u32)(queue->tx_ring_dma));	1978	queue_writel(queue, TBQP, lower_32_bits(queue->tx_ring_dma));
1919	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT	1979	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
1920	queue_writel(queue, TBQPH, (u32)(queue->tx_ring_dma >> 32));	1980	if (bp->hw_dma_cap == HW_DMA_CAP_64B)
		1981	queue_writel(queue, TBQPH, upper_32_bits(queue->tx_ring_dma));
1921	#endif	1982	#endif
1922		1983
1923	/* Enable interrupts */	1984	/* Enable interrupts */
@@ -2627,7 +2688,8 @@ static int macb_init(struct platform_device *pdev) · 703 unmodified lines
2627	queue->IMR = GEM_IMR(hw_q - 1);	2688	queue->IMR = GEM_IMR(hw_q - 1);
2628	queue->TBQP = GEM_TBQP(hw_q - 1);	2689	queue->TBQP = GEM_TBQP(hw_q - 1);
2629	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT	2690	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
2630	queue->TBQPH = GEM_TBQPH(hw_q -1);	2691	if (bp->hw_dma_cap == HW_DMA_CAP_64B)
		2692	queue->TBQPH = GEM_TBQPH(hw_q - 1);
2631	#endif	2693	#endif
2632	} else {	2694	} else {
2633	/* queue0 uses legacy registers */	2695	/* queue0 uses legacy registers */
@@ -2637,7 +2699,8 @@ static int macb_init(struct platform_device *pdev) · 3 unmodified lines
2637	queue->IMR = MACB_IMR;	2699	queue->IMR = MACB_IMR;
2638	queue->TBQP = MACB_TBQP;	2700	queue->TBQP = MACB_TBQP;
2639	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT	2701	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
2640	queue->TBQPH = MACB_TBQPH;	2702	if (bp->hw_dma_cap == HW_DMA_CAP_64B)
		2703	queue->TBQPH = MACB_TBQPH;
2641	#endif	2704	#endif
2642	}	2705	}
2643		2706
@@ -2730,13 +2793,14 @@ static int macb_init(struct platform_device *pdev) · 86 unmodified lines
2730	static int at91ether_start(struct net_device *dev)	2793	static int at91ether_start(struct net_device *dev)
2731	{	2794	{
2732	struct macb *lp = netdev_priv(dev);	2795	struct macb *lp = netdev_priv(dev);
		2796	struct macb_dma_desc *desc;
2733	dma_addr_t addr;	2797	dma_addr_t addr;
2734	u32 ctl;	2798	u32 ctl;
2735	int i;	2799	int i;
2736		2800
2737	lp->rx_ring = dma_alloc_coherent(&lp->pdev->dev,	2801	lp->rx_ring = dma_alloc_coherent(&lp->pdev->dev,
2738	(AT91ETHER_MAX_RX_DESCR *	2802	(AT91ETHER_MAX_RX_DESCR *
2739	sizeof(struct macb_dma_desc)),	2803	macb_dma_desc_get_size(lp)),
2740	&lp->rx_ring_dma, GFP_KERNEL);	2804	&lp->rx_ring_dma, GFP_KERNEL);
2741	if (!lp->rx_ring)	2805	if (!lp->rx_ring)
2742	return -ENOMEM;	2806	return -ENOMEM;
@@ -2748,7 +2812,7 @@ static int at91ether_start(struct net_device *dev) · 5 unmodified lines
2748	if (!lp->rx_buffers) {	2812	if (!lp->rx_buffers) {
2749	dma_free_coherent(&lp->pdev->dev,	2813	dma_free_coherent(&lp->pdev->dev,
2750	AT91ETHER_MAX_RX_DESCR *	2814	AT91ETHER_MAX_RX_DESCR *
2751	sizeof(struct macb_dma_desc),	2815	macb_dma_desc_get_size(lp),
2752	lp->rx_ring, lp->rx_ring_dma);	2816	lp->rx_ring, lp->rx_ring_dma);
2753	lp->rx_ring = NULL;	2817	lp->rx_ring = NULL;
2754	return -ENOMEM;	2818	return -ENOMEM;
@@ -2756,13 +2820,14 @@ static int at91ether_start(struct net_device *dev) · 1 unmodified line
2756		2820
2757	addr = lp->rx_buffers_dma;	2821	addr = lp->rx_buffers_dma;
2758	for (i = 0; i < AT91ETHER_MAX_RX_DESCR; i++) {	2822	for (i = 0; i < AT91ETHER_MAX_RX_DESCR; i++) {
2759	lp->rx_ring[i].addr = addr;	2823	desc = macb_rx_desc(lp, i);
2760	lp->rx_ring[i].ctrl = 0;	2824	macb_set_addr(lp, desc, addr);
		2825	desc->ctrl = 0;
2761	addr += AT91ETHER_MAX_RBUFF_SZ;	2826	addr += AT91ETHER_MAX_RBUFF_SZ;
2762	}	2827	}
2763		2828
2764	/* Set the Wrap bit on the last descriptor */	2829	/* Set the Wrap bit on the last descriptor */
2765	lp->rx_ring[AT91ETHER_MAX_RX_DESCR - 1].addr \|= MACB_BIT(RX_WRAP);	2830	desc->addr \|= MACB_BIT(RX_WRAP);
2766		2831
2767	/* Reset buffer index */	2832	/* Reset buffer index */
2768	lp->rx_tail = 0;	2833	lp->rx_tail = 0;
@@ -2834,7 +2899,7 @@ static int at91ether_close(struct net_device *dev) · 65 unmodified lines
2834		2899
2835	dma_free_coherent(&lp->pdev->dev,	2900	dma_free_coherent(&lp->pdev->dev,
2836	AT91ETHER_MAX_RX_DESCR *	2901	AT91ETHER_MAX_RX_DESCR *
2837	sizeof(struct macb_dma_desc),	2902	macb_dma_desc_get_size(lp),
2838	lp->rx_ring, lp->rx_ring_dma);	2903	lp->rx_ring, lp->rx_ring_dma);
2839	lp->rx_ring = NULL;	2904	lp->rx_ring = NULL;
2840		2905
@@ -2885,13 +2950,15 @@ static int at91ether_start_xmit(struct sk_buff skb, struct net_device dev) · 44 unmodified lines
2885	static void at91ether_rx(struct net_device *dev)	2950	static void at91ether_rx(struct net_device *dev)
2886	{	2951	{
2887	struct macb *lp = netdev_priv(dev);	2952	struct macb *lp = netdev_priv(dev);
		2953	struct macb_dma_desc *desc;
2888	unsigned char *p_recv;	2954	unsigned char *p_recv;
2889	struct sk_buff *skb;	2955	struct sk_buff *skb;
2890	unsigned int pktlen;	2956	unsigned int pktlen;
2891		2957
2892	while (lp->rx_ring[lp->rx_tail].addr & MACB_BIT(RX_USED)) {	2958	desc = macb_rx_desc(lp, lp->rx_tail);
		2959	while (desc->addr & MACB_BIT(RX_USED)) {
2893	p_recv = lp->rx_buffers + lp->rx_tail * AT91ETHER_MAX_RBUFF_SZ;	2960	p_recv = lp->rx_buffers + lp->rx_tail * AT91ETHER_MAX_RBUFF_SZ;
2894	pktlen = MACB_BF(RX_FRMLEN, lp->rx_ring[lp->rx_tail].ctrl);	2961	pktlen = MACB_BF(RX_FRMLEN, desc->ctrl);
2895	skb = netdev_alloc_skb(dev, pktlen + 2);	2962	skb = netdev_alloc_skb(dev, pktlen + 2);
2896	if (skb) {	2963	if (skb) {
2897	skb_reserve(skb, 2);	2964	skb_reserve(skb, 2);
@@ -2905,17 +2972,19 @@ static void at91ether_rx(struct net_device *dev) · 7 unmodified lines
2905	lp->stats.rx_dropped++;	2972	lp->stats.rx_dropped++;
2906	}	2973	}
2907		2974
2908	if (lp->rx_ring[lp->rx_tail].ctrl & MACB_BIT(RX_MHASH_MATCH))	2975	if (desc->ctrl & MACB_BIT(RX_MHASH_MATCH))
2909	lp->stats.multicast++;	2976	lp->stats.multicast++;
2910		2977
2911	/* reset ownership bit */	2978	/* reset ownership bit */
2912	lp->rx_ring[lp->rx_tail].addr &= ~MACB_BIT(RX_USED);	2979	desc->addr &= ~MACB_BIT(RX_USED);
2913		2980
2914	/* wrap after last buffer */	2981	/* wrap after last buffer */
2915	if (lp->rx_tail == AT91ETHER_MAX_RX_DESCR - 1)	2982	if (lp->rx_tail == AT91ETHER_MAX_RX_DESCR - 1)
2916	lp->rx_tail = 0;	2983	lp->rx_tail = 0;
2917	else	2984	else
2918	lp->rx_tail++;	2985	lp->rx_tail++;
		2986
		2987	desc = macb_rx_desc(lp, lp->rx_tail);
2919	}	2988	}
2920	}	2989	}
2921		2990
@@ -3211,8 +3280,11 @@ static int macb_probe(struct platform_device *pdev) · 289 unmodified lines
3211	device_init_wakeup(&pdev->dev, bp->wol & MACB_WOL_HAS_MAGIC_PACKET);	3280	device_init_wakeup(&pdev->dev, bp->wol & MACB_WOL_HAS_MAGIC_PACKET);
3212		3281
3213	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT	3282	#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
3214	if (GEM_BFEXT(DBWDEF, gem_readl(bp, DCFG1)) > GEM_DBW32)	3283	if (GEM_BFEXT(DAW64, gem_readl(bp, DCFG6))) {
3215	dma_set_mask(&pdev->dev, DMA_BIT_MASK(44));	3284	dma_set_mask(&pdev->dev, DMA_BIT_MASK(44));
		3285	bp->hw_dma_cap = HW_DMA_CAP_64B;
		3286	} else
		3287	bp->hw_dma_cap = HW_DMA_CAP_32B;
3216	#endif	3288	#endif
3217		3289
3218	spin_lock_init(&bp->lock);	3290	spin_lock_init(&bp->lock);

drivers/net/ethernet/cadence/macb.h+17−3

 /* Bitfields in DCFG6. */
 #define GEM_PBUF_LSO_OFFSET			27
 #define GEM_PBUF_LSO_SIZE			1
+#define GEM_DAW64_OFFSET			23
+#define GEM_DAW64_SIZE				1
 /* Constants for CLK */
 #define MACB_CLK_DIV8				0
 struct macb_dma_desc {
 	u32	addr;
 	u32	ctrl;
+};
 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
-	u32     addrh;
+enum macb_hw_dma_cap {
-	u32     resvd;
+	HW_DMA_CAP_32B,
-#endif
+	HW_DMA_CAP_64B,
 };
+struct macb_dma_desc_64 {
+	u32 addrh;
+	u32 resvd;
+};
+#endif
 /* DMA descriptor bitfields */
 #define MACB_RX_USED_OFFSET			0
 #define MACB_RX_USED_SIZE			1
 	unsigned int		jumbo_max_len;
 	u32			wol;
+#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
+	enum macb_hw_dma_cap hw_dma_cap;
+#endif
 };
 static inline bool macb_is_gem(struct macb *bp)

drivers/net/ethernet/cavium/thunder/thunder_xcv.c+1−2

@@ -116,8 +116,7 @@ void xcv_setup_link(bool link_up, int link_speed) · 115 unmodified lines
116	int speed = 2;	116	int speed = 2;
117		117
118	if (!xcv) {	118	if (!xcv) {
119	dev_err(&xcv->pdev->dev,	119	pr_err("XCV init not done, probe may have failed\n");
120	"XCV init not done, probe may have failed\n");
121	return;	120	return;
122	}	121	}
123		122

drivers/net/ethernet/emulex/benet/be_main.c+28−5

@@ -362,8 +362,10 @@ static int be_mac_addr_set(struct net_device netdev, void p) · 361 unmodified lines
362	status = -EPERM;	362	status = -EPERM;
363	goto err;	363	goto err;
364	}	364	}
365	done:	365
		366	/* Remember currently programmed MAC */
366	ether_addr_copy(adapter->dev_mac, addr->sa_data);	367	ether_addr_copy(adapter->dev_mac, addr->sa_data);
		368	done:
367	ether_addr_copy(netdev->dev_addr, addr->sa_data);	369	ether_addr_copy(netdev->dev_addr, addr->sa_data);
368	dev_info(dev, "MAC address changed to %pM\n", addr->sa_data);	370	dev_info(dev, "MAC address changed to %pM\n", addr->sa_data);
369	return 0;	371	return 0;
@@ -3618,8 +3620,10 @@ static void be_disable_if_filters(struct be_adapter *adapter) · 3248 unmodified lines
3618	{	3620	{
3619	/* Don't delete MAC on BE3 VFs without FILTMGMT privilege */	3621	/* Don't delete MAC on BE3 VFs without FILTMGMT privilege */
3620	if (!BEx_chip(adapter) \|\| !be_virtfn(adapter) \|\|	3622	if (!BEx_chip(adapter) \|\| !be_virtfn(adapter) \|\|
3621	check_privilege(adapter, BE_PRIV_FILTMGMT))	3623	check_privilege(adapter, BE_PRIV_FILTMGMT)) {
3622	be_dev_mac_del(adapter, adapter->pmac_id[0]);	3624	be_dev_mac_del(adapter, adapter->pmac_id[0]);
		3625	eth_zero_addr(adapter->dev_mac);
		3626	}
3623		3627
3624	be_clear_uc_list(adapter);	3628	be_clear_uc_list(adapter);
3625	be_clear_mc_list(adapter);	3629	be_clear_mc_list(adapter);
@@ -3773,12 +3777,27 @@ static int be_enable_if_filters(struct be_adapter *adapter) · 147 unmodified lines
3773	if (status)	3777	if (status)
3774	return status;	3778	return status;
3775		3779
3776	/* Don't add MAC on BE3 VFs without FILTMGMT privilege */	3780	/* Normally this condition usually true as the ->dev_mac is zeroed.
3777	if (!BEx_chip(adapter) \|\| !be_virtfn(adapter) \|\|	3781	* But on BE3 VFs the initial MAC is pre-programmed by PF and
3778	check_privilege(adapter, BE_PRIV_FILTMGMT)) {	3782	* subsequent be_dev_mac_add() can fail (after fresh boot)
		3783	*/
		3784	if (!ether_addr_equal(adapter->dev_mac, adapter->netdev->dev_addr)) {
		3785	int old_pmac_id = -1;
		3786
		3787	/* Remember old programmed MAC if any - can happen on BE3 VF */
		3788	if (!is_zero_ether_addr(adapter->dev_mac))
		3789	old_pmac_id = adapter->pmac_id[0];
		3790
3779	status = be_dev_mac_add(adapter, adapter->netdev->dev_addr);	3791	status = be_dev_mac_add(adapter, adapter->netdev->dev_addr);
3780	if (status)	3792	if (status)
3781	return status;	3793	return status;
		3794
		3795	/* Delete the old programmed MAC as we successfully programmed
		3796	* a new MAC
		3797	*/
		3798	if (old_pmac_id >= 0 && old_pmac_id != adapter->pmac_id[0])
		3799	be_dev_mac_del(adapter, old_pmac_id);
		3800
3782	ether_addr_copy(adapter->dev_mac, adapter->netdev->dev_addr);	3801	ether_addr_copy(adapter->dev_mac, adapter->netdev->dev_addr);
3783	}	3802	}
3784		3803
@@ -4552,6 +4571,10 @@ static int be_mac_setup(struct be_adapter *adapter) · 767 unmodified lines
4552		4571
4553	memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);	4572	memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
4554	memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);	4573	memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
		4574
		4575	/* Initial MAC for BE3 VFs is already programmed by PF */
		4576	if (BEx_chip(adapter) && be_virtfn(adapter))
		4577	memcpy(adapter->dev_mac, mac, ETH_ALEN);
4555	}	4578	}
4556		4579
4557	return 0;	4580	return 0;

drivers/net/ethernet/freescale/gianfar.c+2−2

@@ -2010,8 +2010,8 @@ static void free_skb_rx_queue(struct gfar_priv_rx_q *rx_queue) · 2009 unmodified lines
2010	if (!rxb->page)	2010	if (!rxb->page)
2011	continue;	2011	continue;
2012		2012
2013	dma_unmap_single(rx_queue->dev, rxb->dma,	2013	dma_unmap_page(rx_queue->dev, rxb->dma,
2014	PAGE_SIZE, DMA_FROM_DEVICE);	2014	PAGE_SIZE, DMA_FROM_DEVICE);
2015	__free_page(rxb->page);	2015	__free_page(rxb->page);
2016		2016
2017	rxb->page = NULL;	2017	rxb->page = NULL;

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

@@ -158,7 +158,7 @@ static int mlx4_reset_slave(struct mlx4_dev *dev) · 157 unmodified lines
158	return -ETIMEDOUT;	158	return -ETIMEDOUT;
159	}	159	}
160		160
161	static int mlx4_comm_internal_err(u32 slave_read)	161	int mlx4_comm_internal_err(u32 slave_read)
162	{	162	{
163	return (u32)COMM_CHAN_EVENT_INTERNAL_ERR ==	163	return (u32)COMM_CHAN_EVENT_INTERNAL_ERR ==
164	(slave_read & (u32)COMM_CHAN_EVENT_INTERNAL_ERR) ? 1 : 0;	164	(slave_read & (u32)COMM_CHAN_EVENT_INTERNAL_ERR) ? 1 : 0;

drivers/net/ethernet/mellanox/mlx4/intf.c+12−0

@@ -222,6 +222,18 @@ void mlx4_unregister_device(struct mlx4_dev *dev) · 221 unmodified lines
222	return;	222	return;
223		223
224	mlx4_stop_catas_poll(dev);	224	mlx4_stop_catas_poll(dev);
		225	if (dev->persist->interface_state & MLX4_INTERFACE_STATE_DELETION &&
		226	mlx4_is_slave(dev)) {
		227	/* In mlx4_remove_one on a VF */
		228	u32 slave_read =
		229	swab32(readl(&mlx4_priv(dev)->mfunc.comm->slave_read));
		230
		231	if (mlx4_comm_internal_err(slave_read)) {
		232	mlx4_dbg(dev, "%s: comm channel is down, entering error state.\n",
		233	__func__);
		234	mlx4_enter_error_state(dev->persist);
		235	}
		236	}
225	mutex_lock(&intf_mutex);	237	mutex_lock(&intf_mutex);
226		238
227	list_for_each_entry(intf, &intf_list, list)	239	list_for_each_entry(intf, &intf_list, list)

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

@@ -1220,6 +1220,7 @@ void mlx4_qp_event(struct mlx4_dev *dev, u32 qpn, int event_type); · 1219 unmodified lines
1220	void mlx4_srq_event(struct mlx4_dev *dev, u32 srqn, int event_type);	1220	void mlx4_srq_event(struct mlx4_dev *dev, u32 srqn, int event_type);
1221		1221
1222	void mlx4_enter_error_state(struct mlx4_dev_persistent *persist);	1222	void mlx4_enter_error_state(struct mlx4_dev_persistent *persist);
		1223	int mlx4_comm_internal_err(u32 slave_read);
1223		1224
1224	int mlx4_SENSE_PORT(struct mlx4_dev *dev, int port,	1225	int mlx4_SENSE_PORT(struct mlx4_dev *dev, int port,
1225	enum mlx4_port_type *type);	1226	enum mlx4_port_type *type);

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

@@ -1728,7 +1728,7 @@ int mlx5_cmd_init(struct mlx5_core_dev *dev) · 1727 unmodified lines
1728	if (cmd->cmdif_rev > CMD_IF_REV) {	1728	if (cmd->cmdif_rev > CMD_IF_REV) {
1729	dev_err(&dev->pdev->dev, "driver does not support command interface version. driver %d, firmware %d\n",	1729	dev_err(&dev->pdev->dev, "driver does not support command interface version. driver %d, firmware %d\n",
1730	CMD_IF_REV, cmd->cmdif_rev);	1730	CMD_IF_REV, cmd->cmdif_rev);
1731	err = -ENOTSUPP;	1731	err = -EOPNOTSUPP;
1732	goto err_free_page;	1732	goto err_free_page;
1733	}	1733	}
1734		1734

drivers/net/ethernet/mellanox/mlx5/core/en.h+4−3

 int mlx5e_modify_rqs_vsd(struct mlx5e_priv *priv, bool vsd);
 int mlx5e_redirect_rqt(struct mlx5e_priv *priv, u32 rqtn, int sz, int ix);
-void mlx5e_build_tir_ctx_hash(void *tirc, struct mlx5e_priv *priv);
+void mlx5e_build_indir_tir_ctx_hash(struct mlx5e_priv *priv, void *tirc,
+				    enum mlx5e_traffic_types tt);
 int mlx5e_open_locked(struct net_device *netdev);
 int mlx5e_close_locked(struct net_device *netdev);
 static inline int mlx5e_arfs_enable(struct mlx5e_priv *priv)
 {
-	return -ENOTSUPP;
+	return -EOPNOTSUPP;
 }
 static inline int mlx5e_arfs_disable(struct mlx5e_priv *priv)
 {
-	return -ENOTSUPP;
+	return -EOPNOTSUPP;
 }
 #else
 int mlx5e_arfs_create_tables(struct mlx5e_priv *priv);

drivers/net/ethernet/mellanox/mlx5/core/en_dcbnl.c+8−3

 	int i;
 	if (!MLX5_CAP_GEN(priv->mdev, ets))
-		return -ENOTSUPP;
+		return -EOPNOTSUPP;
 	ets->ets_cap = mlx5_max_tc(priv->mdev) + 1;
 	for (i = 0; i < ets->ets_cap; i++) {
 	int err;
 	if (!MLX5_CAP_GEN(priv->mdev, ets))
-		return -ENOTSUPP;
+		return -EOPNOTSUPP;
 	err = mlx5e_dbcnl_validate_ets(netdev, ets);
 	if (err)
 	struct mlx5_core_dev *mdev = priv->mdev;
 	struct ieee_ets ets;
 	struct ieee_pfc pfc;
-	int err = -ENOTSUPP;
+	int err = -EOPNOTSUPP;
 	int i;
 	if (!MLX5_CAP_GEN(mdev, ets))
 	struct mlx5e_priv *priv = netdev_priv(netdev);
 	struct mlx5_core_dev *mdev = priv->mdev;
+	if (!MLX5_CAP_GEN(priv->mdev, ets)) {
+		netdev_err(netdev, "%s, ets is not supported\n", __func__);
+		return;
+	}
 	if (priority >= CEE_DCBX_MAX_PRIO) {
 		netdev_err(netdev,
 			   "%s, priority is out of range\n", __func__);

drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c+26−15

 	struct mlx5e_priv *priv = netdev_priv(netdev);
 	if (!MLX5_CAP_GEN(priv->mdev, cq_moderation))
-		return -ENOTSUPP;
+		return -EOPNOTSUPP;
 	coal->rx_coalesce_usecs       = priv->params.rx_cq_moderation.usec;
 	coal->rx_max_coalesced_frames = priv->params.rx_cq_moderation.pkts;
 	int i;
 	if (!MLX5_CAP_GEN(mdev, cq_moderation))
-		return -ENOTSUPP;
+		return -EOPNOTSUPP;
 	mutex_lock(&priv->state_lock);
 static void mlx5e_modify_tirs_hash(struct mlx5e_priv *priv, void *in, int inlen)
 {
-	struct mlx5_core_dev *mdev = priv->mdev;
 	void *tirc = MLX5_ADDR_OF(modify_tir_in, in, ctx);
-	int i;
+	struct mlx5_core_dev *mdev = priv->mdev;
+	int ctxlen = MLX5_ST_SZ_BYTES(tirc);
+	int tt;
 	MLX5_SET(modify_tir_in, in, bitmask.hash, 1);
-	mlx5e_build_tir_ctx_hash(tirc, priv);
-	for (i = 0; i < MLX5E_NUM_INDIR_TIRS; i++)
+	for (tt = 0; tt < MLX5E_NUM_INDIR_TIRS; tt++) {
-		mlx5_core_modify_tir(mdev, priv->indir_tir[i].tirn, in, inlen);
+		memset(tirc, 0, ctxlen);
+		mlx5e_build_indir_tir_ctx_hash(priv, tirc, tt);
+		mlx5_core_modify_tir(mdev, priv->indir_tir[tt].tirn, in, inlen);
+	}
 }
 static int mlx5e_set_rxfh(struct net_device *dev, const u32 *indir,
 {
 	struct mlx5e_priv *priv = netdev_priv(dev);
 	int inlen = MLX5_ST_SZ_BYTES(modify_tir_in);
+	bool hash_changed = false;
 	void *in;
 	if ((hfunc != ETH_RSS_HASH_NO_CHANGE) &&
 		mlx5e_redirect_rqt(priv, rqtn, MLX5E_INDIR_RQT_SIZE, 0);
 	}
-	if (key)
+	if (hfunc != ETH_RSS_HASH_NO_CHANGE &&
+	    hfunc != priv->params.rss_hfunc) {
+		priv->params.rss_hfunc = hfunc;
+		hash_changed = true;
+	}
+	if (key) {
 		memcpy(priv->params.toeplitz_hash_key, key,
 		       sizeof(priv->params.toeplitz_hash_key));
+		hash_changed = hash_changed ||
+			       priv->params.rss_hfunc == ETH_RSS_HASH_TOP;
+	}
-	if (hfunc != ETH_RSS_HASH_NO_CHANGE)
+	if (hash_changed)
-		priv->params.rss_hfunc = hfunc;
+		mlx5e_modify_tirs_hash(priv, in, inlen);
-	mlx5e_modify_tirs_hash(priv, in, inlen);
 	mutex_unlock(&priv->state_lock);
 	u32 mlx5_wol_mode;
 	if (!wol_supported)
-		return -ENOTSUPP;
+		return -EOPNOTSUPP;
 	if (wol->wolopts & ~wol_supported)
 		return -EINVAL;
 	if (rx_cq_period_mode == MLX5_CQ_PERIOD_MODE_START_FROM_CQE &&
 	    !MLX5_CAP_GEN(mdev, cq_period_start_from_cqe))
-		return -ENOTSUPP;
+		return -EOPNOTSUPP;
 	if (!rx_mode_changed)
 		return 0;
 	bool reset;
 	if (!MLX5_CAP_GEN(mdev, cqe_compression))
-		return -ENOTSUPP;
+		return -EOPNOTSUPP;
 	if (enable && priv->tstamp.hwtstamp_config.rx_filter != HWTSTAMP_FILTER_NONE) {
 		netdev_err(netdev, "Can't enable cqe compression while timestamping is enabled.\n");

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

@@ -1089,7 +1089,7 @@ int mlx5e_create_flow_steering(struct mlx5e_priv *priv) · 1088 unmodified lines
1089	MLX5_FLOW_NAMESPACE_KERNEL);	1089	MLX5_FLOW_NAMESPACE_KERNEL);
1090		1090
1091	if (!priv->fs.ns)	1091	if (!priv->fs.ns)
1092	return -EINVAL;	1092	return -EOPNOTSUPP;
1093		1093
1094	err = mlx5e_arfs_create_tables(priv);	1094	err = mlx5e_arfs_create_tables(priv);
1095	if (err) {	1095	if (err) {

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

@@ -92,7 +92,7 @@ static struct mlx5e_ethtool_table get_flow_table(struct mlx5e_priv priv, · 91 unmodified lines
92	ns = mlx5_get_flow_namespace(priv->mdev,	92	ns = mlx5_get_flow_namespace(priv->mdev,
93	MLX5_FLOW_NAMESPACE_ETHTOOL);	93	MLX5_FLOW_NAMESPACE_ETHTOOL);
94	if (!ns)	94	if (!ns)
95	return ERR_PTR(-ENOTSUPP);	95	return ERR_PTR(-EOPNOTSUPP);
96		96
97	table_size = min_t(u32, BIT(MLX5_CAP_FLOWTABLE(priv->mdev,	97	table_size = min_t(u32, BIT(MLX5_CAP_FLOWTABLE(priv->mdev,
98	flow_table_properties_nic_receive.log_max_ft_size)),	98	flow_table_properties_nic_receive.log_max_ft_size)),

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

 	MLX5_SET(tirc, tirc, lro_timeout_period_usecs, priv->params.lro_timeout);
 }
-void mlx5e_build_tir_ctx_hash(void *tirc, struct mlx5e_priv *priv)
+void mlx5e_build_indir_tir_ctx_hash(struct mlx5e_priv *priv, void *tirc,
+				    enum mlx5e_traffic_types tt)
 {
+	void *hfso = MLX5_ADDR_OF(tirc, tirc, rx_hash_field_selector_outer);
+#define MLX5_HASH_IP            (MLX5_HASH_FIELD_SEL_SRC_IP   |\
+				 MLX5_HASH_FIELD_SEL_DST_IP)
+#define MLX5_HASH_IP_L4PORTS    (MLX5_HASH_FIELD_SEL_SRC_IP   |\
+				 MLX5_HASH_FIELD_SEL_DST_IP   |\
+				 MLX5_HASH_FIELD_SEL_L4_SPORT |\
+				 MLX5_HASH_FIELD_SEL_L4_DPORT)
+#define MLX5_HASH_IP_IPSEC_SPI  (MLX5_HASH_FIELD_SEL_SRC_IP   |\
+				 MLX5_HASH_FIELD_SEL_DST_IP   |\
+				 MLX5_HASH_FIELD_SEL_IPSEC_SPI)
 	MLX5_SET(tirc, tirc, rx_hash_fn,
 		 mlx5e_rx_hash_fn(priv->params.rss_hfunc));
 	if (priv->params.rss_hfunc == ETH_RSS_HASH_TOP) {
 		MLX5_SET(tirc, tirc, rx_hash_symmetric, 1);
 		memcpy(rss_key, priv->params.toeplitz_hash_key, len);
 	}
+	switch (tt) {
+	case MLX5E_TT_IPV4_TCP:
+		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
+			 MLX5_L3_PROT_TYPE_IPV4);
+		MLX5_SET(rx_hash_field_select, hfso, l4_prot_type,
+			 MLX5_L4_PROT_TYPE_TCP);
+		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
+			 MLX5_HASH_IP_L4PORTS);
+		break;
+	case MLX5E_TT_IPV6_TCP:
+		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
+			 MLX5_L3_PROT_TYPE_IPV6);
+		MLX5_SET(rx_hash_field_select, hfso, l4_prot_type,
+			 MLX5_L4_PROT_TYPE_TCP);
+		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
+			 MLX5_HASH_IP_L4PORTS);
+		break;
+	case MLX5E_TT_IPV4_UDP:
+		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
+			 MLX5_L3_PROT_TYPE_IPV4);
+		MLX5_SET(rx_hash_field_select, hfso, l4_prot_type,
+			 MLX5_L4_PROT_TYPE_UDP);
+		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
+			 MLX5_HASH_IP_L4PORTS);
+		break;
+	case MLX5E_TT_IPV6_UDP:
+		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
+			 MLX5_L3_PROT_TYPE_IPV6);
+		MLX5_SET(rx_hash_field_select, hfso, l4_prot_type,
+			 MLX5_L4_PROT_TYPE_UDP);
+		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
+			 MLX5_HASH_IP_L4PORTS);
+		break;
+	case MLX5E_TT_IPV4_IPSEC_AH:
+		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
+			 MLX5_L3_PROT_TYPE_IPV4);
+		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
+			 MLX5_HASH_IP_IPSEC_SPI);
+		break;
+	case MLX5E_TT_IPV6_IPSEC_AH:
+		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
+			 MLX5_L3_PROT_TYPE_IPV6);
+		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
+			 MLX5_HASH_IP_IPSEC_SPI);
+		break;
+	case MLX5E_TT_IPV4_IPSEC_ESP:
+		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
+			 MLX5_L3_PROT_TYPE_IPV4);
+		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
+			 MLX5_HASH_IP_IPSEC_SPI);
+		break;
+	case MLX5E_TT_IPV6_IPSEC_ESP:
+		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
+			 MLX5_L3_PROT_TYPE_IPV6);
+		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
+			 MLX5_HASH_IP_IPSEC_SPI);
+		break;
+	case MLX5E_TT_IPV4:
+		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
+			 MLX5_L3_PROT_TYPE_IPV4);
+		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
+			 MLX5_HASH_IP);
+		break;
+	case MLX5E_TT_IPV6:
+		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
+			 MLX5_L3_PROT_TYPE_IPV6);
+		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
+			 MLX5_HASH_IP);
+		break;
+	default:
+		WARN_ONCE(true, "%s: bad traffic type!\n", __func__);
+	}
 }
 static int mlx5e_modify_tirs_lro(struct mlx5e_priv *priv)
 static void mlx5e_build_indir_tir_ctx(struct mlx5e_priv *priv, u32 *tirc,
 				      enum mlx5e_traffic_types tt)
 {
-	void *hfso = MLX5_ADDR_OF(tirc, tirc, rx_hash_field_selector_outer);
 	MLX5_SET(tirc, tirc, transport_domain, priv->mdev->mlx5e_res.td.tdn);
-#define MLX5_HASH_IP            (MLX5_HASH_FIELD_SEL_SRC_IP   |\
-				 MLX5_HASH_FIELD_SEL_DST_IP)
-#define MLX5_HASH_IP_L4PORTS    (MLX5_HASH_FIELD_SEL_SRC_IP   |\
-				 MLX5_HASH_FIELD_SEL_DST_IP   |\
-				 MLX5_HASH_FIELD_SEL_L4_SPORT |\
-				 MLX5_HASH_FIELD_SEL_L4_DPORT)
-#define MLX5_HASH_IP_IPSEC_SPI  (MLX5_HASH_FIELD_SEL_SRC_IP   |\
-				 MLX5_HASH_FIELD_SEL_DST_IP   |\
-				 MLX5_HASH_FIELD_SEL_IPSEC_SPI)
 	mlx5e_build_tir_ctx_lro(tirc, priv);
 	MLX5_SET(tirc, tirc, disp_type, MLX5_TIRC_DISP_TYPE_INDIRECT);
 	MLX5_SET(tirc, tirc, indirect_table, priv->indir_rqt.rqtn);
-	mlx5e_build_tir_ctx_hash(tirc, priv);
+	mlx5e_build_indir_tir_ctx_hash(priv, tirc, tt);
-	switch (tt) {
-	case MLX5E_TT_IPV4_TCP:
-		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
-			 MLX5_L3_PROT_TYPE_IPV4);
-		MLX5_SET(rx_hash_field_select, hfso, l4_prot_type,
-			 MLX5_L4_PROT_TYPE_TCP);
-		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
-			 MLX5_HASH_IP_L4PORTS);
-		break;
-	case MLX5E_TT_IPV6_TCP:
-		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
-			 MLX5_L3_PROT_TYPE_IPV6);
-		MLX5_SET(rx_hash_field_select, hfso, l4_prot_type,
-			 MLX5_L4_PROT_TYPE_TCP);
-		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
-			 MLX5_HASH_IP_L4PORTS);
-		break;
-	case MLX5E_TT_IPV4_UDP:
-		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
-			 MLX5_L3_PROT_TYPE_IPV4);
-		MLX5_SET(rx_hash_field_select, hfso, l4_prot_type,
-			 MLX5_L4_PROT_TYPE_UDP);
-		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
-			 MLX5_HASH_IP_L4PORTS);
-		break;
-	case MLX5E_TT_IPV6_UDP:
-		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
-			 MLX5_L3_PROT_TYPE_IPV6);
-		MLX5_SET(rx_hash_field_select, hfso, l4_prot_type,
-			 MLX5_L4_PROT_TYPE_UDP);
-		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
-			 MLX5_HASH_IP_L4PORTS);
-		break;
-	case MLX5E_TT_IPV4_IPSEC_AH:
-		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
-			 MLX5_L3_PROT_TYPE_IPV4);
-		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
-			 MLX5_HASH_IP_IPSEC_SPI);
-		break;
-	case MLX5E_TT_IPV6_IPSEC_AH:
-		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
-			 MLX5_L3_PROT_TYPE_IPV6);
-		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
-			 MLX5_HASH_IP_IPSEC_SPI);
-		break;
-	case MLX5E_TT_IPV4_IPSEC_ESP:
-		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
-			 MLX5_L3_PROT_TYPE_IPV4);
-		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
-			 MLX5_HASH_IP_IPSEC_SPI);
-		break;
-	case MLX5E_TT_IPV6_IPSEC_ESP:
-		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
-			 MLX5_L3_PROT_TYPE_IPV6);
-		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
-			 MLX5_HASH_IP_IPSEC_SPI);
-		break;
-	case MLX5E_TT_IPV4:
-		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
-			 MLX5_L3_PROT_TYPE_IPV4);
-		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
-			 MLX5_HASH_IP);
-		break;
-	case MLX5E_TT_IPV6:
-		MLX5_SET(rx_hash_field_select, hfso, l3_prot_type,
-			 MLX5_L3_PROT_TYPE_IPV6);
-		MLX5_SET(rx_hash_field_select, hfso, selected_fields,
-			 MLX5_HASH_IP);
-		break;
-	default:
-		WARN_ONCE(true,
-			  "mlx5e_build_indir_tir_ctx: bad traffic type!\n");
-	}
 }
 static void mlx5e_build_direct_tir_ctx(struct mlx5e_priv *priv, u32 *tirc,
 static int mlx5e_check_required_hca_cap(struct mlx5_core_dev *mdev)
 {
 	if (MLX5_CAP_GEN(mdev, port_type) != MLX5_CAP_PORT_TYPE_ETH)
-		return -ENOTSUPP;
+		return -EOPNOTSUPP;
 	if (!MLX5_CAP_GEN(mdev, eth_net_offloads) ||
 	    !MLX5_CAP_GEN(mdev, nic_flow_table) ||
 	    !MLX5_CAP_ETH(mdev, csum_cap) ||
 			       < 3) {
 		mlx5_core_warn(mdev,
 			       "Not creating net device, some required device capabilities are missing\n");
-		return -ENOTSUPP;
+		return -EOPNOTSUPP;
 	}
 	if (!MLX5_CAP_ETH(mdev, self_lb_en_modifiable))
 		mlx5_core_warn(mdev, "Self loop back prevention is not supported\n");

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c+6−7

@@ -663,6 +663,7 @@ static int mlx5e_route_lookup_ipv4(struct mlx5e_priv *priv, · 662 unmodified lines
663	__be32 *saddr,	663	__be32 *saddr,
664	int *out_ttl)	664	int *out_ttl)
665	{	665	{
		666	struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
666	struct rtable *rt;	667	struct rtable *rt;
667	struct neighbour *n = NULL;	668	struct neighbour *n = NULL;
668	int ttl;	669	int ttl;
@@ -677,12 +678,11 @@ static int mlx5e_route_lookup_ipv4(struct mlx5e_priv *priv, · 8 unmodified lines
677	#else	678	#else
678	return -EOPNOTSUPP;	679	return -EOPNOTSUPP;
679	#endif	680	#endif
680		681	/* if the egress device isn't on the same HW e-switch, we use the uplink */
681	if (!switchdev_port_same_parent_id(priv->netdev, rt->dst.dev)) {	682	if (!switchdev_port_same_parent_id(priv->netdev, rt->dst.dev))
682	pr_warn("%s: can't offload, devices not on same HW e-switch\n", __func__);	683	*out_dev = mlx5_eswitch_get_uplink_netdev(esw);
683	ip_rt_put(rt);	684	else
684	return -EOPNOTSUPP;	685	*out_dev = rt->dst.dev;
685	}
686		686
687	ttl = ip4_dst_hoplimit(&rt->dst);	687	ttl = ip4_dst_hoplimit(&rt->dst);
688	n = dst_neigh_lookup(&rt->dst, &fl4->daddr);	688	n = dst_neigh_lookup(&rt->dst, &fl4->daddr);
@@ -693,7 +693,6 @@ static int mlx5e_route_lookup_ipv4(struct mlx5e_priv *priv, · 4 unmodified lines
693	*out_n = n;	693	*out_n = n;
694	*saddr = fl4->saddr;	694	*saddr = fl4->saddr;
695	*out_ttl = ttl;	695	*out_ttl = ttl;
696	*out_dev = rt->dst.dev;
697		696
698	return 0;	697	return 0;
699	}	698	}

drivers/net/ethernet/mellanox/mlx5/core/eswitch.c+5−5

@@ -133,7 +133,7 @@ static int modify_esw_vport_cvlan(struct mlx5_core_dev *dev, u32 vport, · 132 unmodified lines
133		133
134	if (!MLX5_CAP_ESW(dev, vport_cvlan_strip) \|\|	134	if (!MLX5_CAP_ESW(dev, vport_cvlan_strip) \|\|
135	!MLX5_CAP_ESW(dev, vport_cvlan_insert_if_not_exist))	135	!MLX5_CAP_ESW(dev, vport_cvlan_insert_if_not_exist))
136	return -ENOTSUPP;	136	return -EOPNOTSUPP;
137		137
138	esw_debug(dev, "Set Vport[%d] VLAN %d qos %d set=%x\n",	138	esw_debug(dev, "Set Vport[%d] VLAN %d qos %d set=%x\n",
139	vport, vlan, qos, set_flags);	139	vport, vlan, qos, set_flags);
@@ -353,7 +353,7 @@ static int esw_create_legacy_fdb_table(struct mlx5_eswitch *esw, int nvports) · 213 unmodified lines
353	root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_FDB);	353	root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_FDB);
354	if (!root_ns) {	354	if (!root_ns) {
355	esw_warn(dev, "Failed to get FDB flow namespace\n");	355	esw_warn(dev, "Failed to get FDB flow namespace\n");
356	return -ENOMEM;	356	return -EOPNOTSUPP;
357	}	357	}
358		358
359	flow_group_in = mlx5_vzalloc(inlen);	359	flow_group_in = mlx5_vzalloc(inlen);
@@ -962,7 +962,7 @@ static int esw_vport_enable_egress_acl(struct mlx5_eswitch *esw, · 602 unmodified lines
962	root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_ESW_EGRESS);	962	root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_ESW_EGRESS);
963	if (!root_ns) {	963	if (!root_ns) {
964	esw_warn(dev, "Failed to get E-Switch egress flow namespace\n");	964	esw_warn(dev, "Failed to get E-Switch egress flow namespace\n");
965	return -EIO;	965	return -EOPNOTSUPP;
966	}	966	}
967		967
968	flow_group_in = mlx5_vzalloc(inlen);	968	flow_group_in = mlx5_vzalloc(inlen);
@@ -1079,7 +1079,7 @@ static int esw_vport_enable_ingress_acl(struct mlx5_eswitch *esw, · 110 unmodified lines
1079	root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_ESW_INGRESS);	1079	root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_ESW_INGRESS);
1080	if (!root_ns) {	1080	if (!root_ns) {
1081	esw_warn(dev, "Failed to get E-Switch ingress flow namespace\n");	1081	esw_warn(dev, "Failed to get E-Switch ingress flow namespace\n");
1082	return -EIO;	1082	return -EOPNOTSUPP;
1083	}	1083	}
1084		1084
1085	flow_group_in = mlx5_vzalloc(inlen);	1085	flow_group_in = mlx5_vzalloc(inlen);
@@ -1630,7 +1630,7 @@ int mlx5_eswitch_enable_sriov(struct mlx5_eswitch *esw, int nvfs, int mode) · 544 unmodified lines
1630	if (!MLX5_CAP_GEN(esw->dev, eswitch_flow_table) \|\|	1630	if (!MLX5_CAP_GEN(esw->dev, eswitch_flow_table) \|\|
1631	!MLX5_CAP_ESW_FLOWTABLE_FDB(esw->dev, ft_support)) {	1631	!MLX5_CAP_ESW_FLOWTABLE_FDB(esw->dev, ft_support)) {
1632	esw_warn(esw->dev, "E-Switch FDB is not supported, aborting ...\n");	1632	esw_warn(esw->dev, "E-Switch FDB is not supported, aborting ...\n");
1633	return -ENOTSUPP;	1633	return -EOPNOTSUPP;
1634	}	1634	}
1635		1635
1636	if (!MLX5_CAP_ESW_INGRESS_ACL(esw->dev, ft_support))	1636	if (!MLX5_CAP_ESW_INGRESS_ACL(esw->dev, ft_support))

drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c+22−14

 	return 0;
 out_notsupp:
-	return -ENOTSUPP;
+	return -EOPNOTSUPP;
 }
 int mlx5_eswitch_add_vlan_action(struct mlx5_eswitch *esw,
 	root_ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_FDB);
 	if (!root_ns) {
 		esw_warn(dev, "Failed to get FDB flow namespace\n");
+		err = -EOPNOTSUPP;
 		goto ns_err;
 	}
 	ns = mlx5_get_flow_namespace(dev, MLX5_FLOW_NAMESPACE_OFFLOADS);
 	if (!ns) {
 		esw_warn(esw->dev, "Failed to get offloads flow namespace\n");
-		return -ENOMEM;
+		return -EOPNOTSUPP;
 	}
 	ft_offloads = mlx5_create_flow_table(ns, 0, dev->priv.sriov.num_vfs + 2, 0, 0);
 		esw_warn(esw->dev, "Failed setting eswitch to offloads, err %d\n", err);
 		err1 = mlx5_eswitch_enable_sriov(esw, num_vfs, SRIOV_LEGACY);
 		if (err1)
-			esw_warn(esw->dev, "Failed setting eswitch back to legacy, err %d\n", err);
+			esw_warn(esw->dev, "Failed setting eswitch back to legacy, err %d\n", err1);
 	}
 	if (esw->offloads.inline_mode == MLX5_INLINE_MODE_NONE) {
 		if (mlx5_eswitch_inline_mode_get(esw,
 	int vport;
 	int err;
+	/* disable PF RoCE so missed packets don't go through RoCE steering */
+	mlx5_dev_list_lock();
+	mlx5_remove_dev_by_protocol(esw->dev, MLX5_INTERFACE_PROTOCOL_IB);
+	mlx5_dev_list_unlock();
 	err = esw_create_offloads_fdb_table(esw, nvports);
 	if (err)
-		return err;
+		goto create_fdb_err;
 	err = esw_create_offloads_table(esw);
 	if (err)
 			goto err_reps;
 	}
-	/* disable PF RoCE so missed packets don't go through RoCE steering */
-	mlx5_dev_list_lock();
-	mlx5_remove_dev_by_protocol(esw->dev, MLX5_INTERFACE_PROTOCOL_IB);
-	mlx5_dev_list_unlock();
 	return 0;
 err_reps:
 create_ft_err:
 	esw_destroy_offloads_fdb_table(esw);
+create_fdb_err:
+	/* enable back PF RoCE */
+	mlx5_dev_list_lock();
+	mlx5_add_dev_by_protocol(esw->dev, MLX5_INTERFACE_PROTOCOL_IB);
+	mlx5_dev_list_unlock();
 	return err;
 }
 {
 	int err, err1, num_vfs = esw->dev->priv.sriov.num_vfs;
-	/* enable back PF RoCE */
-	mlx5_dev_list_lock();
-	mlx5_add_dev_by_protocol(esw->dev, MLX5_INTERFACE_PROTOCOL_IB);
-	mlx5_dev_list_unlock();
 	mlx5_eswitch_disable_sriov(esw);
 	err = mlx5_eswitch_enable_sriov(esw, num_vfs, SRIOV_LEGACY);
 	if (err) {
 			esw_warn(esw->dev, "Failed setting eswitch back to offloads, err %d\n", err);
 	}
+	/* enable back PF RoCE */
+	mlx5_dev_list_lock();
+	mlx5_add_dev_by_protocol(esw->dev, MLX5_INTERFACE_PROTOCOL_IB);
+	mlx5_dev_list_unlock();
 	return err;
 }

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

@@ -322,7 +322,7 @@ int mlx5_cmd_update_fte(struct mlx5_core_dev *dev, · 321 unmodified lines
322	flow_table_properties_nic_receive.	322	flow_table_properties_nic_receive.
323	flow_modify_en);	323	flow_modify_en);
324	if (!atomic_mod_cap)	324	if (!atomic_mod_cap)
325	return -ENOTSUPP;	325	return -EOPNOTSUPP;
326	opmod = 1;	326	opmod = 1;
327		327
328	return mlx5_cmd_set_fte(dev, opmod, modify_mask, ft, group_id, fte);	328	return mlx5_cmd_set_fte(dev, opmod, modify_mask, ft, group_id, fte);

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

@@ -1822,7 +1822,7 @@ static int create_anchor_flow_table(struct mlx5_flow_steering *steering) · 1821 unmodified lines
1822	struct mlx5_flow_table *ft;	1822	struct mlx5_flow_table *ft;
1823		1823
1824	ns = mlx5_get_flow_namespace(steering->dev, MLX5_FLOW_NAMESPACE_ANCHOR);	1824	ns = mlx5_get_flow_namespace(steering->dev, MLX5_FLOW_NAMESPACE_ANCHOR);
1825	if (!ns)	1825	if (WARN_ON(!ns))
1826	return -EINVAL;	1826	return -EINVAL;
1827	ft = mlx5_create_flow_table(ns, ANCHOR_PRIO, ANCHOR_SIZE, ANCHOR_LEVEL, 0);	1827	ft = mlx5_create_flow_table(ns, ANCHOR_PRIO, ANCHOR_SIZE, ANCHOR_LEVEL, 0);
1828	if (IS_ERR(ft)) {	1828	if (IS_ERR(ft)) {

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

@@ -807,7 +807,7 @@ static int mlx5_core_set_issi(struct mlx5_core_dev *dev) · 806 unmodified lines
807	return 0;	807	return 0;
808	}	808	}
809		809
810	return -ENOTSUPP;	810	return -EOPNOTSUPP;
811	}	811	}
812		812
813		813

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

@@ -620,7 +620,7 @@ static int mlx5_set_port_qetcr_reg(struct mlx5_core_dev mdev, u32 in, · 619 unmodified lines
620	u32 out[MLX5_ST_SZ_DW(qtct_reg)];	620	u32 out[MLX5_ST_SZ_DW(qtct_reg)];
621		621
622	if (!MLX5_CAP_GEN(mdev, ets))	622	if (!MLX5_CAP_GEN(mdev, ets))
623	return -ENOTSUPP;	623	return -EOPNOTSUPP;
624		624
625	return mlx5_core_access_reg(mdev, in, inlen, out, sizeof(out),	625	return mlx5_core_access_reg(mdev, in, inlen, out, sizeof(out),
626	MLX5_REG_QETCR, 0, 1);	626	MLX5_REG_QETCR, 0, 1);
@@ -632,7 +632,7 @@ static int mlx5_query_port_qetcr_reg(struct mlx5_core_dev mdev, u32 out, · 5 unmodified lines
632	u32 in[MLX5_ST_SZ_DW(qtct_reg)];	632	u32 in[MLX5_ST_SZ_DW(qtct_reg)];
633		633
634	if (!MLX5_CAP_GEN(mdev, ets))	634	if (!MLX5_CAP_GEN(mdev, ets))
635	return -ENOTSUPP;	635	return -EOPNOTSUPP;
636		636
637	memset(in, 0, sizeof(in));	637	memset(in, 0, sizeof(in));
638	return mlx5_core_access_reg(mdev, in, sizeof(in), out, outlen,	638	return mlx5_core_access_reg(mdev, in, sizeof(in), out, outlen,

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

@@ -532,7 +532,7 @@ int mlx5_modify_nic_vport_node_guid(struct mlx5_core_dev *mdev, · 531 unmodified lines
532	if (!MLX5_CAP_GEN(mdev, vport_group_manager))	532	if (!MLX5_CAP_GEN(mdev, vport_group_manager))
533	return -EACCES;	533	return -EACCES;
534	if (!MLX5_CAP_ESW(mdev, nic_vport_node_guid_modify))	534	if (!MLX5_CAP_ESW(mdev, nic_vport_node_guid_modify))
535	return -ENOTSUPP;	535	return -EOPNOTSUPP;
536		536
537	in = mlx5_vzalloc(inlen);	537	in = mlx5_vzalloc(inlen);
538	if (!in)	538	if (!in)

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

 {
 	void __iomem *ioaddr = hw->pcsr;
 	u32 intr_status = readl(ioaddr + GMAC_INT_STATUS);
+	u32 intr_mask = readl(ioaddr + GMAC_INT_MASK);
 	int ret = 0;
+	/* Discard masked bits */
+	intr_status &= ~intr_mask;
 	/* Not used events (e.g. MMC interrupts) are not handled. */
 	if ((intr_status & GMAC_INT_STATUS_MMCTIS))
 		x->mmc_tx_irq_n++;

drivers/net/hyperv/netvsc.c+6−0

 	ndev = hv_get_drvdata(device);
 	buffer = get_per_channel_state(channel);
+	/* commit_rd_index() -> hv_signal_on_read() needs this. */
+	init_cached_read_index(channel);
 	do {
 		desc = get_next_pkt_raw(channel);
 		if (desc != NULL) {
 			bufferlen = bytes_recvd;
 		}
+		init_cached_read_index(channel);
 	} while (1);
 	if (bufferlen > NETVSC_PACKET_SIZE)

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

@@ -1012,7 +1012,7 @@ static struct phy_driver ksphy_driver[] = { · 1011 unmodified lines
1012	.phy_id = PHY_ID_KSZ8795,	1012	.phy_id = PHY_ID_KSZ8795,
1013	.phy_id_mask = MICREL_PHY_ID_MASK,	1013	.phy_id_mask = MICREL_PHY_ID_MASK,
1014	.name = "Micrel KSZ8795",	1014	.name = "Micrel KSZ8795",
1015	.features = (SUPPORTED_Pause \| SUPPORTED_Asym_Pause),	1015	.features = PHY_BASIC_FEATURES,
1016	.flags = PHY_HAS_MAGICANEG \| PHY_HAS_INTERRUPT,	1016	.flags = PHY_HAS_MAGICANEG \| PHY_HAS_INTERRUPT,
1017	.config_init = kszphy_config_init,	1017	.config_init = kszphy_config_init,
1018	.config_aneg = ksz8873mll_config_aneg,	1018	.config_aneg = ksz8873mll_config_aneg,

drivers/net/wireless/intel/iwlwifi/iwl-8000.c+1−1

@@ -91,7 +91,7 @@ · 90 unmodified lines
91		91
92	#define IWL8000_FW_PRE "iwlwifi-8000C-"	92	#define IWL8000_FW_PRE "iwlwifi-8000C-"
93	#define IWL8000_MODULE_FIRMWARE(api) \	93	#define IWL8000_MODULE_FIRMWARE(api) \
94	IWL8000_FW_PRE "-" __stringify(api) ".ucode"	94	IWL8000_FW_PRE __stringify(api) ".ucode"
95		95
96	#define IWL8265_FW_PRE "iwlwifi-8265-"	96	#define IWL8265_FW_PRE "iwlwifi-8265-"
97	#define IWL8265_MODULE_FIRMWARE(api) \	97	#define IWL8265_MODULE_FIRMWARE(api) \

drivers/net/wireless/intel/iwlwifi/mvm/sta.c+4−3

 		.frame_limit = IWL_FRAME_LIMIT,
 	};
-	/* Make sure reserved queue is still marked as such (or allocated) */
+	/* Make sure reserved queue is still marked as such (if allocated) */
-	mvm->queue_info[mvm_sta->reserved_queue].status =
+	if (mvm_sta->reserved_queue != IEEE80211_INVAL_HW_QUEUE)
-		IWL_MVM_QUEUE_RESERVED;
+		mvm->queue_info[mvm_sta->reserved_queue].status =
+			IWL_MVM_QUEUE_RESERVED;
 	for (i = 0; i <= IWL_MAX_TID_COUNT; i++) {
 		struct iwl_mvm_tid_data *tid_data = &mvm_sta->tid_data[i];

drivers/net/wireless/intel/iwlwifi/mvm/tt.c+8−4

 		return;
 	IWL_DEBUG_TEMP(mvm, "Thermal zone device unregister\n");
-	thermal_zone_device_unregister(mvm->tz_device.tzone);
+	if (mvm->tz_device.tzone) {
-	mvm->tz_device.tzone = NULL;
+		thermal_zone_device_unregister(mvm->tz_device.tzone);
+		mvm->tz_device.tzone = NULL;
+	}
 }
 static void iwl_mvm_cooling_device_unregister(struct iwl_mvm *mvm)
 		return;
 	IWL_DEBUG_TEMP(mvm, "Cooling device unregister\n");
-	thermal_cooling_device_unregister(mvm->cooling_dev.cdev);
+	if (mvm->cooling_dev.cdev) {
-	mvm->cooling_dev.cdev = NULL;
+		thermal_cooling_device_unregister(mvm->cooling_dev.cdev);
+		mvm->cooling_dev.cdev = NULL;
+	}
 }
 #endif /* CONFIG_THERMAL */

drivers/pci/pcie/aspm.c+13−6

@@ -532,25 +532,32 @@ static struct pcie_link_state alloc_pcie_link_state(struct pci_dev pdev) · 531 unmodified lines
532	link = kzalloc(sizeof(*link), GFP_KERNEL);	532	link = kzalloc(sizeof(*link), GFP_KERNEL);
533	if (!link)	533	if (!link)
534	return NULL;	534	return NULL;
		535
535	INIT_LIST_HEAD(&link->sibling);	536	INIT_LIST_HEAD(&link->sibling);
536	INIT_LIST_HEAD(&link->children);	537	INIT_LIST_HEAD(&link->children);
537	INIT_LIST_HEAD(&link->link);	538	INIT_LIST_HEAD(&link->link);
538	link->pdev = pdev;	539	link->pdev = pdev;
539	if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT) {	540
		541	/*
		542	* Root Ports and PCI/PCI-X to PCIe Bridges are roots of PCIe
		543	* hierarchies.
		544	*/
		545	if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT \|\|
		546	pci_pcie_type(pdev) == PCI_EXP_TYPE_PCIE_BRIDGE) {
		547	link->root = link;
		548	} else {
540	struct pcie_link_state *parent;	549	struct pcie_link_state *parent;
		550
541	parent = pdev->bus->parent->self->link_state;	551	parent = pdev->bus->parent->self->link_state;
542	if (!parent) {	552	if (!parent) {
543	kfree(link);	553	kfree(link);
544	return NULL;	554	return NULL;
545	}	555	}
		556
546	link->parent = parent;	557	link->parent = parent;
		558	link->root = link->parent->root;
547	list_add(&link->link, &parent->children);	559	list_add(&link->link, &parent->children);
548	}	560	}
549	/* Setup a pointer to the root port link */
550	if (!link->parent)
551	link->root = link;
552	else
553	link->root = link->parent->root;
554		561
555	list_add(&link->sibling, &link_list);	562	list_add(&link->sibling, &link_list);
556	pdev->link_state = link;	563	pdev->link_state = link;

drivers/pinctrl/berlin/berlin-bg4ct.c+1−1

@@ -217,7 +217,7 @@ static const struct berlin_desc_group berlin4ct_soc_pinctrl_groups[] = { · 216 unmodified lines
217	BERLIN_PINCTRL_GROUP("SCRD0_CRD_PRES", 0xc, 0x3, 0x15,	217	BERLIN_PINCTRL_GROUP("SCRD0_CRD_PRES", 0xc, 0x3, 0x15,
218	BERLIN_PINCTRL_FUNCTION(0x0, "gpio"), /* GPIO20 */	218	BERLIN_PINCTRL_FUNCTION(0x0, "gpio"), /* GPIO20 */
219	BERLIN_PINCTRL_FUNCTION(0x1, "scrd0"), /* crd pres */	219	BERLIN_PINCTRL_FUNCTION(0x1, "scrd0"), /* crd pres */
220	BERLIN_PINCTRL_FUNCTION(0x1, "sd1a")), /* DAT3 */	220	BERLIN_PINCTRL_FUNCTION(0x3, "sd1a")), /* DAT3 */
221	BERLIN_PINCTRL_GROUP("SPI1_SS0n", 0xc, 0x3, 0x18,	221	BERLIN_PINCTRL_GROUP("SPI1_SS0n", 0xc, 0x3, 0x18,
222	BERLIN_PINCTRL_FUNCTION(0x0, "spi1"), /* SS0n */	222	BERLIN_PINCTRL_FUNCTION(0x0, "spi1"), /* SS0n */
223	BERLIN_PINCTRL_FUNCTION(0x1, "gpio"), /* GPIO37 */	223	BERLIN_PINCTRL_FUNCTION(0x1, "gpio"), /* GPIO37 */

drivers/pinctrl/intel/pinctrl-baytrail.c+20−7

 				  int reg)
 {
 	struct byt_community *comm = byt_get_community(vg, offset);
-	u32 reg_offset = 0;
+	u32 reg_offset;
 	if (!comm)
 		return NULL;
 	offset -= comm->pin_base;
-	if (reg == BYT_INT_STAT_REG)
+	switch (reg) {
+	case BYT_INT_STAT_REG:
 		reg_offset = (offset / 32) * 4;
-	else
+		break;
+	case BYT_DEBOUNCE_REG:
+		reg_offset = 0;
+		break;
+	default:
 		reg_offset = comm->pad_map[offset] * 16;
+		break;
+	}
 	return comm->reg_base + reg_offset + reg;
 }
 			debounce = readl(db_reg);
 			debounce &= ~BYT_DEBOUNCE_PULSE_MASK;
+			if (arg)
+				conf |= BYT_DEBOUNCE_EN;
+			else
+				conf &= ~BYT_DEBOUNCE_EN;
 			switch (arg) {
-			case 0:
-				conf &= BYT_DEBOUNCE_EN;
-				break;
 			case 375:
 				debounce |= BYT_DEBOUNCE_PULSE_375US;
 				break;
 				debounce |= BYT_DEBOUNCE_PULSE_24MS;
 				break;
 			default:
-				ret = -EINVAL;
+				if (arg)
+					ret = -EINVAL;
+				break;
 			}
 			if (!ret)
 			continue;
 		}
+		raw_spin_lock(&vg->lock);
 		pending = readl(reg);
+		raw_spin_unlock(&vg->lock);
 		for_each_set_bit(pin, &pending, 32) {
 			virq = irq_find_mapping(vg->chip.irqdomain, base + pin);
 			generic_handle_irq(virq);

drivers/pinctrl/intel/pinctrl-merrifield.c+3−0

@@ -794,6 +794,9 @@ static int mrfld_config_set(struct pinctrl_dev *pctldev, unsigned int pin, · 793 unmodified lines
794	unsigned int i;	794	unsigned int i;
795	int ret;	795	int ret;
796		796
		797	if (!mrfld_buf_available(mp, pin))
		798	return -ENOTSUPP;
		799
797	for (i = 0; i < nconfigs; i++) {	800	for (i = 0; i < nconfigs; i++) {
798	switch (pinconf_to_config_param(configs[i])) {	801	switch (pinconf_to_config_param(configs[i])) {
799	case PIN_CONFIG_BIAS_DISABLE:	802	case PIN_CONFIG_BIAS_DISABLE:

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

 			val = arg / 10 - 1;
 			break;
 		case PIN_CONFIG_BIAS_DISABLE:
-			val = 0;
+			continue;
-			break;
 		case PIN_CONFIG_BIAS_PULL_UP:
 			if (arg == 0)
 				return -EINVAL;

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

@@ -272,7 +272,7 @@ static const struct regulator_desc axp806_regulators[] = { · 271 unmodified lines
272	64, AXP806_DCDCD_V_CTRL, 0x3f, AXP806_PWR_OUT_CTRL1,	272	64, AXP806_DCDCD_V_CTRL, 0x3f, AXP806_PWR_OUT_CTRL1,
273	BIT(3)),	273	BIT(3)),
274	AXP_DESC(AXP806, DCDCE, "dcdce", "vine", 1100, 3400, 100,	274	AXP_DESC(AXP806, DCDCE, "dcdce", "vine", 1100, 3400, 100,
275	AXP806_DCDCB_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(4)),	275	AXP806_DCDCE_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(4)),
276	AXP_DESC(AXP806, ALDO1, "aldo1", "aldoin", 700, 3300, 100,	276	AXP_DESC(AXP806, ALDO1, "aldo1", "aldoin", 700, 3300, 100,
277	AXP806_ALDO1_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(5)),	277	AXP806_ALDO1_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(5)),
278	AXP_DESC(AXP806, ALDO2, "aldo2", "aldoin", 700, 3400, 100,	278	AXP_DESC(AXP806, ALDO2, "aldo2", "aldoin", 700, 3400, 100,

drivers/regulator/fixed.c+0−46

@@ -30,9 +30,6 @@ · 29 unmodified lines
30	#include <linux/of_gpio.h>	30	#include <linux/of_gpio.h>
31	#include <linux/regulator/of_regulator.h>	31	#include <linux/regulator/of_regulator.h>
32	#include <linux/regulator/machine.h>	32	#include <linux/regulator/machine.h>
33	#include <linux/acpi.h>
34	#include <linux/property.h>
35	#include <linux/gpio/consumer.h>
36		33
37	struct fixed_voltage_data {	34	struct fixed_voltage_data {
38	struct regulator_desc desc;	35	struct regulator_desc desc;
@@ -97,44 +94,6 @@ of_get_fixed_voltage_config(struct device *dev, · 58 unmodified lines
97	return config;	94	return config;
98	}	95	}
99		96
100	/**
101	* acpi_get_fixed_voltage_config - extract fixed_voltage_config structure info
102	* @dev: device requesting for fixed_voltage_config
103	* @desc: regulator description
104	*
105	* Populates fixed_voltage_config structure by extracting data through ACPI
106	* interface, returns a pointer to the populated structure of NULL if memory
107	* alloc fails.
108	*/
109	static struct fixed_voltage_config *
110	acpi_get_fixed_voltage_config(struct device *dev,
111	const struct regulator_desc *desc)
112	{
113	struct fixed_voltage_config *config;
114	const char *supply_name;
115	struct gpio_desc *gpiod;
116	int ret;
117
118	config = devm_kzalloc(dev, sizeof(*config), GFP_KERNEL);
119	if (!config)
120	return ERR_PTR(-ENOMEM);
121
122	ret = device_property_read_string(dev, "supply-name", &supply_name);
123	if (!ret)
124	config->supply_name = supply_name;
125
126	gpiod = gpiod_get(dev, "gpio", GPIOD_ASIS);
127	if (IS_ERR(gpiod))
128	return ERR_PTR(-ENODEV);
129
130	config->gpio = desc_to_gpio(gpiod);
131	config->enable_high = device_property_read_bool(dev,
132	"enable-active-high");
133	gpiod_put(gpiod);
134
135	return config;
136	}
137
138	static struct regulator_ops fixed_voltage_ops = {	97	static struct regulator_ops fixed_voltage_ops = {
139	};	98	};
140		99
@@ -155,11 +114,6 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev) · 14 unmodified lines
155	&drvdata->desc);	114	&drvdata->desc);
156	if (IS_ERR(config))	115	if (IS_ERR(config))
157	return PTR_ERR(config);	116	return PTR_ERR(config);
158	} else if (ACPI_HANDLE(&pdev->dev)) {
159	config = acpi_get_fixed_voltage_config(&pdev->dev,
160	&drvdata->desc);
161	if (IS_ERR(config))
162	return PTR_ERR(config);
163	} else {	117	} else {
164	config = dev_get_platdata(&pdev->dev);	118	config = dev_get_platdata(&pdev->dev);
165	}	119	}

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

@@ -452,7 +452,7 @@ static int twl6030smps_map_voltage(struct regulator_dev *rdev, int min_uV, · 451 unmodified lines
452	vsel = 62;	452	vsel = 62;
453	else if ((min_uV > 1800000) && (min_uV <= 1900000))	453	else if ((min_uV > 1800000) && (min_uV <= 1900000))
454	vsel = 61;	454	vsel = 61;
455	else if ((min_uV > 1350000) && (min_uV <= 1800000))	455	else if ((min_uV > 1500000) && (min_uV <= 1800000))
456	vsel = 60;	456	vsel = 60;
457	else if ((min_uV > 1350000) && (min_uV <= 1500000))	457	else if ((min_uV > 1350000) && (min_uV <= 1500000))
458	vsel = 59;	458	vsel = 59;

drivers/rtc/Kconfig+4−1

 	  will be called rtc-mpc5121.
 config RTC_DRV_JZ4740
-	bool "Ingenic JZ4740 SoC"
+	tristate "Ingenic JZ4740 SoC"
 	depends on MACH_INGENIC || COMPILE_TEST
 	help
 	  If you say yes here you get support for the Ingenic JZ47xx SoCs RTC
 	  controllers.
+	  This driver can also be buillt as a module. If so, the module
+	  will be called rtc-jz4740.
 config RTC_DRV_LPC24XX
 	tristate "NXP RTC for LPC178x/18xx/408x/43xx"
 	depends on ARCH_LPC18XX || COMPILE_TEST

drivers/rtc/rtc-jz4740.c+10−2

 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/reboot.h>
 			     JZ_REG_RTC_RESET_COUNTER, reset_counter_ticks);
 	jz4740_rtc_poweroff(dev_for_power_off);
-	machine_halt();
+	kernel_halt();
 }
 static const struct of_device_id jz4740_rtc_of_match[] = {
 	{ .compatible = "ingenic,jz4780-rtc", .data = (void *)ID_JZ4780 },
 	{},
 };
+MODULE_DEVICE_TABLE(of, jz4740_rtc_of_match);
 static int jz4740_rtc_probe(struct platform_device *pdev)
 {
 	{ "jz4780-rtc", ID_JZ4780 },
 	{}
 };
+MODULE_DEVICE_TABLE(platform, jz4740_rtc_ids);
 static struct platform_driver jz4740_rtc_driver = {
 	.probe	 = jz4740_rtc_probe,
 	.id_table = jz4740_rtc_ids,
 };
-builtin_platform_driver(jz4740_rtc_driver);
+module_platform_driver(jz4740_rtc_driver);
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("RTC driver for the JZ4740 SoC\n");
+MODULE_ALIAS("platform:jz4740-rtc");

drivers/scsi/virtio_scsi.c+10−1

 {
 	struct Scsi_Host *shost = virtio_scsi_host(vscsi->vdev);
 	struct virtio_scsi_cmd *cmd = scsi_cmd_priv(sc);
+	unsigned long flags;
 	int req_size;
+	int ret;
 	BUG_ON(scsi_sg_count(sc) > shost->sg_tablesize);
 		req_size = sizeof(cmd->req.cmd);
 	}
-	if (virtscsi_kick_cmd(req_vq, cmd, req_size, sizeof(cmd->resp.cmd)) != 0)
+	ret = virtscsi_kick_cmd(req_vq, cmd, req_size, sizeof(cmd->resp.cmd));
+	if (ret == -EIO) {
+		cmd->resp.cmd.response = VIRTIO_SCSI_S_BAD_TARGET;
+		spin_lock_irqsave(&req_vq->vq_lock, flags);
+		virtscsi_complete_cmd(vscsi, cmd);
+		spin_unlock_irqrestore(&req_vq->vq_lock, flags);
+	} else if (ret != 0) {
 		return SCSI_MLQUEUE_HOST_BUSY;
+	}
 	return 0;
 }

drivers/staging/greybus/timesync_platform.c+6−0

 int gb_timesync_platform_lock_bus(struct gb_timesync_svc *pdata)
 {
+	if (!arche_platform_change_state_cb)
+		return 0;
 	return arche_platform_change_state_cb(ARCHE_PLATFORM_STATE_TIME_SYNC,
 					      pdata);
 }
 void gb_timesync_platform_unlock_bus(void)
 {
+	if (!arche_platform_change_state_cb)
+		return;
 	arche_platform_change_state_cb(ARCHE_PLATFORM_STATE_ACTIVE, NULL);
 }

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

 	/* CBM - Flash disk */
 	{ USB_DEVICE(0x0204, 0x6025), .driver_info = USB_QUIRK_RESET_RESUME },
+	/* WORLDE easy key (easykey.25) MIDI controller  */
+	{ USB_DEVICE(0x0218, 0x0401), .driver_info =
+			USB_QUIRK_CONFIG_INTF_STRINGS },
 	/* HP 5300/5370C scanner */
 	{ USB_DEVICE(0x03f0, 0x0701), .driver_info =
 			USB_QUIRK_STRING_FETCH_255 },

drivers/usb/gadget/function/f_fs.c+12−1

 		if (len < sizeof(*d) || h->interface >= ffs->interfaces_count)
 			return -EINVAL;
 		length = le32_to_cpu(d->dwSize);
+		if (len < length)
+			return -EINVAL;
 		type = le32_to_cpu(d->dwPropertyDataType);
 		if (type < USB_EXT_PROP_UNICODE ||
 		    type > USB_EXT_PROP_UNICODE_MULTI) {
 			return -EINVAL;
 		}
 		pnl = le16_to_cpu(d->wPropertyNameLength);
+		if (length < 14 + pnl) {
+			pr_vdebug("invalid os descriptor length: %d pnl:%d (descriptor %d)\n",
+				  length, pnl, type);
+			return -EINVAL;
+		}
 		pdl = le32_to_cpu(*(u32 *)((u8 *)data + 10 + pnl));
 		if (length != 14 + pnl + pdl) {
 			pr_vdebug("invalid os descriptor length: %d pnl:%d pdl:%d (descriptor %d)\n",
 		}
 	}
 	if (flags & (1 << i)) {
+		if (len < 4) {
+			goto error;
+		}
 		os_descs_count = get_unaligned_le32(data);
 		data += 4;
 		len -= 4;
 	ENTER();
-	if (unlikely(get_unaligned_le32(data) != FUNCTIONFS_STRINGS_MAGIC ||
+	if (unlikely(len < 16 ||
+		     get_unaligned_le32(data) != FUNCTIONFS_STRINGS_MAGIC ||
 		     get_unaligned_le32(data + 4) != len))
 		goto error;
 	str_count  = get_unaligned_le32(data + 8);

drivers/usb/musb/musb_core.c+13−13

 						| MUSB_PORT_STAT_RESUME;
 				musb->rh_timer = jiffies
 					+ msecs_to_jiffies(USB_RESUME_TIMEOUT);
-				musb->need_finish_resume = 1;
 				musb->xceiv->otg->state = OTG_STATE_A_HOST;
 				musb->is_active = 1;
 				musb_host_resume_root_hub(musb);
+				schedule_delayed_work(&musb->finish_resume_work,
+					msecs_to_jiffies(USB_RESUME_TIMEOUT));
 				break;
 			case OTG_STATE_B_WAIT_ACON:
 				musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL;
 static void musb_irq_work(struct work_struct *data)
 {
 	struct musb *musb = container_of(data, struct musb, irq_work.work);
+	int error;
+	error = pm_runtime_get_sync(musb->controller);
+	if (error < 0) {
+		dev_err(musb->controller, "Could not enable: %i\n", error);
+		return;
+	}
 	musb_pm_runtime_check_session(musb);
 		musb->xceiv_old_state = musb->xceiv->otg->state;
 		sysfs_notify(&musb->controller->kobj, NULL, "mode");
 	}
+	pm_runtime_mark_last_busy(musb->controller);
+	pm_runtime_put_autosuspend(musb->controller);
 }
 static void musb_recover_from_babble(struct musb *musb)
 	mask = MUSB_DEVCTL_BDEVICE | MUSB_DEVCTL_FSDEV | MUSB_DEVCTL_LSDEV;
 	if ((devctl & mask) != (musb->context.devctl & mask))
 		musb->port1_status = 0;
-	if (musb->need_finish_resume) {
-		musb->need_finish_resume = 0;
-		schedule_delayed_work(&musb->finish_resume_work,
-				      msecs_to_jiffies(USB_RESUME_TIMEOUT));
-	}
 	/*
 	 * The USB HUB code expects the device to be in RPM_ACTIVE once it came
 	musb_restore_context(musb);
-	if (musb->need_finish_resume) {
-		musb->need_finish_resume = 0;
-		schedule_delayed_work(&musb->finish_resume_work,
-				msecs_to_jiffies(USB_RESUME_TIMEOUT));
-	}
 	spin_lock_irqsave(&musb->lock, flags);
 	error = musb_run_resume_work(musb);
 	if (error)

drivers/usb/musb/musb_core.h+0−1

@@ -410,7 +410,6 @@ struct musb { · 409 unmodified lines
410		410
411	/* is_suspended means USB B_PERIPHERAL suspend */	411	/* is_suspended means USB B_PERIPHERAL suspend */
412	unsigned is_suspended:1;	412	unsigned is_suspended:1;
413	unsigned need_finish_resume :1;
414		413
415	/* may_wakeup means remote wakeup is enabled */	414	/* may_wakeup means remote wakeup is enabled */
416	unsigned may_wakeup:1;	415	unsigned may_wakeup:1;

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

@@ -2007,6 +2007,7 @@ static const struct usb_device_id option_ids[] = { · 2006 unmodified lines
2007	{ USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_WMD200, 0xff, 0xff, 0xff) },	2007	{ USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_WMD200, 0xff, 0xff, 0xff) },
2008	{ USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_6802, 0xff, 0xff, 0xff) },	2008	{ USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_6802, 0xff, 0xff, 0xff) },
2009	{ USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_WMD300, 0xff, 0xff, 0xff) },	2009	{ USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_WMD300, 0xff, 0xff, 0xff) },
		2010	{ USB_DEVICE_AND_INTERFACE_INFO(0x03f0, 0x421d, 0xff, 0xff, 0xff) }, /* HP lt2523 (Novatel E371) */
2010	{ } /* Terminating entry */	2011	{ } /* Terminating entry */
2011	};	2012	};
2012	MODULE_DEVICE_TABLE(usb, option_ids);	2013	MODULE_DEVICE_TABLE(usb, option_ids);

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

@@ -49,6 +49,7 @@ static const struct usb_device_id id_table[] = { · 48 unmodified lines
49	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },	49	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
50	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },	50	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
51	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },	51	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
		52	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
52	{ USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },	53	{ USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
53	{ USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },	54	{ USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
54	{ USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },	55	{ USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },

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

@@ -27,6 +27,7 @@ · 26 unmodified lines
27	#define ATEN_VENDOR_ID 0x0557	27	#define ATEN_VENDOR_ID 0x0557
28	#define ATEN_VENDOR_ID2 0x0547	28	#define ATEN_VENDOR_ID2 0x0547
29	#define ATEN_PRODUCT_ID 0x2008	29	#define ATEN_PRODUCT_ID 0x2008
		30	#define ATEN_PRODUCT_ID2 0x2118
30		31
31	#define IODATA_VENDOR_ID 0x04bb	32	#define IODATA_VENDOR_ID 0x04bb
32	#define IODATA_PRODUCT_ID 0x0a03	33	#define IODATA_PRODUCT_ID 0x0a03

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

@@ -124,6 +124,7 @@ static const struct usb_device_id id_table[] = { · 123 unmodified lines
124	{USB_DEVICE(0x1410, 0xa021)}, /* Novatel Gobi 3000 Composite */	124	{USB_DEVICE(0x1410, 0xa021)}, /* Novatel Gobi 3000 Composite */
125	{USB_DEVICE(0x413c, 0x8193)}, /* Dell Gobi 3000 QDL */	125	{USB_DEVICE(0x413c, 0x8193)}, /* Dell Gobi 3000 QDL */
126	{USB_DEVICE(0x413c, 0x8194)}, /* Dell Gobi 3000 Composite */	126	{USB_DEVICE(0x413c, 0x8194)}, /* Dell Gobi 3000 Composite */
		127	{USB_DEVICE(0x413c, 0x81a6)}, /* Dell DW5570 QDL (MC8805) */
127	{USB_DEVICE(0x1199, 0x68a4)}, /* Sierra Wireless QDL */	128	{USB_DEVICE(0x1199, 0x68a4)}, /* Sierra Wireless QDL */
128	{USB_DEVICE(0x1199, 0x68a5)}, /* Sierra Wireless Modem */	129	{USB_DEVICE(0x1199, 0x68a5)}, /* Sierra Wireless Modem */
129	{USB_DEVICE(0x1199, 0x68a8)}, /* Sierra Wireless QDL */	130	{USB_DEVICE(0x1199, 0x68a8)}, /* Sierra Wireless QDL */

drivers/vfio/vfio_iommu_spapr_tce.c+5−6

@@ -1123,12 +1123,11 @@ static long tce_iommu_ioctl(void *iommu_data, · 1122 unmodified lines
1123	mutex_lock(&container->lock);	1123	mutex_lock(&container->lock);
1124		1124
1125	ret = tce_iommu_create_default_window(container);	1125	ret = tce_iommu_create_default_window(container);
1126	if (ret)	1126	if (!ret)
1127	return ret;	1127	ret = tce_iommu_create_window(container,
1128		1128	create.page_shift,
1129	ret = tce_iommu_create_window(container, create.page_shift,	1129	create.window_size, create.levels,
1130	create.window_size, create.levels,	1130	&create.start_addr);
1131	&create.start_addr);
1132		1131
1133	mutex_unlock(&container->lock);	1132	mutex_unlock(&container->lock);
1134		1133

drivers/vhost/vhost.c+4−6

 static void vhost_init_is_le(struct vhost_virtqueue *vq)
 {
-	if (vhost_has_feature(vq, VIRTIO_F_VERSION_1))
+	vq->is_le = vhost_has_feature(vq, VIRTIO_F_VERSION_1)
-		vq->is_le = true;
+		|| virtio_legacy_is_little_endian();
 }
 #endif /* CONFIG_VHOST_CROSS_ENDIAN_LEGACY */
 static void vhost_reset_is_le(struct vhost_virtqueue *vq)
 {
-	vq->is_le = virtio_legacy_is_little_endian();
+	vhost_init_is_le(vq);
 }
 struct vhost_flush_struct {
 	int r;
 	bool is_le = vq->is_le;
-	if (!vq->private_data) {
+	if (!vq->private_data)
-		vhost_reset_is_le(vq);
 		return 0;
-	}
 	vhost_init_is_le(vq);

drivers/virtio/virtio_ring.c+0−7

@@ -159,13 +159,6 @@ static bool vring_use_dma_api(struct virtio_device *vdev) · 158 unmodified lines
159	if (xen_domain())	159	if (xen_domain())
160	return true;	160	return true;
161		161
162	/*
163	* On ARM-based machines, the DMA ops will do the right thing,
164	* so always use them with legacy devices.
165	*/
166	if (IS_ENABLED(CONFIG_ARM) \|\| IS_ENABLED(CONFIG_ARM64))
167	return !virtio_has_feature(vdev, VIRTIO_F_VERSION_1);
168
169	return false;	162	return false;
170	}	163	}
171		164

fs/cifs/readdir.c+1−0

@@ -285,6 +285,7 @@ initiate_cifs_search(const unsigned int xid, struct file *file) · 284 unmodified lines
285	rc = -ENOMEM;	285	rc = -ENOMEM;
286	goto error_exit;	286	goto error_exit;
287	}	287	}
		288	spin_lock_init(&cifsFile->file_info_lock);
288	file->private_data = cifsFile;	289	file->private_data = cifsFile;
289	cifsFile->tlink = cifs_get_tlink(tlink);	290	cifsFile->tlink = cifs_get_tlink(tlink);
290	tcon = tlink_tcon(tlink);	291	tcon = tlink_tcon(tlink);

fs/dax.c+5−0

 		struct blk_dax_ctl dax = { 0 };
 		ssize_t map_len;
+		if (fatal_signal_pending(current)) {
+			ret = -EINTR;
+			break;
+		}
 		dax.sector = dax_iomap_sector(iomap, pos);
 		dax.size = (length + offset + PAGE_SIZE - 1) & PAGE_MASK;
 		map_len = dax_map_atomic(iomap->bdev, &dax);

fs/fscache/cookie.c+5−0

 		hlist_for_each_entry(object, &cookie->backing_objects, cookie_link) {
 			if (invalidate)
 				set_bit(FSCACHE_OBJECT_RETIRED, &object->flags);
+			clear_bit(FSCACHE_OBJECT_PENDING_WRITE, &object->flags);
 			fscache_raise_event(object, FSCACHE_OBJECT_EV_KILL);
 		}
 	} else {
 		wait_on_atomic_t(&cookie->n_active, fscache_wait_atomic_t,
 				 TASK_UNINTERRUPTIBLE);
+	/* Make sure any pending writes are cancelled. */
+	if (cookie->def->type != FSCACHE_COOKIE_TYPE_INDEX)
+		fscache_invalidate_writes(cookie);
 	/* Reset the cookie state if it wasn't relinquished */
 	if (!test_bit(FSCACHE_COOKIE_RELINQUISHED, &cookie->flags)) {
 		atomic_inc(&cookie->n_active);

fs/fscache/netfs.c+1−0

@@ -48,6 +48,7 @@ int __fscache_register_netfs(struct fscache_netfs *netfs) · 47 unmodified lines
48	cookie->flags = 1 << FSCACHE_COOKIE_ENABLED;	48	cookie->flags = 1 << FSCACHE_COOKIE_ENABLED;
49		49
50	spin_lock_init(&cookie->lock);	50	spin_lock_init(&cookie->lock);
		51	spin_lock_init(&cookie->stores_lock);
51	INIT_HLIST_HEAD(&cookie->backing_objects);	52	INIT_HLIST_HEAD(&cookie->backing_objects);
52		53
53	/* check the netfs type is not already present */	54	/* check the netfs type is not already present */

fs/fscache/object.c+30−2

 static const struct fscache_state *fscache_object_available(struct fscache_object *, int);
 static const struct fscache_state *fscache_parent_ready(struct fscache_object *, int);
 static const struct fscache_state *fscache_update_object(struct fscache_object *, int);
+static const struct fscache_state *fscache_object_dead(struct fscache_object *, int);
 #define __STATE_NAME(n) fscache_osm_##n
 #define STATE(n) (&__STATE_NAME(n))
 static WORK_STATE(KILL_OBJECT,		"KILL", fscache_kill_object);
 static WORK_STATE(KILL_DEPENDENTS,	"KDEP", fscache_kill_dependents);
 static WORK_STATE(DROP_OBJECT,		"DROP", fscache_drop_object);
-static WORK_STATE(OBJECT_DEAD,		"DEAD", (void*)2UL);
+static WORK_STATE(OBJECT_DEAD,		"DEAD", fscache_object_dead);
 static WAIT_STATE(WAIT_FOR_INIT,	"?INI",
 		  TRANSIT_TO(INIT_OBJECT,	1 << FSCACHE_OBJECT_EV_NEW_CHILD));
 	event = -1;
 	if (new_state == NO_TRANSIT) {
 		_debug("{OBJ%x} %s notrans", object->debug_id, state->name);
+		if (unlikely(state == STATE(OBJECT_DEAD))) {
+			_leave(" [dead]");
+			return;
+		}
 		fscache_enqueue_object(object);
 		event_mask = object->oob_event_mask;
 		goto unmask_events;
 	object->state = state = new_state;
 	if (state->work) {
-		if (unlikely(state->work == ((void *)2UL))) {
+		if (unlikely(state == STATE(OBJECT_DEAD))) {
 			_leave(" [dead]");
 			return;
 		}
 	fscache_mark_object_dead(object);
 	object->oob_event_mask = 0;
+	if (test_bit(FSCACHE_OBJECT_RETIRED, &object->flags)) {
+		/* Reject any new read/write ops and abort any that are pending. */
+		clear_bit(FSCACHE_OBJECT_PENDING_WRITE, &object->flags);
+		fscache_cancel_all_ops(object);
+	}
 	if (list_empty(&object->dependents) &&
 	    object->n_ops == 0 &&
 	    object->n_children == 0)
 	}
 }
 EXPORT_SYMBOL(fscache_object_mark_killed);
+/*
+ * The object is dead.  We can get here if an object gets queued by an event
+ * that would lead to its death (such as EV_KILL) when the dispatcher is
+ * already running (and so can be requeued) but hasn't yet cleared the event
+ * mask.
+ */
+static const struct fscache_state *fscache_object_dead(struct fscache_object *object,
+						       int event)
+{
+	if (!test_and_set_bit(FSCACHE_OBJECT_RUN_AFTER_DEAD,
+			      &object->flags))
+		return NO_TRANSIT;
+	WARN(true, "FS-Cache object redispatched after death");
+	return NO_TRANSIT;
+}

fs/iomap.c+3−0

@@ -114,6 +114,9 @@ iomap_write_begin(struct inode *inode, loff_t pos, unsigned len, unsigned flags, · 113 unmodified lines
114		114
115	BUG_ON(pos + len > iomap->offset + iomap->length);	115	BUG_ON(pos + len > iomap->offset + iomap->length);
116		116
		117	if (fatal_signal_pending(current))
		118	return -EINTR;
		119
117	page = grab_cache_page_write_begin(inode->i_mapping, index, flags);	120	page = grab_cache_page_write_begin(inode->i_mapping, index, flags);
118	if (!page)	121	if (!page)
119	return -ENOMEM;	122	return -ENOMEM;

fs/nfsd/vfs.c+60−37

 	}
 }
+static __be32
+nfsd_get_write_access(struct svc_rqst *rqstp, struct svc_fh *fhp,
+		struct iattr *iap)
+{
+	struct inode *inode = d_inode(fhp->fh_dentry);
+	int host_err;
+	if (iap->ia_size < inode->i_size) {
+		__be32 err;
+		err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
+				NFSD_MAY_TRUNC | NFSD_MAY_OWNER_OVERRIDE);
+		if (err)
+			return err;
+	}
+	host_err = get_write_access(inode);
+	if (host_err)
+		goto out_nfserrno;
+	host_err = locks_verify_truncate(inode, NULL, iap->ia_size);
+	if (host_err)
+		goto out_put_write_access;
+	return 0;
+out_put_write_access:
+	put_write_access(inode);
+out_nfserrno:
+	return nfserrno(host_err);
+}
 /*
  * Set various file attributes.  After this call fhp needs an fh_put.
  */
 	__be32		err;
 	int		host_err;
 	bool		get_write_count;
+	int		size_change = 0;
 	if (iap->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_SIZE))
 		accmode |= NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE;
 	/* Get inode */
 	err = fh_verify(rqstp, fhp, ftype, accmode);
 	if (err)
-		return err;
+		goto out;
 	if (get_write_count) {
 		host_err = fh_want_write(fhp);
 		if (host_err)
-			goto out_host_err;
+			return nfserrno(host_err);
 	}
 	dentry = fhp->fh_dentry;
 		iap->ia_valid &= ~ATTR_MODE;
 	if (!iap->ia_valid)
-		return 0;
+		goto out;
 	nfsd_sanitize_attrs(inode, iap);
-	if (check_guard && guardtime != inode->i_ctime.tv_sec)
-		return nfserr_notsync;
 	/*
 	 * The size case is special, it changes the file in addition to the
-	 * attributes, and file systems don't expect it to be mixed with
+	 * attributes.
-	 * "random" attribute changes.  We thus split out the size change
-	 * into a separate call for vfs_truncate, and do the rest as a
-	 * a separate setattr call.
 	 */
 	if (iap->ia_valid & ATTR_SIZE) {
-		struct path path = {
+		err = nfsd_get_write_access(rqstp, fhp, iap);
-			.mnt	= fhp->fh_export->ex_path.mnt,
+		if (err)
-			.dentry	= dentry,
+			goto out;
-		};
+		size_change = 1;
-		bool implicit_mtime = false;
 		/*
-		 * vfs_truncate implicity updates the mtime IFF the file size
+		 * RFC5661, Section 18.30.4:
-		 * actually changes.  Avoid the additional seattr call below if
+		 *   Changing the size of a file with SETATTR indirectly
-		 * the only other attribute that the client sends is the mtime.
+		 *   changes the time_modify and change attributes.
+		 *
+		 * (and similar for the older RFCs)
 		 */
-		if (iap->ia_size != i_size_read(inode) &&
+		if (iap->ia_size != i_size_read(inode))
-		    ((iap->ia_valid & ~(ATTR_SIZE | ATTR_MTIME)) == 0))
+			iap->ia_valid |= ATTR_MTIME;
-			implicit_mtime = true;
-		host_err = vfs_truncate(&path, iap->ia_size);
-		if (host_err)
-			goto out_host_err;
-		iap->ia_valid &= ~ATTR_SIZE;
-		if (implicit_mtime)
-			iap->ia_valid &= ~ATTR_MTIME;
-		if (!iap->ia_valid)
-			goto done;
 	}
 	iap->ia_valid |= ATTR_CTIME;
+	if (check_guard && guardtime != inode->i_ctime.tv_sec) {
+		err = nfserr_notsync;
+		goto out_put_write_access;
+	}
 	fh_lock(fhp);
 	host_err = notify_change(dentry, iap, NULL);
 	fh_unlock(fhp);
-	if (host_err)
+	err = nfserrno(host_err);
-		goto out_host_err;
-done:
+out_put_write_access:
-	host_err = commit_metadata(fhp);
+	if (size_change)
-out_host_err:
+		put_write_access(inode);
-	return nfserrno(host_err);
+	if (!err)
+		err = nfserrno(commit_metadata(fhp));
+out:
+	return err;
 }
 #if defined(CONFIG_NFSD_V4)

include/asm-generic/export.h+6−5

 #ifndef KSYM_ALIGN
 #define KSYM_ALIGN 8
 #endif
-#ifndef KCRC_ALIGN
-#define KCRC_ALIGN 8
-#endif
 #else
 #define __put .long
 #ifndef KSYM_ALIGN
 #define KSYM_ALIGN 4
 #endif
+#endif
 #ifndef KCRC_ALIGN
 #define KCRC_ALIGN 4
 #endif
-#endif
 #ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
 #define KSYM(name) _##name
 	.section ___kcrctab\sec+\name,"a"
 	.balign KCRC_ALIGN
 KSYM(__kcrctab_\name):
-	__put KSYM(__crc_\name)
+#if defined(CONFIG_MODULE_REL_CRCS)
+	.long KSYM(__crc_\name) - .
+#else
+	.long KSYM(__crc_\name)
+#endif
 	.weak KSYM(__crc_\name)
 	.previous
 #endif

include/drm/drmP.h+1−0

@@ -517,6 +517,7 @@ struct drm_device { · 516 unmodified lines
517	struct drm_minor control; /< Control node /	517	struct drm_minor control; /< Control node /
518	struct drm_minor primary; /< Primary node /	518	struct drm_minor primary; /< Primary node /
519	struct drm_minor render; /< Render node /	519	struct drm_minor render; /< Render node /
		520	bool registered;
520		521
521	/* currently active master for this device. Protected by master_mutex */	522	/* currently active master for this device. Protected by master_mutex */
522	struct drm_master *master;	523	struct drm_master *master;

include/drm/drm_connector.h+15−1

 	 * core drm connector interfaces. Everything added from this callback
 	 * should be unregistered in the early_unregister callback.
 	 *
+	 * This is called while holding drm_connector->mutex.
+	 *
 	 * Returns:
 	 *
 	 * 0 on success, or a negative error code on failure.
 	 * late_register(). It is called from drm_connector_unregister(),
 	 * early in the driver unload sequence to disable userspace access
 	 * before data structures are torndown.
+	 *
+	 * This is called while holding drm_connector->mutex.
 	 */
 	void (*early_unregister)(struct drm_connector *connector);
  * @interlace_allowed: can this connector handle interlaced modes?
  * @doublescan_allowed: can this connector handle doublescan?
  * @stereo_allowed: can this connector handle stereo modes?
- * @registered: is this connector exposed (registered) with userspace?
  * @modes: modes available on this connector (from fill_modes() + user)
  * @status: one of the drm_connector_status enums (connected, not, or unknown)
  * @probed_modes: list of modes derived directly from the display
 	char *name;
+	/**
+	 * @mutex: Lock for general connector state, but currently only protects
+	 * @registered. Most of the connector state is still protected by the
+	 * mutex in &drm_mode_config.
+	 */
+	struct mutex mutex;
 	/**
 	 * @index: Compacted connector index, which matches the position inside
 	 * the mode_config.list for drivers not supporting hot-add/removing. Can
 	bool interlace_allowed;
 	bool doublescan_allowed;
 	bool stereo_allowed;
+	/**
+	 * @registered: Is this connector exposed (registered) with userspace?
+	 * Protected by @mutex.
+	 */
 	bool registered;
 	struct list_head modes; /* list of modes on this connector */

include/linux/can/core.h+3−4

 extern int  can_proto_register(const struct can_proto *cp);
 extern void can_proto_unregister(const struct can_proto *cp);
-extern int  can_rx_register(struct net_device *dev, canid_t can_id,
+int can_rx_register(struct net_device *dev, canid_t can_id, canid_t mask,
-			    canid_t mask,
+		    void (*func)(struct sk_buff *, void *),
-			    void (*func)(struct sk_buff *, void *),
+		    void *data, char *ident, struct sock *sk);
-			    void *data, char *ident);
 extern void can_rx_unregister(struct net_device *dev, canid_t can_id,
 			      canid_t mask,

include/linux/cpuhotplug.h+0−3

 	CPUHP_CREATE_THREADS,
 	CPUHP_PERF_PREPARE,
 	CPUHP_PERF_X86_PREPARE,
-	CPUHP_PERF_X86_UNCORE_PREP,
 	CPUHP_PERF_X86_AMD_UNCORE_PREP,
-	CPUHP_PERF_X86_RAPL_PREP,
 	CPUHP_PERF_BFIN,
 	CPUHP_PERF_POWER,
 	CPUHP_PERF_SUPERH,
 	CPUHP_AP_IRQ_ARMADA_XP_STARTING,
 	CPUHP_AP_IRQ_BCM2836_STARTING,
 	CPUHP_AP_ARM_MVEBU_COHERENCY,
-	CPUHP_AP_PERF_X86_UNCORE_STARTING,
 	CPUHP_AP_PERF_X86_AMD_UNCORE_STARTING,
 	CPUHP_AP_PERF_X86_STARTING,
 	CPUHP_AP_PERF_X86_AMD_IBS_STARTING,

include/linux/export.h+12−5

 #ifdef CONFIG_MODVERSIONS
 /* Mark the CRC weak since genksyms apparently decides not to
  * generate a checksums for some symbols */
+#if defined(CONFIG_MODULE_REL_CRCS)
 #define __CRC_SYMBOL(sym, sec)						\
-	extern __visible void *__crc_##sym __attribute__((weak));	\
+	asm("	.section \"___kcrctab" sec "+" #sym "\", \"a\"	\n"	\
-	static const unsigned long __kcrctab_##sym			\
+	    "	.weak	" VMLINUX_SYMBOL_STR(__crc_##sym) "	\n"	\
-	__used								\
+	    "	.long	" VMLINUX_SYMBOL_STR(__crc_##sym) " - .	\n"	\
-	__attribute__((section("___kcrctab" sec "+" #sym), used))	\
+	    "	.previous					\n");
-	= (unsigned long) &__crc_##sym;
+#else
+#define __CRC_SYMBOL(sym, sec)						\
+	asm("	.section \"___kcrctab" sec "+" #sym "\", \"a\"	\n"	\
+	    "	.weak	" VMLINUX_SYMBOL_STR(__crc_##sym) "	\n"	\
+	    "	.long	" VMLINUX_SYMBOL_STR(__crc_##sym) "	\n"	\
+	    "	.previous					\n");
+#endif
 #else
 #define __CRC_SYMBOL(sym, sec)
 #endif

include/linux/fscache-cache.h+1−0

@@ -360,6 +360,7 @@ struct fscache_object { · 359 unmodified lines
360	#define FSCACHE_OBJECT_IS_AVAILABLE 5 /* T if object has become active */	360	#define FSCACHE_OBJECT_IS_AVAILABLE 5 /* T if object has become active */
361	#define FSCACHE_OBJECT_RETIRED 6 /* T if object was retired on relinquishment */	361	#define FSCACHE_OBJECT_RETIRED 6 /* T if object was retired on relinquishment */
362	#define FSCACHE_OBJECT_KILLED_BY_CACHE 7 /* T if object was killed by the cache */	362	#define FSCACHE_OBJECT_KILLED_BY_CACHE 7 /* T if object was killed by the cache */
		363	#define FSCACHE_OBJECT_RUN_AFTER_DEAD 8 /* T if object has been dispatched after death */
363		364
364	struct list_head cache_link; /* link in cache->object_list */	365	struct list_head cache_link; /* link in cache->object_list */
365	struct hlist_node cookie_link; /* link in cookie->backing_objects */	366	struct hlist_node cookie_link; /* link in cookie->backing_objects */

include/linux/hyperv.h+30−2

 	u32 ring_data_startoffset;
 	u32 priv_write_index;
 	u32 priv_read_index;
+	u32 cached_read_index;
 };
 /*
 	return write;
 }
+static inline u32 hv_get_cached_bytes_to_write(
+	const struct hv_ring_buffer_info *rbi)
+{
+	u32 read_loc, write_loc, dsize, write;
+	dsize = rbi->ring_datasize;
+	read_loc = rbi->cached_read_index;
+	write_loc = rbi->ring_buffer->write_index;
+	write = write_loc >= read_loc ? dsize - (write_loc - read_loc) :
+		read_loc - write_loc;
+	return write;
+}
 /*
  * VMBUS version is 32 bit entity broken up into
  * two 16 bit quantities: major_number. minor_number.
 static inline  void hv_signal_on_read(struct vmbus_channel *channel)
 {
-	u32 cur_write_sz;
+	u32 cur_write_sz, cached_write_sz;
 	u32 pending_sz;
 	struct hv_ring_buffer_info *rbi = &channel->inbound;
 	cur_write_sz = hv_get_bytes_to_write(rbi);
-	if (cur_write_sz >= pending_sz)
+	if (cur_write_sz < pending_sz)
+		return;
+	cached_write_sz = hv_get_cached_bytes_to_write(rbi);
+	if (cached_write_sz < pending_sz)
 		vmbus_setevent(channel);
 	return;
 }
+static inline void
+init_cached_read_index(struct vmbus_channel *channel)
+{
+	struct hv_ring_buffer_info *rbi = &channel->inbound;
+	rbi->cached_read_index = rbi->ring_buffer->read_index;
+}
 /*
  * An API to support in-place processing of incoming VMBUS packets.
  */
  * This call commits the read index and potentially signals the host.
  * Here is the pattern for using the "in-place" consumption APIs:
  *
+ * init_cached_read_index();
+ *
  * while (get_next_pkt_raw() {
  *	process the packet "in-place";
  *	put_pkt_raw();

include/linux/irq.h+17−0

  *
  * IRQD_TRIGGER_MASK		- Mask for the trigger type bits
  * IRQD_SETAFFINITY_PENDING	- Affinity setting is pending
+ * IRQD_ACTIVATED		- Interrupt has already been activated
  * IRQD_NO_BALANCING		- Balancing disabled for this IRQ
  * IRQD_PER_CPU			- Interrupt is per cpu
  * IRQD_AFFINITY_SET		- Interrupt affinity was set
 enum {
 	IRQD_TRIGGER_MASK		= 0xf,
 	IRQD_SETAFFINITY_PENDING	= (1 <<  8),
+	IRQD_ACTIVATED			= (1 <<  9),
 	IRQD_NO_BALANCING		= (1 << 10),
 	IRQD_PER_CPU			= (1 << 11),
 	IRQD_AFFINITY_SET		= (1 << 12),
 	return __irqd_to_state(d) & IRQD_AFFINITY_MANAGED;
 }
+static inline bool irqd_is_activated(struct irq_data *d)
+{
+	return __irqd_to_state(d) & IRQD_ACTIVATED;
+}
+static inline void irqd_set_activated(struct irq_data *d)
+{
+	__irqd_to_state(d) |= IRQD_ACTIVATED;
+}
+static inline void irqd_clr_activated(struct irq_data *d)
+{
+	__irqd_to_state(d) &= ~IRQD_ACTIVATED;
+}
 #undef __irqd_to_state
 static inline irq_hw_number_t irqd_to_hwirq(struct irq_data *d)

include/linux/log2.h+12−1

@@ -203,6 +203,17 @@ unsigned long __rounddown_pow_of_two(unsigned long n) · 202 unmodified lines
203	* ... and so on.	203	* ... and so on.
204	*/	204	*/
205		205
206	#define order_base_2(n) ilog2(roundup_pow_of_two(n))	206	static inline __attribute_const__
		207	int __order_base_2(unsigned long n)
		208	{
		209	return n > 1 ? ilog2(n - 1) + 1 : 0;
		210	}
207		211
		212	#define order_base_2(n) \
		213	( \
		214	__builtin_constant_p(n) ? ( \
		215	((n) == 0 \|\| (n) == 1) ? 0 : \
		216	ilog2((n) - 1) + 1) : \
		217	__order_base_2(n) \
		218	)
208	#endif /* _LINUX_LOG2_H */	219	#endif /* _LINUX_LOG2_H */

include/linux/memory_hotplug.h+2−1

@@ -85,7 +85,8 @@ extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages); · 84 unmodified lines
85	extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);	85	extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
86	/* VM interface that may be used by firmware interface */	86	/* VM interface that may be used by firmware interface */
87	extern int online_pages(unsigned long, unsigned long, int);	87	extern int online_pages(unsigned long, unsigned long, int);
88	extern int test_pages_in_a_zone(unsigned long, unsigned long);	88	extern int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn,
		89	unsigned long valid_start, unsigned long valid_end);
89	extern void __offline_isolated_pages(unsigned long, unsigned long);	90	extern void __offline_isolated_pages(unsigned long, unsigned long);
90		91
91	typedef void (online_page_callback_t)(struct page page);	92	typedef void (online_page_callback_t)(struct page page);

include/linux/module.h+7−7

@@ -346,7 +346,7 @@ struct module { · 345 unmodified lines
346		346
347	/* Exported symbols */	347	/* Exported symbols */
348	const struct kernel_symbol *syms;	348	const struct kernel_symbol *syms;
349	const unsigned long *crcs;	349	const s32 *crcs;
350	unsigned int num_syms;	350	unsigned int num_syms;
351		351
352	/* Kernel parameters. */	352	/* Kernel parameters. */
@@ -359,18 +359,18 @@ struct module { · 6 unmodified lines
359	/* GPL-only exported symbols. */	359	/* GPL-only exported symbols. */
360	unsigned int num_gpl_syms;	360	unsigned int num_gpl_syms;
361	const struct kernel_symbol *gpl_syms;	361	const struct kernel_symbol *gpl_syms;
362	const unsigned long *gpl_crcs;	362	const s32 *gpl_crcs;
363		363
364	#ifdef CONFIG_UNUSED_SYMBOLS	364	#ifdef CONFIG_UNUSED_SYMBOLS
365	/* unused exported symbols. */	365	/* unused exported symbols. */
366	const struct kernel_symbol *unused_syms;	366	const struct kernel_symbol *unused_syms;
367	const unsigned long *unused_crcs;	367	const s32 *unused_crcs;
368	unsigned int num_unused_syms;	368	unsigned int num_unused_syms;
369		369
370	/* GPL-only, unused exported symbols. */	370	/* GPL-only, unused exported symbols. */
371	unsigned int num_unused_gpl_syms;	371	unsigned int num_unused_gpl_syms;
372	const struct kernel_symbol *unused_gpl_syms;	372	const struct kernel_symbol *unused_gpl_syms;
373	const unsigned long *unused_gpl_crcs;	373	const s32 *unused_gpl_crcs;
374	#endif	374	#endif
375		375
376	#ifdef CONFIG_MODULE_SIG	376	#ifdef CONFIG_MODULE_SIG
@@ -382,7 +382,7 @@ struct module { · 5 unmodified lines
382		382
383	/* symbols that will be GPL-only in the near future. */	383	/* symbols that will be GPL-only in the near future. */
384	const struct kernel_symbol *gpl_future_syms;	384	const struct kernel_symbol *gpl_future_syms;
385	const unsigned long *gpl_future_crcs;	385	const s32 *gpl_future_crcs;
386	unsigned int num_gpl_future_syms;	386	unsigned int num_gpl_future_syms;
387		387
388	/* Exception table */	388	/* Exception table */
@@ -523,7 +523,7 @@ struct module find_module(const char name); · 134 unmodified lines
523		523
524	struct symsearch {	524	struct symsearch {
525	const struct kernel_symbol start, stop;	525	const struct kernel_symbol start, stop;
526	const unsigned long *crcs;	526	const s32 *crcs;
527	enum {	527	enum {
528	NOT_GPL_ONLY,	528	NOT_GPL_ONLY,
529	GPL_ONLY,	529	GPL_ONLY,
@@ -539,7 +539,7 @@ struct symsearch { · 9 unmodified lines
539	*/	539	*/
540	const struct kernel_symbol find_symbol(const char name,	540	const struct kernel_symbol find_symbol(const char name,
541	struct module **owner,	541	struct module **owner,
542	const unsigned long **crc,	542	const s32 **crc,
543	bool gplok,	543	bool gplok,
544	bool warn);	544	bool warn);
545		545

include/linux/netdevice.h+15−14

  *	of useless work if you return NETDEV_TX_BUSY.
  *	Required; cannot be NULL.
  *
- * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
+ * netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
- *		netdev_features_t features);
+ *					   struct net_device *dev
- *	Adjusts the requested feature flags according to device-specific
+ *					   netdev_features_t features);
- *	constraints, and returns the resulting flags. Must not modify
+ *	Called by core transmit path to determine if device is capable of
- *	the device state.
+ *	performing offload operations on a given packet. This is to give
+ *	the device an opportunity to implement any restrictions that cannot
+ *	be otherwise expressed by feature flags. The check is called with
+ *	the set of features that the stack has calculated and it returns
+ *	those the driver believes to be appropriate.
  *
  * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb,
  *                         void *accel_priv, select_queue_fallback_t fallback);
  *	Called to release previously enslaved netdev.
  *
  *      Feature/offload setting functions.
+ * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
+ *		netdev_features_t features);
+ *	Adjusts the requested feature flags according to device-specific
+ *	constraints, and returns the resulting flags. Must not modify
+ *	the device state.
+ *
  * int (*ndo_set_features)(struct net_device *dev, netdev_features_t features);
  *	Called to update device configuration to new features. Passed
  *	feature set might be less than what was returned by ndo_fix_features()).
  *	Callback to use for xmit over the accelerated station. This
  *	is used in place of ndo_start_xmit on accelerated net
  *	devices.
- * netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
- *					   struct net_device *dev
- *					   netdev_features_t features);
- *	Called by core transmit path to determine if device is capable of
- *	performing offload operations on a given packet. This is to give
- *	the device an opportunity to implement any restrictions that cannot
- *	be otherwise expressed by feature flags. The check is called with
- *	the set of features that the stack has calculated and it returns
- *	those the driver believes to be appropriate.
  * int (*ndo_set_tx_maxrate)(struct net_device *dev,
  *			     int queue_index, u32 maxrate);
  *	Called when a user wants to set a max-rate limitation of specific

include/linux/percpu-refcount.h+2−2

@@ -204,7 +204,7 @@ static inline void percpu_ref_get(struct percpu_ref *ref) · 203 unmodified lines
204	static inline bool percpu_ref_tryget(struct percpu_ref *ref)	204	static inline bool percpu_ref_tryget(struct percpu_ref *ref)
205	{	205	{
206	unsigned long __percpu *percpu_count;	206	unsigned long __percpu *percpu_count;
207	int ret;	207	bool ret;
208		208
209	rcu_read_lock_sched();	209	rcu_read_lock_sched();
210		210
@@ -238,7 +238,7 @@ static inline bool percpu_ref_tryget(struct percpu_ref *ref) · 27 unmodified lines
238	static inline bool percpu_ref_tryget_live(struct percpu_ref *ref)	238	static inline bool percpu_ref_tryget_live(struct percpu_ref *ref)
239	{	239	{
240	unsigned long __percpu *percpu_count;	240	unsigned long __percpu *percpu_count;
241	int ret = false;	241	bool ret = false;
242		242
243	rcu_read_lock_sched();	243	rcu_read_lock_sched();
244		244

include/net/ipv6.h+5−0

 {
 	u32 hash;
+	/* @flowlabel may include more than a flow label, eg, the traffic class.
+	 * Here we want only the flow label value.
+	 */
+	flowlabel &= IPV6_FLOWLABEL_MASK;
 	if (flowlabel ||
 	    net->ipv6.sysctl.auto_flowlabels == IP6_AUTO_FLOW_LABEL_OFF ||
 	    (!autolabel &&

include/uapi/linux/ethtool.h+3−1

 	ETHTOOL_LINK_MODE_10000baseLR_Full_BIT	= 44,
 	ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT	= 45,
 	ETHTOOL_LINK_MODE_10000baseER_Full_BIT	= 46,
+	ETHTOOL_LINK_MODE_2500baseT_Full_BIT	= 47,
+	ETHTOOL_LINK_MODE_5000baseT_Full_BIT	= 48,
 	/* Last allowed bit for __ETHTOOL_LINK_MODE_LEGACY_MASK is bit
 	 */
 	__ETHTOOL_LINK_MODE_LAST
-	  = ETHTOOL_LINK_MODE_10000baseER_Full_BIT,
+	  = ETHTOOL_LINK_MODE_5000baseT_Full_BIT,
 };
 #define __ETHTOOL_LINK_MODE_LEGACY_MASK(base_name)	\

init/Kconfig+4−0

 	  make them incompatible with the kernel you are running.  If
 	  unsure, say N.
+config MODULE_REL_CRCS
+	bool
+	depends on MODVERSIONS
 config MODULE_SRCVERSION_ALL
 	bool "Source checksum for all modules"
 	help

kernel/cgroup.c+5−8

 	return ERR_PTR(err);
 }
+/*
+ * The returned cgroup is fully initialized including its control mask, but
+ * it isn't associated with its kernfs_node and doesn't have the control
+ * mask applied.
+ */
 static struct cgroup *cgroup_create(struct cgroup *parent)
 {
 	struct cgroup_root *root = parent->root;
 	cgroup_propagate_control(cgrp);
-	/* @cgrp doesn't have dir yet so the following will only create csses */
-	ret = cgroup_apply_control_enable(cgrp);
-	if (ret)
-		goto out_destroy;
 	return cgrp;
 out_cancel_ref:
 out_free_cgrp:
 	kfree(cgrp);
 	return ERR_PTR(ret);
-out_destroy:
-	cgroup_destroy_locked(cgrp);
-	return ERR_PTR(ret);
 }
 static int cgroup_mkdir(struct kernfs_node *parent_kn, const char *name,

kernel/events/core.c+46−23

 static void
 list_add_event(struct perf_event *event, struct perf_event_context *ctx)
 {
 	lockdep_assert_held(&ctx->lock);
 	WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
 {
 	struct perf_event *group_leader = event->group_leader, *pos;
+	lockdep_assert_held(&event->ctx->lock);
 	/*
 	 * We can have double attach due to group movement in perf_event_open.
 	 */
 	struct perf_event *sibling, *tmp;
 	struct list_head *list = NULL;
+	lockdep_assert_held(&event->ctx->lock);
 	/*
 	 * We can have double detach due to exit/hot-unplug + close.
 	 */
  */
 static void perf_remove_from_context(struct perf_event *event, unsigned long flags)
 {
-	lockdep_assert_held(&event->ctx->mutex);
+	struct perf_event_context *ctx = event->ctx;
+	lockdep_assert_held(&ctx->mutex);
 	event_function_call(event, __perf_remove_from_context, (void *)flags);
+	/*
+	 * The above event_function_call() can NO-OP when it hits
+	 * TASK_TOMBSTONE. In that case we must already have been detached
+	 * from the context (by perf_event_exit_event()) but the grouping
+	 * might still be in-tact.
+	 */
+	WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
+	if ((flags & DETACH_GROUP) &&
+	    (event->attach_state & PERF_ATTACH_GROUP)) {
+		/*
+		 * Since in that case we cannot possibly be scheduled, simply
+		 * detach now.
+		 */
+		raw_spin_lock_irq(&ctx->lock);
+		perf_group_detach(event);
+		raw_spin_unlock_irq(&ctx->lock);
+	}
 }
 /*
 	char *buf = NULL;
 	char *name;
+	if (vma->vm_flags & VM_READ)
+		prot |= PROT_READ;
+	if (vma->vm_flags & VM_WRITE)
+		prot |= PROT_WRITE;
+	if (vma->vm_flags & VM_EXEC)
+		prot |= PROT_EXEC;
+	if (vma->vm_flags & VM_MAYSHARE)
+		flags = MAP_SHARED;
+	else
+		flags = MAP_PRIVATE;
+	if (vma->vm_flags & VM_DENYWRITE)
+		flags |= MAP_DENYWRITE;
+	if (vma->vm_flags & VM_MAYEXEC)
+		flags |= MAP_EXECUTABLE;
+	if (vma->vm_flags & VM_LOCKED)
+		flags |= MAP_LOCKED;
+	if (vma->vm_flags & VM_HUGETLB)
+		flags |= MAP_HUGETLB;
 	if (file) {
 		struct inode *inode;
 		dev_t dev;
 		maj = MAJOR(dev);
 		min = MINOR(dev);
-		if (vma->vm_flags & VM_READ)
-			prot |= PROT_READ;
-		if (vma->vm_flags & VM_WRITE)
-			prot |= PROT_WRITE;
-		if (vma->vm_flags & VM_EXEC)
-			prot |= PROT_EXEC;
-		if (vma->vm_flags & VM_MAYSHARE)
-			flags = MAP_SHARED;
-		else
-			flags = MAP_PRIVATE;
-		if (vma->vm_flags & VM_DENYWRITE)
-			flags |= MAP_DENYWRITE;
-		if (vma->vm_flags & VM_MAYEXEC)
-			flags |= MAP_EXECUTABLE;
-		if (vma->vm_flags & VM_LOCKED)
-			flags |= MAP_LOCKED;
-		if (vma->vm_flags & VM_HUGETLB)
-			flags |= MAP_HUGETLB;
 		goto got_name;
 	} else {
 		if (vma->vm_ops && vma->vm_ops->name) {

kernel/irq/irqdomain.c+30−14

@@ -1346,6 +1346,30 @@ void irq_domain_free_irqs_parent(struct irq_domain *domain, · 1345 unmodified lines
1346	}	1346	}
1347	EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent);	1347	EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent);
1348		1348
		1349	static void __irq_domain_activate_irq(struct irq_data *irq_data)
		1350	{
		1351	if (irq_data && irq_data->domain) {
		1352	struct irq_domain *domain = irq_data->domain;
		1353
		1354	if (irq_data->parent_data)
		1355	__irq_domain_activate_irq(irq_data->parent_data);
		1356	if (domain->ops->activate)
		1357	domain->ops->activate(domain, irq_data);
		1358	}
		1359	}
		1360
		1361	static void __irq_domain_deactivate_irq(struct irq_data *irq_data)
		1362	{
		1363	if (irq_data && irq_data->domain) {
		1364	struct irq_domain *domain = irq_data->domain;
		1365
		1366	if (domain->ops->deactivate)
		1367	domain->ops->deactivate(domain, irq_data);
		1368	if (irq_data->parent_data)
		1369	__irq_domain_deactivate_irq(irq_data->parent_data);
		1370	}
		1371	}
		1372
1349	/**	1373	/**
1350	* irq_domain_activate_irq - Call domain_ops->activate recursively to activate	1374	* irq_domain_activate_irq - Call domain_ops->activate recursively to activate
1351	* interrupt	1375	* interrupt
@@ -1356,13 +1380,9 @@ EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent); · 4 unmodified lines
1356	*/	1380	*/
1357	void irq_domain_activate_irq(struct irq_data *irq_data)	1381	void irq_domain_activate_irq(struct irq_data *irq_data)
1358	{	1382	{
1359	if (irq_data && irq_data->domain) {	1383	if (!irqd_is_activated(irq_data)) {
1360	struct irq_domain *domain = irq_data->domain;	1384	__irq_domain_activate_irq(irq_data);
1361		1385	irqd_set_activated(irq_data);
1362	if (irq_data->parent_data)
1363	irq_domain_activate_irq(irq_data->parent_data);
1364	if (domain->ops->activate)
1365	domain->ops->activate(domain, irq_data);
1366	}	1386	}
1367	}	1387	}
1368		1388
@@ -1376,13 +1396,9 @@ void irq_domain_activate_irq(struct irq_data *irq_data) · 7 unmodified lines
1376	*/	1396	*/
1377	void irq_domain_deactivate_irq(struct irq_data *irq_data)	1397	void irq_domain_deactivate_irq(struct irq_data *irq_data)
1378	{	1398	{
1379	if (irq_data && irq_data->domain) {	1399	if (irqd_is_activated(irq_data)) {
1380	struct irq_domain *domain = irq_data->domain;	1400	__irq_domain_deactivate_irq(irq_data);
1381		1401	irqd_clr_activated(irq_data);
1382	if (domain->ops->deactivate)
1383	domain->ops->deactivate(domain, irq_data);
1384	if (irq_data->parent_data)
1385	irq_domain_deactivate_irq(irq_data->parent_data);
1386	}	1402	}
1387	}	1403	}
1388		1404

kernel/module.c+25−28

@@ -389,16 +389,16 @@ extern const struct kernel_symbol __start___ksymtab_gpl[]; · 388 unmodified lines
389	extern const struct kernel_symbol __stop___ksymtab_gpl[];	389	extern const struct kernel_symbol __stop___ksymtab_gpl[];
390	extern const struct kernel_symbol __start___ksymtab_gpl_future[];	390	extern const struct kernel_symbol __start___ksymtab_gpl_future[];
391	extern const struct kernel_symbol __stop___ksymtab_gpl_future[];	391	extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
392	extern const unsigned long __start___kcrctab[];	392	extern const s32 __start___kcrctab[];
393	extern const unsigned long __start___kcrctab_gpl[];	393	extern const s32 __start___kcrctab_gpl[];
394	extern const unsigned long __start___kcrctab_gpl_future[];	394	extern const s32 __start___kcrctab_gpl_future[];
395	#ifdef CONFIG_UNUSED_SYMBOLS	395	#ifdef CONFIG_UNUSED_SYMBOLS
396	extern const struct kernel_symbol __start___ksymtab_unused[];	396	extern const struct kernel_symbol __start___ksymtab_unused[];
397	extern const struct kernel_symbol __stop___ksymtab_unused[];	397	extern const struct kernel_symbol __stop___ksymtab_unused[];
398	extern const struct kernel_symbol __start___ksymtab_unused_gpl[];	398	extern const struct kernel_symbol __start___ksymtab_unused_gpl[];
399	extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];	399	extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];
400	extern const unsigned long __start___kcrctab_unused[];	400	extern const s32 __start___kcrctab_unused[];
401	extern const unsigned long __start___kcrctab_unused_gpl[];	401	extern const s32 __start___kcrctab_unused_gpl[];
402	#endif	402	#endif
403		403
404	#ifndef CONFIG_MODVERSIONS	404	#ifndef CONFIG_MODVERSIONS
@@ -497,7 +497,7 @@ struct find_symbol_arg { · 92 unmodified lines
497		497
498	/* Output */	498	/* Output */
499	struct module *owner;	499	struct module *owner;
500	const unsigned long *crc;	500	const s32 *crc;
501	const struct kernel_symbol *sym;	501	const struct kernel_symbol *sym;
502	};	502	};
503		503
@@ -563,7 +563,7 @@ static bool find_symbol_in_section(const struct symsearch *syms, · 59 unmodified lines
563	* (optional) module which owns it. Needs preempt disabled or module_mutex. */	563	* (optional) module which owns it. Needs preempt disabled or module_mutex. */
564	const struct kernel_symbol find_symbol(const char name,	564	const struct kernel_symbol find_symbol(const char name,
565	struct module **owner,	565	struct module **owner,
566	const unsigned long **crc,	566	const s32 **crc,
567	bool gplok,	567	bool gplok,
568	bool warn)	568	bool warn)
569	{	569	{
@@ -1249,23 +1249,17 @@ static int try_to_force_load(struct module mod, const char reason) · 679 unmodified lines
1249	}	1249	}
1250		1250
1251	#ifdef CONFIG_MODVERSIONS	1251	#ifdef CONFIG_MODVERSIONS
1252	/* If the arch applies (non-zero) relocations to kernel kcrctab, unapply it. */	1252
1253	static unsigned long maybe_relocated(unsigned long crc,	1253	static u32 resolve_rel_crc(const s32 *crc)
1254	const struct module *crc_owner)
1255	{	1254	{
1256	#ifdef ARCH_RELOCATES_KCRCTAB	1255	return (u32 )((void )crc + crc);
1257	if (crc_owner == NULL)
1258	return crc - (unsigned long)reloc_start;
1259	#endif
1260	return crc;
1261	}	1256	}
1262		1257
1263	static int check_version(Elf_Shdr *sechdrs,	1258	static int check_version(Elf_Shdr *sechdrs,
1264	unsigned int versindex,	1259	unsigned int versindex,
1265	const char *symname,	1260	const char *symname,
1266	struct module *mod,	1261	struct module *mod,
1267	const unsigned long *crc,	1262	const s32 *crc)
1268	const struct module *crc_owner)
1269	{	1263	{
1270	unsigned int i, num_versions;	1264	unsigned int i, num_versions;
1271	struct modversion_info *versions;	1265	struct modversion_info *versions;
@@ -1283,13 +1277,19 @@ static int check_version(Elf_Shdr *sechdrs, · 11 unmodified lines
1283	/ sizeof(struct modversion_info);	1277	/ sizeof(struct modversion_info);
1284		1278
1285	for (i = 0; i < num_versions; i++) {	1279	for (i = 0; i < num_versions; i++) {
		1280	u32 crcval;
		1281
1286	if (strcmp(versions[i].name, symname) != 0)	1282	if (strcmp(versions[i].name, symname) != 0)
1287	continue;	1283	continue;
1288		1284
1289	if (versions[i].crc == maybe_relocated(*crc, crc_owner))	1285	if (IS_ENABLED(CONFIG_MODULE_REL_CRCS))
		1286	crcval = resolve_rel_crc(crc);
		1287	else
		1288	crcval = *crc;
		1289	if (versions[i].crc == crcval)
1290	return 1;	1290	return 1;
1291	pr_debug("Found checksum %lX vs module %lX\n",	1291	pr_debug("Found checksum %X vs module %lX\n",
1292	maybe_relocated(*crc, crc_owner), versions[i].crc);	1292	crcval, versions[i].crc);
1293	goto bad_version;	1293	goto bad_version;
1294	}	1294	}
1295		1295
@@ -1307,7 +1307,7 @@ static inline int check_modstruct_version(Elf_Shdr *sechdrs, · 11 unmodified lines
1307	unsigned int versindex,	1307	unsigned int versindex,
1308	struct module *mod)	1308	struct module *mod)
1309	{	1309	{
1310	const unsigned long *crc;	1310	const s32 *crc;
1311		1311
1312	/*	1312	/*
1313	* Since this should be found in kernel (which can't be removed), no	1313	* Since this should be found in kernel (which can't be removed), no
@@ -1321,8 +1321,7 @@ static inline int check_modstruct_version(Elf_Shdr *sechdrs, · 7 unmodified lines
1321	}	1321	}
1322	preempt_enable();	1322	preempt_enable();
1323	return check_version(sechdrs, versindex,	1323	return check_version(sechdrs, versindex,
1324	VMLINUX_SYMBOL_STR(module_layout), mod, crc,	1324	VMLINUX_SYMBOL_STR(module_layout), mod, crc);
1325	NULL);
1326	}	1325	}
1327		1326
1328	/* First part is kernel version, which we ignore if module has crcs. */	1327	/* First part is kernel version, which we ignore if module has crcs. */
@@ -1340,8 +1339,7 @@ static inline int check_version(Elf_Shdr *sechdrs, · 11 unmodified lines
1340	unsigned int versindex,	1339	unsigned int versindex,
1341	const char *symname,	1340	const char *symname,
1342	struct module *mod,	1341	struct module *mod,
1343	const unsigned long *crc,	1342	const s32 *crc)
1344	const struct module *crc_owner)
1345	{	1343	{
1346	return 1;	1344	return 1;
1347	}	1345	}
@@ -1368,7 +1366,7 @@ static const struct kernel_symbol resolve_symbol(struct module mod, · 20 unmodified lines
1368	{	1366	{
1369	struct module *owner;	1367	struct module *owner;
1370	const struct kernel_symbol *sym;	1368	const struct kernel_symbol *sym;
1371	const unsigned long *crc;	1369	const s32 *crc;
1372	int err;	1370	int err;
1373		1371
1374	/*	1372	/*
@@ -1383,8 +1381,7 @@ static const struct kernel_symbol resolve_symbol(struct module mod, · 8 unmodified lines
1383	if (!sym)	1381	if (!sym)
1384	goto unlock;	1382	goto unlock;
1385		1383
1386	if (!check_version(info->sechdrs, info->index.vers, name, mod, crc,	1384	if (!check_version(info->sechdrs, info->index.vers, name, mod, crc)) {
1387	owner)) {
1388	sym = ERR_PTR(-EINVAL);	1385	sym = ERR_PTR(-EINVAL);
1389	goto getname;	1386	goto getname;
1390	}	1387	}

kernel/trace/trace_hwlat.c+5−3

 static struct cpumask save_cpumask;
 static bool disable_migrate;
-static void move_to_next_cpu(void)
+static void move_to_next_cpu(bool initmask)
 {
 	static struct cpumask *current_mask;
 	int next_cpu;
 		return;
 	/* Just pick the first CPU on first iteration */
-	if (!current_mask) {
+	if (initmask) {
 		current_mask = &save_cpumask;
 		get_online_cpus();
 		cpumask_and(current_mask, cpu_online_mask, tracing_buffer_mask);
 static int kthread_fn(void *data)
 {
 	u64 interval;
+	bool initmask = true;
 	while (!kthread_should_stop()) {
-		move_to_next_cpu();
+		move_to_next_cpu(initmask);
+		initmask = false;
 		local_irq_disable();
 		get_sample();

kernel/trace/trace_kprobe.c+1−1

@@ -1372,7 +1372,7 @@ kprobe_trace_selftest_target(int a1, int a2, int a3, int a4, int a5, int a6) · 1371 unmodified lines
1372	return a1 + a2 + a3 + a4 + a5 + a6;	1372	return a1 + a2 + a3 + a4 + a5 + a6;
1373	}	1373	}
1374		1374
1375	static struct __init trace_event_file *	1375	static __init struct trace_event_file *
1376	find_trace_probe_file(struct trace_kprobe tk, struct trace_array tr)	1376	find_trace_probe_file(struct trace_kprobe tk, struct trace_array tr)
1377	{	1377	{
1378	struct trace_event_file *file;	1378	struct trace_event_file *file;

mm/filemap.c+5−0

 		cond_resched();
 find_page:
+		if (fatal_signal_pending(current)) {
+			error = -EINTR;
+			goto out;
+		}
 		page = find_get_page(mapping, index);
 		if (!page) {
 			page_cache_sync_readahead(mapping,

mm/kasan/report.c+3−0

  *
  */
+#include <linux/ftrace.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/printk.h>
 	if (likely(!kasan_report_enabled()))
 		return;
+	disable_trace_on_warning();
 	info.access_addr = (void *)addr;
 	info.access_size = size;
 	info.is_write = is_write;

mm/memory_hotplug.c+21−7

@@ -1483,17 +1483,20 @@ bool is_mem_section_removable(unsigned long start_pfn, unsigned long nr_pages) · 1482 unmodified lines
1483	}	1483	}
1484		1484
1485	/*	1485	/*
1486	* Confirm all pages in a range [start, end) is belongs to the same zone.	1486	* Confirm all pages in a range [start, end) belong to the same zone.
		1487	* When true, return its valid [start, end).
1487	*/	1488	*/
1488	int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn)	1489	int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn,
		1490	unsigned long valid_start, unsigned long valid_end)
1489	{	1491	{
1490	unsigned long pfn, sec_end_pfn;	1492	unsigned long pfn, sec_end_pfn;
		1493	unsigned long start, end;
1491	struct zone *zone = NULL;	1494	struct zone *zone = NULL;
1492	struct page *page;	1495	struct page *page;
1493	int i;	1496	int i;
1494	for (pfn = start_pfn, sec_end_pfn = SECTION_ALIGN_UP(start_pfn);	1497	for (pfn = start_pfn, sec_end_pfn = SECTION_ALIGN_UP(start_pfn + 1);
1495	pfn < end_pfn;	1498	pfn < end_pfn;
1496	pfn = sec_end_pfn + 1, sec_end_pfn += PAGES_PER_SECTION) {	1499	pfn = sec_end_pfn, sec_end_pfn += PAGES_PER_SECTION) {
1497	/* Make sure the memory section is present first */	1500	/* Make sure the memory section is present first */
1498	if (!present_section_nr(pfn_to_section_nr(pfn)))	1501	if (!present_section_nr(pfn_to_section_nr(pfn)))
1499	continue;	1502	continue;
@@ -1509,10 +1512,20 @@ int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn) · 9 unmodified lines
1509	page = pfn_to_page(pfn + i);	1512	page = pfn_to_page(pfn + i);
1510	if (zone && page_zone(page) != zone)	1513	if (zone && page_zone(page) != zone)
1511	return 0;	1514	return 0;
		1515	if (!zone)
		1516	start = pfn + i;
1512	zone = page_zone(page);	1517	zone = page_zone(page);
		1518	end = pfn + MAX_ORDER_NR_PAGES;
1513	}	1519	}
1514	}	1520	}
1515	return 1;	1521
		1522	if (zone) {
		1523	*valid_start = start;
		1524	*valid_end = end;
		1525	return 1;
		1526	} else {
		1527	return 0;
		1528	}
1516	}	1529	}
1517		1530
1518	/*	1531	/*
@@ -1839,6 +1852,7 @@ static int __ref __offline_pages(unsigned long start_pfn, · 320 unmodified lines
1839	long offlined_pages;	1852	long offlined_pages;
1840	int ret, drain, retry_max, node;	1853	int ret, drain, retry_max, node;
1841	unsigned long flags;	1854	unsigned long flags;
		1855	unsigned long valid_start, valid_end;
1842	struct zone *zone;	1856	struct zone *zone;
1843	struct memory_notify arg;	1857	struct memory_notify arg;
1844		1858
@@ -1849,10 +1863,10 @@ static int __ref __offline_pages(unsigned long start_pfn, · 4 unmodified lines
1849	return -EINVAL;	1863	return -EINVAL;
1850	/* This makes hotplug much easier...and readable.	1864	/* This makes hotplug much easier...and readable.
1851	we assume this for now. .*/	1865	we assume this for now. .*/
1852	if (!test_pages_in_a_zone(start_pfn, end_pfn))	1866	if (!test_pages_in_a_zone(start_pfn, end_pfn, &valid_start, &valid_end))
1853	return -EINVAL;	1867	return -EINVAL;
1854		1868
1855	zone = page_zone(pfn_to_page(start_pfn));	1869	zone = page_zone(pfn_to_page(valid_start));
1856	node = zone_to_nid(zone);	1870	node = zone_to_nid(zone);
1857	nr_pages = end_pfn - start_pfn;	1871	nr_pages = end_pfn - start_pfn;
1858		1872

mm/shmem.c+9−2

 		struct shrink_control *sc, unsigned long nr_to_split)
 {
 	LIST_HEAD(list), *pos, *next;
+	LIST_HEAD(to_remove);
 	struct inode *inode;
 	struct shmem_inode_info *info;
 	struct page *page;
 		/* Check if there's anything to gain */
 		if (round_up(inode->i_size, PAGE_SIZE) ==
 				round_up(inode->i_size, HPAGE_PMD_SIZE)) {
-			list_del_init(&info->shrinklist);
+			list_move(&info->shrinklist, &to_remove);
 			removed++;
-			iput(inode);
 			goto next;
 		}
 	}
 	spin_unlock(&sbinfo->shrinklist_lock);
+	list_for_each_safe(pos, next, &to_remove) {
+		info = list_entry(pos, struct shmem_inode_info, shrinklist);
+		inode = &info->vfs_inode;
+		list_del_init(&info->shrinklist);
+		iput(inode);
+	}
 	list_for_each_safe(pos, next, &list) {
 		int ret;

mm/zswap.c+29−1

 /* Enable/disable zswap (disabled by default) */
 static bool zswap_enabled;
-module_param_named(enabled, zswap_enabled, bool, 0644);
+static int zswap_enabled_param_set(const char *,
+				   const struct kernel_param *);
+static struct kernel_param_ops zswap_enabled_param_ops = {
+	.set =		zswap_enabled_param_set,
+	.get =		param_get_bool,
+};
+module_param_cb(enabled, &zswap_enabled_param_ops, &zswap_enabled, 0644);
 /* Crypto compressor to use */
 #define ZSWAP_COMPRESSOR_DEFAULT "lzo"
 /* used by param callback function */
 static bool zswap_init_started;
+/* fatal error during init */
+static bool zswap_init_failed;
 /*********************************
 * helpers and fwd declarations
 **********************************/
 	char *s = strstrip((char *)val);
 	int ret;
+	if (zswap_init_failed) {
+		pr_err("can't set param, initialization failed\n");
+		return -ENODEV;
+	}
 	/* no change required */
 	if (!strcmp(s, *(char **)kp->arg))
 		return 0;
 	return __zswap_param_set(val, kp, NULL, zswap_compressor);
 }
+static int zswap_enabled_param_set(const char *val,
+				   const struct kernel_param *kp)
+{
+	if (zswap_init_failed) {
+		pr_err("can't enable, initialization failed\n");
+		return -ENODEV;
+	}
+	return param_set_bool(val, kp);
+}
 /*********************************
 * writeback code
 **********************************/
 dstmem_fail:
 	zswap_entry_cache_destroy();
 cache_fail:
+	/* if built-in, we aren't unloaded on failure; don't allow use */
+	zswap_init_failed = true;
+	zswap_enabled = false;
 	return -ENOMEM;
 }
 /* must be late so crypto has time to come up */

net/can/af_can.c+10−2

  * @func: callback function on filter match
  * @data: returned parameter for callback function
  * @ident: string for calling module identification
+ * @sk: socket pointer (might be NULL)
  *
  * Description:
  *  Invokes the callback function with the received sk_buff and the given
  */
 int can_rx_register(struct net_device *dev, canid_t can_id, canid_t mask,
 		    void (*func)(struct sk_buff *, void *), void *data,
-		    char *ident)
+		    char *ident, struct sock *sk)
 {
 	struct receiver *r;
 	struct hlist_head *rl;
 		r->func    = func;
 		r->data    = data;
 		r->ident   = ident;
+		r->sk      = sk;
 		hlist_add_head_rcu(&r->list, rl);
 		d->entries++;
 static void can_rx_delete_receiver(struct rcu_head *rp)
 {
 	struct receiver *r = container_of(rp, struct receiver, rcu);
+	struct sock *sk = r->sk;
 	kmem_cache_free(rcv_cache, r);
+	if (sk)
+		sock_put(sk);
 }
 /**
 	spin_unlock(&can_rcvlists_lock);
 	/* schedule the receiver item for deletion */
-	if (r)
+	if (r) {
+		if (r->sk)
+			sock_hold(r->sk);
 		call_rcu(&r->rcu, can_rx_delete_receiver);
+	}
 }
 EXPORT_SYMBOL(can_rx_unregister);

net/can/af_can.h+2−1

 struct receiver {
 	struct hlist_node list;
-	struct rcu_head rcu;
 	canid_t can_id;
 	canid_t mask;
 	unsigned long matches;
 	void (*func)(struct sk_buff *, void *);
 	void *data;
 	char *ident;
+	struct sock *sk;
+	struct rcu_head rcu;
 };
 #define CAN_SFF_RCV_ARRAY_SZ (1 << CAN_SFF_ID_BITS)

net/can/bcm.c+18−9

@@ -734,14 +734,23 @@ static struct bcm_op bcm_find_op(struct list_head ops, · 733 unmodified lines
734		734
735	static void bcm_remove_op(struct bcm_op *op)	735	static void bcm_remove_op(struct bcm_op *op)
736	{	736	{
737	hrtimer_cancel(&op->timer);	737	if (op->tsklet.func) {
738	hrtimer_cancel(&op->thrtimer);	738	while (test_bit(TASKLET_STATE_SCHED, &op->tsklet.state) \|\|
739		739	test_bit(TASKLET_STATE_RUN, &op->tsklet.state) \|\|
740	if (op->tsklet.func)	740	hrtimer_active(&op->timer)) {
741	tasklet_kill(&op->tsklet);	741	hrtimer_cancel(&op->timer);
		742	tasklet_kill(&op->tsklet);
		743	}
		744	}
742		745
743	if (op->thrtsklet.func)	746	if (op->thrtsklet.func) {
744	tasklet_kill(&op->thrtsklet);	747	while (test_bit(TASKLET_STATE_SCHED, &op->thrtsklet.state) \|\|
		748	test_bit(TASKLET_STATE_RUN, &op->thrtsklet.state) \|\|
		749	hrtimer_active(&op->thrtimer)) {
		750	hrtimer_cancel(&op->thrtimer);
		751	tasklet_kill(&op->thrtsklet);
		752	}
		753	}
745		754
746	if ((op->frames) && (op->frames != &op->sframe))	755	if ((op->frames) && (op->frames != &op->sframe))
747	kfree(op->frames);	756	kfree(op->frames);
@@ -1216,7 +1225,7 @@ static int bcm_rx_setup(struct bcm_msg_head msg_head, struct msghdr msg, · 468 unmodified lines
1216	err = can_rx_register(dev, op->can_id,	1225	err = can_rx_register(dev, op->can_id,
1217	REGMASK(op->can_id),	1226	REGMASK(op->can_id),
1218	bcm_rx_handler, op,	1227	bcm_rx_handler, op,
1219	"bcm");	1228	"bcm", sk);
1220		1229
1221	op->rx_reg_dev = dev;	1230	op->rx_reg_dev = dev;
1222	dev_put(dev);	1231	dev_put(dev);
@@ -1225,7 +1234,7 @@ static int bcm_rx_setup(struct bcm_msg_head msg_head, struct msghdr msg, · 2 unmodified lines
1225	} else	1234	} else
1226	err = can_rx_register(NULL, op->can_id,	1235	err = can_rx_register(NULL, op->can_id,
1227	REGMASK(op->can_id),	1236	REGMASK(op->can_id),
1228	bcm_rx_handler, op, "bcm");	1237	bcm_rx_handler, op, "bcm", sk);
1229	if (err) {	1238	if (err) {
1230	/* this bcm rx op is broken -> remove it */	1239	/* this bcm rx op is broken -> remove it */
1231	list_del(&op->list);	1240	list_del(&op->list);

net/can/gw.c+1−1

@@ -442,7 +442,7 @@ static inline int cgw_register_filter(struct cgw_job *gwj) · 441 unmodified lines
442	{	442	{
443	return can_rx_register(gwj->src.dev, gwj->ccgw.filter.can_id,	443	return can_rx_register(gwj->src.dev, gwj->ccgw.filter.can_id,
444	gwj->ccgw.filter.can_mask, can_can_gw_rcv,	444	gwj->ccgw.filter.can_mask, can_can_gw_rcv,
445	gwj, "gw");	445	gwj, "gw", NULL);
446	}	446	}
447		447
448	static inline void cgw_unregister_filter(struct cgw_job *gwj)	448	static inline void cgw_unregister_filter(struct cgw_job *gwj)

net/can/raw.c+2−2

@@ -190,7 +190,7 @@ static int raw_enable_filters(struct net_device dev, struct sock sk, · 189 unmodified lines
190	for (i = 0; i < count; i++) {	190	for (i = 0; i < count; i++) {
191	err = can_rx_register(dev, filter[i].can_id,	191	err = can_rx_register(dev, filter[i].can_id,
192	filter[i].can_mask,	192	filter[i].can_mask,
193	raw_rcv, sk, "raw");	193	raw_rcv, sk, "raw", sk);
194	if (err) {	194	if (err) {
195	/* clean up successfully registered filters */	195	/* clean up successfully registered filters */
196	while (--i >= 0)	196	while (--i >= 0)
@@ -211,7 +211,7 @@ static int raw_enable_errfilter(struct net_device dev, struct sock sk, · 14 unmodified lines
211		211
212	if (err_mask)	212	if (err_mask)
213	err = can_rx_register(dev, 0, err_mask \| CAN_ERR_FLAG,	213	err = can_rx_register(dev, 0, err_mask \| CAN_ERR_FLAG,
214	raw_rcv, sk, "raw");	214	raw_rcv, sk, "raw", sk);
215		215
216	return err;	216	return err;
217	}	217	}

net/ipv4/tcp_output.c+4−2

@@ -2518,9 +2518,11 @@ u32 __tcp_select_window(struct sock *sk) · 2517 unmodified lines
2518	int full_space = min_t(int, tp->window_clamp, allowed_space);	2518	int full_space = min_t(int, tp->window_clamp, allowed_space);
2519	int window;	2519	int window;
2520		2520
2521	if (mss > full_space)	2521	if (unlikely(mss > full_space)) {
2522	mss = full_space;	2522	mss = full_space;
2523		2523	if (mss <= 0)
		2524	return 0;
		2525	}
2524	if (free_space < (full_space >> 1)) {	2526	if (free_space < (full_space >> 1)) {
2525	icsk->icsk_ack.quick = 0;	2527	icsk->icsk_ack.quick = 0;
2526		2528

net/ipv6/ip6_output.c+1−1

@@ -1344,7 +1344,7 @@ emsgsize: · 1343 unmodified lines
1344	*/	1344	*/
1345	if (transhdrlen && sk->sk_protocol == IPPROTO_UDP &&	1345	if (transhdrlen && sk->sk_protocol == IPPROTO_UDP &&
1346	headersize == sizeof(struct ipv6hdr) &&	1346	headersize == sizeof(struct ipv6hdr) &&
1347	length < mtu - headersize &&	1347	length <= mtu - headersize &&
1348	!(flags & MSG_MORE) &&	1348	!(flags & MSG_MORE) &&
1349	rt->dst.dev->features & (NETIF_F_IPV6_CSUM \| NETIF_F_HW_CSUM))	1349	rt->dst.dev->features & (NETIF_F_IPV6_CSUM \| NETIF_F_HW_CSUM))
1350	csummode = CHECKSUM_PARTIAL;	1350	csummode = CHECKSUM_PARTIAL;

net/ipv6/ip6_tunnel.c+1−1

@@ -441,7 +441,7 @@ __u16 ip6_tnl_parse_tlv_enc_lim(struct sk_buff skb, __u8 raw) · 440 unmodified lines
441	if (i + sizeof(*tel) > optlen)	441	if (i + sizeof(*tel) > optlen)
442	break;	442	break;
443		443
444	tel = (struct ipv6_tlv_tnl_enc_lim *) skb->data + off + i;	444	tel = (struct ipv6_tlv_tnl_enc_lim *)(skb->data + off + i);
445	/* return index of option if found and valid */	445	/* return index of option if found and valid */
446	if (tel->type == IPV6_TLV_TNL_ENCAP_LIMIT &&	446	if (tel->type == IPV6_TLV_TNL_ENCAP_LIMIT &&
447	tel->length == 1)	447	tel->length == 1)

net/sched/cls_flower.c+2−2

@@ -568,9 +568,9 @@ static int fl_set_key(struct net net, struct nlattr *tb, · 567 unmodified lines
568	&mask->icmp.type,	568	&mask->icmp.type,
569	TCA_FLOWER_KEY_ICMPV6_TYPE_MASK,	569	TCA_FLOWER_KEY_ICMPV6_TYPE_MASK,
570	sizeof(key->icmp.type));	570	sizeof(key->icmp.type));
571	fl_set_key_val(tb, &key->icmp.code, TCA_FLOWER_KEY_ICMPV4_CODE,	571	fl_set_key_val(tb, &key->icmp.code, TCA_FLOWER_KEY_ICMPV6_CODE,
572	&mask->icmp.code,	572	&mask->icmp.code,
573	TCA_FLOWER_KEY_ICMPV4_CODE_MASK,	573	TCA_FLOWER_KEY_ICMPV6_CODE_MASK,
574	sizeof(key->icmp.code));	574	sizeof(key->icmp.code));
575	}	575	}
576		576

net/sched/cls_matchall.c+45−82

@@ -16,16 +16,11 @@ · 15 unmodified lines
16	#include <net/sch_generic.h>	16	#include <net/sch_generic.h>
17	#include <net/pkt_cls.h>	17	#include <net/pkt_cls.h>
18		18
19	struct cls_mall_filter {	19	struct cls_mall_head {
20	struct tcf_exts exts;	20	struct tcf_exts exts;
21	struct tcf_result res;	21	struct tcf_result res;
22	u32 handle;	22	u32 handle;
23	struct rcu_head rcu;
24	u32 flags;	23	u32 flags;
25	};
26
27	struct cls_mall_head {
28	struct cls_mall_filter *filter;
29	struct rcu_head rcu;	24	struct rcu_head rcu;
30	};	25	};
31		26
@@ -33,38 +28,29 @@ static int mall_classify(struct sk_buff skb, const struct tcf_proto tp, · 1 unmodified line
33	struct tcf_result *res)	28	struct tcf_result *res)
34	{	29	{
35	struct cls_mall_head *head = rcu_dereference_bh(tp->root);	30	struct cls_mall_head *head = rcu_dereference_bh(tp->root);
36	struct cls_mall_filter *f = head->filter;
37		31
38	if (tc_skip_sw(f->flags))	32	if (tc_skip_sw(head->flags))
39	return -1;	33	return -1;
40		34
41	return tcf_exts_exec(skb, &f->exts, res);	35	return tcf_exts_exec(skb, &head->exts, res);
42	}	36	}
43		37
44	static int mall_init(struct tcf_proto *tp)	38	static int mall_init(struct tcf_proto *tp)
45	{	39	{
46	struct cls_mall_head *head;
47
48	head = kzalloc(sizeof(*head), GFP_KERNEL);
49	if (!head)
50	return -ENOBUFS;
51
52	rcu_assign_pointer(tp->root, head);
53
54	return 0;	40	return 0;
55	}	41	}
56		42
57	static void mall_destroy_filter(struct rcu_head *head)	43	static void mall_destroy_rcu(struct rcu_head *rcu)
58	{	44	{
59	struct cls_mall_filter *f = container_of(head, struct cls_mall_filter, rcu);	45	struct cls_mall_head *head = container_of(rcu, struct cls_mall_head,
		46	rcu);
60		47
61	tcf_exts_destroy(&f->exts);	48	tcf_exts_destroy(&head->exts);
62		49	kfree(head);
63	kfree(f);
64	}	50	}
65		51
66	static int mall_replace_hw_filter(struct tcf_proto *tp,	52	static int mall_replace_hw_filter(struct tcf_proto *tp,
67	struct cls_mall_filter *f,	53	struct cls_mall_head *head,
68	unsigned long cookie)	54	unsigned long cookie)
69	{	55	{
70	struct net_device *dev = tp->q->dev_queue->dev;	56	struct net_device *dev = tp->q->dev_queue->dev;
@@ -74,7 +60,7 @@ static int mall_replace_hw_filter(struct tcf_proto *tp, · 3 unmodified lines
74	offload.type = TC_SETUP_MATCHALL;	60	offload.type = TC_SETUP_MATCHALL;
75	offload.cls_mall = &mall_offload;	61	offload.cls_mall = &mall_offload;
76	offload.cls_mall->command = TC_CLSMATCHALL_REPLACE;	62	offload.cls_mall->command = TC_CLSMATCHALL_REPLACE;
77	offload.cls_mall->exts = &f->exts;	63	offload.cls_mall->exts = &head->exts;
78	offload.cls_mall->cookie = cookie;	64	offload.cls_mall->cookie = cookie;
79		65
80	return dev->netdev_ops->ndo_setup_tc(dev, tp->q->handle, tp->protocol,	66	return dev->netdev_ops->ndo_setup_tc(dev, tp->q->handle, tp->protocol,
@@ -82,7 +68,7 @@ static int mall_replace_hw_filter(struct tcf_proto *tp, · 1 unmodified line
82	}	68	}
83		69
84	static void mall_destroy_hw_filter(struct tcf_proto *tp,	70	static void mall_destroy_hw_filter(struct tcf_proto *tp,
85	struct cls_mall_filter *f,	71	struct cls_mall_head *head,
86	unsigned long cookie)	72	unsigned long cookie)
87	{	73	{
88	struct net_device *dev = tp->q->dev_queue->dev;	74	struct net_device *dev = tp->q->dev_queue->dev;
@@ -103,29 +89,20 @@ static bool mall_destroy(struct tcf_proto *tp, bool force) · 14 unmodified lines
103	{	89	{
104	struct cls_mall_head *head = rtnl_dereference(tp->root);	90	struct cls_mall_head *head = rtnl_dereference(tp->root);
105	struct net_device *dev = tp->q->dev_queue->dev;	91	struct net_device *dev = tp->q->dev_queue->dev;
106	struct cls_mall_filter *f = head->filter;
107		92
108	if (!force && f)	93	if (!head)
109	return false;	94	return true;
110		95
111	if (f) {	96	if (tc_should_offload(dev, tp, head->flags))
112	if (tc_should_offload(dev, tp, f->flags))	97	mall_destroy_hw_filter(tp, head, (unsigned long) head);
113	mall_destroy_hw_filter(tp, f, (unsigned long) f);
114		98
115	call_rcu(&f->rcu, mall_destroy_filter);	99	call_rcu(&head->rcu, mall_destroy_rcu);
116	}
117	kfree_rcu(head, rcu);
118	return true;	100	return true;
119	}	101	}
120		102
121	static unsigned long mall_get(struct tcf_proto *tp, u32 handle)	103	static unsigned long mall_get(struct tcf_proto *tp, u32 handle)
122	{	104	{
123	struct cls_mall_head *head = rtnl_dereference(tp->root);	105	return 0UL;
124	struct cls_mall_filter *f = head->filter;
125
126	if (f && f->handle == handle)
127	return (unsigned long) f;
128	return 0;
129	}	106	}
130		107
131	static const struct nla_policy mall_policy[TCA_MATCHALL_MAX + 1] = {	108	static const struct nla_policy mall_policy[TCA_MATCHALL_MAX + 1] = {
@@ -134,7 +111,7 @@ static const struct nla_policy mall_policy[TCA_MATCHALL_MAX + 1] = { · 2 unmodified lines
134	};	111	};
135		112
136	static int mall_set_parms(struct net net, struct tcf_proto tp,	113	static int mall_set_parms(struct net net, struct tcf_proto tp,
137	struct cls_mall_filter *f,	114	struct cls_mall_head *head,
138	unsigned long base, struct nlattr **tb,	115	unsigned long base, struct nlattr **tb,
139	struct nlattr *est, bool ovr)	116	struct nlattr *est, bool ovr)
140	{	117	{
@@ -147,11 +124,11 @@ static int mall_set_parms(struct net net, struct tcf_proto tp, · 6 unmodified lines
147	return err;	124	return err;
148		125
149	if (tb[TCA_MATCHALL_CLASSID]) {	126	if (tb[TCA_MATCHALL_CLASSID]) {
150	f->res.classid = nla_get_u32(tb[TCA_MATCHALL_CLASSID]);	127	head->res.classid = nla_get_u32(tb[TCA_MATCHALL_CLASSID]);
151	tcf_bind_filter(tp, &f->res, base);	128	tcf_bind_filter(tp, &head->res, base);
152	}	129	}
153		130
154	tcf_exts_change(tp, &f->exts, &e);	131	tcf_exts_change(tp, &head->exts, &e);
155		132
156	return 0;	133	return 0;
157	}	134	}
@@ -162,21 +139,17 @@ static int mall_change(struct net net, struct sk_buff in_skb, · 4 unmodified lines
162	unsigned long *arg, bool ovr)	139	unsigned long *arg, bool ovr)
163	{	140	{
164	struct cls_mall_head *head = rtnl_dereference(tp->root);	141	struct cls_mall_head *head = rtnl_dereference(tp->root);
165	struct cls_mall_filter fold = (struct cls_mall_filter ) *arg;
166	struct net_device *dev = tp->q->dev_queue->dev;	142	struct net_device *dev = tp->q->dev_queue->dev;
167	struct cls_mall_filter *f;
168	struct nlattr *tb[TCA_MATCHALL_MAX + 1];	143	struct nlattr *tb[TCA_MATCHALL_MAX + 1];
		144	struct cls_mall_head *new;
169	u32 flags = 0;	145	u32 flags = 0;
170	int err;	146	int err;
171		147
172	if (!tca[TCA_OPTIONS])	148	if (!tca[TCA_OPTIONS])
173	return -EINVAL;	149	return -EINVAL;
174		150
175	if (head->filter)	151	if (head)
176	return -EBUSY;	152	return -EEXIST;
177
178	if (fold)
179	return -EINVAL;
180		153
181	err = nla_parse_nested(tb, TCA_MATCHALL_MAX,	154	err = nla_parse_nested(tb, TCA_MATCHALL_MAX,
182	tca[TCA_OPTIONS], mall_policy);	155	tca[TCA_OPTIONS], mall_policy);
@@ -189,23 +162,23 @@ static int mall_change(struct net net, struct sk_buff in_skb, · 6 unmodified lines
189	return -EINVAL;	162	return -EINVAL;
190	}	163	}
191		164
192	f = kzalloc(sizeof(*f), GFP_KERNEL);	165	new = kzalloc(sizeof(*new), GFP_KERNEL);
193	if (!f)	166	if (!new)
194	return -ENOBUFS;	167	return -ENOBUFS;
195		168
196	tcf_exts_init(&f->exts, TCA_MATCHALL_ACT, 0);	169	tcf_exts_init(&new->exts, TCA_MATCHALL_ACT, 0);
197		170
198	if (!handle)	171	if (!handle)
199	handle = 1;	172	handle = 1;
200	f->handle = handle;	173	new->handle = handle;
201	f->flags = flags;	174	new->flags = flags;
202		175
203	err = mall_set_parms(net, tp, f, base, tb, tca[TCA_RATE], ovr);	176	err = mall_set_parms(net, tp, new, base, tb, tca[TCA_RATE], ovr);
204	if (err)	177	if (err)
205	goto errout;	178	goto errout;
206		179
207	if (tc_should_offload(dev, tp, flags)) {	180	if (tc_should_offload(dev, tp, flags)) {
208	err = mall_replace_hw_filter(tp, f, (unsigned long) f);	181	err = mall_replace_hw_filter(tp, new, (unsigned long) new);
209	if (err) {	182	if (err) {
210	if (tc_skip_sw(flags))	183	if (tc_skip_sw(flags))
211	goto errout;	184	goto errout;
@@ -214,39 +187,29 @@ static int mall_change(struct net net, struct sk_buff in_skb, · 2 unmodified lines
214	}	187	}
215	}	188	}
216		189
217	*arg = (unsigned long) f;	190	*arg = (unsigned long) head;
218	rcu_assign_pointer(head->filter, f);	191	rcu_assign_pointer(tp->root, new);
219		192	if (head)
		193	call_rcu(&head->rcu, mall_destroy_rcu);
220	return 0;	194	return 0;
221		195
222	errout:	196	errout:
223	kfree(f);	197	kfree(new);
224	return err;	198	return err;
225	}	199	}
226		200
227	static int mall_delete(struct tcf_proto *tp, unsigned long arg)	201	static int mall_delete(struct tcf_proto *tp, unsigned long arg)
228	{	202	{
229	struct cls_mall_head *head = rtnl_dereference(tp->root);	203	return -EOPNOTSUPP;
230	struct cls_mall_filter f = (struct cls_mall_filter ) arg;
231	struct net_device *dev = tp->q->dev_queue->dev;
232
233	if (tc_should_offload(dev, tp, f->flags))
234	mall_destroy_hw_filter(tp, f, (unsigned long) f);
235
236	RCU_INIT_POINTER(head->filter, NULL);
237	tcf_unbind_filter(tp, &f->res);
238	call_rcu(&f->rcu, mall_destroy_filter);
239	return 0;
240	}	204	}
241		205
242	static void mall_walk(struct tcf_proto tp, struct tcf_walker arg)	206	static void mall_walk(struct tcf_proto tp, struct tcf_walker arg)
243	{	207	{
244	struct cls_mall_head *head = rtnl_dereference(tp->root);	208	struct cls_mall_head *head = rtnl_dereference(tp->root);
245	struct cls_mall_filter *f = head->filter;
246		209
247	if (arg->count < arg->skip)	210	if (arg->count < arg->skip)
248	goto skip;	211	goto skip;
249	if (arg->fn(tp, (unsigned long) f, arg) < 0)	212	if (arg->fn(tp, (unsigned long) head, arg) < 0)
250	arg->stop = 1;	213	arg->stop = 1;
251	skip:	214	skip:
252	arg->count++;	215	arg->count++;
@@ -255,28 +218,28 @@ skip: · 2 unmodified lines
255	static int mall_dump(struct net net, struct tcf_proto tp, unsigned long fh,	218	static int mall_dump(struct net net, struct tcf_proto tp, unsigned long fh,
256	struct sk_buff skb, struct tcmsg t)	219	struct sk_buff skb, struct tcmsg t)
257	{	220	{
258	struct cls_mall_filter f = (struct cls_mall_filter ) fh;	221	struct cls_mall_head head = (struct cls_mall_head ) fh;
259	struct nlattr *nest;	222	struct nlattr *nest;
260		223
261	if (!f)	224	if (!head)
262	return skb->len;	225	return skb->len;
263		226
264	t->tcm_handle = f->handle;	227	t->tcm_handle = head->handle;
265		228
266	nest = nla_nest_start(skb, TCA_OPTIONS);	229	nest = nla_nest_start(skb, TCA_OPTIONS);
267	if (!nest)	230	if (!nest)
268	goto nla_put_failure;	231	goto nla_put_failure;
269		232
270	if (f->res.classid &&	233	if (head->res.classid &&
271	nla_put_u32(skb, TCA_MATCHALL_CLASSID, f->res.classid))	234	nla_put_u32(skb, TCA_MATCHALL_CLASSID, head->res.classid))
272	goto nla_put_failure;	235	goto nla_put_failure;
273		236
274	if (tcf_exts_dump(skb, &f->exts))	237	if (tcf_exts_dump(skb, &head->exts))
275	goto nla_put_failure;	238	goto nla_put_failure;
276		239
277	nla_nest_end(skb, nest);	240	nla_nest_end(skb, nest);
278		241
279	if (tcf_exts_dump_stats(skb, &f->exts) < 0)	242	if (tcf_exts_dump_stats(skb, &head->exts) < 0)
280	goto nla_put_failure;	243	goto nla_put_failure;
281		244
282	return skb->len;	245	return skb->len;

scripts/Makefile.build+2−0

     $(CPP) -D__GENKSYMS__ $(c_flags) $< |                                   \
     $(GENKSYMS) $(if $(1), -T $(2))                                         \
      $(patsubst y,-s _,$(CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX))             \
+     $(patsubst y,-R,$(CONFIG_MODULE_REL_CRCS))                             \
      $(if $(KBUILD_PRESERVE),-p)                                            \
      -r $(firstword $(wildcard $(2:.symtypes=.symref) /dev/null))
     $(CPP) -D__GENKSYMS__ $(c_flags) -xc - |                                \
     $(GENKSYMS) $(if $(1), -T $(2))                                         \
      $(patsubst y,-s _,$(CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX))             \
+     $(patsubst y,-R,$(CONFIG_MODULE_REL_CRCS))                             \
      $(if $(KBUILD_PRESERVE),-p)                                            \
      -r $(firstword $(wildcard $(2:.symtypes=.symref) /dev/null))

scripts/genksyms/genksyms.c+14−5

 int in_source_file;
 static int flag_debug, flag_dump_defs, flag_reference, flag_dump_types,
-	   flag_preserve, flag_warnings;
+	   flag_preserve, flag_warnings, flag_rel_crcs;
 static const char *mod_prefix = "";
 static int errors;
 			fputs(">\n", debugfile);
 		/* Used as a linker script. */
-		printf("%s__crc_%s = 0x%08lx ;\n", mod_prefix, name, crc);
+		printf(!flag_rel_crcs ? "%s__crc_%s = 0x%08lx;\n" :
+		       "SECTIONS { .rodata : ALIGN(4) { "
+		       "%s__crc_%s = .; LONG(0x%08lx); } }\n",
+		       mod_prefix, name, crc);
 	}
 }
 static void genksyms_usage(void)
 {
-	fputs("Usage:\n" "genksyms [-adDTwqhV] > /path/to/.tmp_obj.ver\n" "\n"
+	fputs("Usage:\n" "genksyms [-adDTwqhVR] > /path/to/.tmp_obj.ver\n" "\n"
 #ifdef __GNU_LIBRARY__
 	      "  -s, --symbol-prefix   Select symbol prefix\n"
 	      "  -d, --debug           Increment the debug level (repeatable)\n"
 	      "  -q, --quiet           Disable warnings (default)\n"
 	      "  -h, --help            Print this message\n"
 	      "  -V, --version         Print the release version\n"
+	      "  -R, --relative-crc    Emit section relative symbol CRCs\n"
 #else				/* __GNU_LIBRARY__ */
 	      "  -s                    Select symbol prefix\n"
 	      "  -d                    Increment the debug level (repeatable)\n"
 	      "  -q                    Disable warnings (default)\n"
 	      "  -h                    Print this message\n"
 	      "  -V                    Print the release version\n"
+	      "  -R                    Emit section relative symbol CRCs\n"
 #endif				/* __GNU_LIBRARY__ */
 	      , stderr);
 }
 		{"preserve", 0, 0, 'p'},
 		{"version", 0, 0, 'V'},
 		{"help", 0, 0, 'h'},
+		{"relative-crc", 0, 0, 'R'},
 		{0, 0, 0, 0}
 	};
-	while ((o = getopt_long(argc, argv, "s:dwqVDr:T:ph",
+	while ((o = getopt_long(argc, argv, "s:dwqVDr:T:phR",
 				&long_opts[0], NULL)) != EOF)
 #else				/* __GNU_LIBRARY__ */
-	while ((o = getopt(argc, argv, "s:dwqVDr:T:ph")) != EOF)
+	while ((o = getopt(argc, argv, "s:dwqVDr:T:phR")) != EOF)
 #endif				/* __GNU_LIBRARY__ */
 		switch (o) {
 		case 's':
 		case 'h':
 			genksyms_usage();
 			return 0;
+		case 'R':
+			flag_rel_crcs = 1;
+			break;
 		default:
 			genksyms_usage();
 			return 1;

scripts/kallsyms.c+12−0

 		"_SDA2_BASE_",		/* ppc */
 		NULL };
+	static char *special_prefixes[] = {
+		"__crc_",		/* modversions */
+		NULL };
 	static char *special_suffixes[] = {
 		"_veneer",		/* arm */
 		"_from_arm",		/* arm */
 		if (strcmp(sym_name, special_symbols[i]) == 0)
 			return 0;
+	for (i = 0; special_prefixes[i]; i++) {
+		int l = strlen(special_prefixes[i]);
+		if (l <= strlen(sym_name) &&
+		    strncmp(sym_name, special_prefixes[i], l) == 0)
+			return 0;
+	}
 	for (i = 0; special_suffixes[i]; i++) {
 		int l = strlen(sym_name) - strlen(special_suffixes[i]);

scripts/mod/modpost.c+10−0

@@ -621,6 +621,16 @@ static void handle_modversions(struct module mod, struct elf_info info, · 620 unmodified lines
621	if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {	621	if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
622	is_crc = true;	622	is_crc = true;
623	crc = (unsigned int) sym->st_value;	623	crc = (unsigned int) sym->st_value;
		624	if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS) {
		625	unsigned int *crcp;
		626
		627	/* symbol points to the CRC in the ELF object */
		628	crcp = (void *)info->hdr + sym->st_value +
		629	info->sechdrs[sym->st_shndx].sh_offset -
		630	(info->hdr->e_type != ET_REL ?
		631	info->sechdrs[sym->st_shndx].sh_addr : 0);
		632	crc = *crcp;
		633	}
624	sym_update_crc(symname + strlen(CRC_PFX), mod, crc,	634	sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
625	export);	635	export);
626	}	636	}

tools/objtool/arch/x86/decode.c+1−1

 		*type = INSN_RETURN;
 		break;
-	case 0xc5: /* iret */
 	case 0xca: /* retf */
 	case 0xcb: /* retf */
+	case 0xcf: /* iret */
 		*type = INSN_CONTEXT_SWITCH;
 		break;