[gentoo-commits] proj/linux-patches:4.9 commit in: /

[Alice Ferrazzi]

commit:     b6cc76d171506ea5f54f296e60c2abad9a0ad920
Author:     Alice Ferrazzi <alicef <AT> gentoo <DOT> org>
AuthorDate: Thu Feb  9 11:11:34 2017 +0000
Commit:     Alice Ferrazzi <alicef <AT> gentoo <DOT> org>
CommitDate: Thu Feb  9 11:11:34 2017 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=b6cc76d1

Linux patch 4.9.9

 0000_README            |    4 +
 1008_linux-4.9.9.patch | 2333 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 2337 insertions(+)

diff --git a/0000_README b/0000_README
index c9cccee..3bab163 100644
--- a/0000_README
+++ b/0000_README
@@ -75,6 +75,10 @@ Patch:  1007_linux-4.9.8.patch
 From:   http://www.kernel.org
 Desc:   Linux 4.9.8
 
+Patch:  1008_linux-4.9.9.patch
+From:   http://www.kernel.org
+Desc:   Linux 4.9.9
+
 Patch:  1500_XATTR_USER_PREFIX.patch
 From:   https://bugs.gentoo.org/show_bug.cgi?id=470644
 Desc:   Support for namespace user.pax.* on tmpfs.

diff --git a/1008_linux-4.9.9.patch b/1008_linux-4.9.9.patch
new file mode 100644
index 0000000..393ec22
--- /dev/null
+++ b/1008_linux-4.9.9.patch
@@ -0,0 +1,2333 @@
+diff --git a/Makefile b/Makefile
+index 1130803ab93c..c0c41c9fac0c 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,6 +1,6 @@
+ VERSION = 4
+ PATCHLEVEL = 9
+-SUBLEVEL = 8
++SUBLEVEL = 9
+ EXTRAVERSION =
+ NAME = Roaring Lionus
+ 
+diff --git a/arch/arm64/crypto/aes-modes.S b/arch/arm64/crypto/aes-modes.S
+index c53dbeae79f2..838dad5c209f 100644
+--- a/arch/arm64/crypto/aes-modes.S
++++ b/arch/arm64/crypto/aes-modes.S
+@@ -193,15 +193,16 @@ AES_ENTRY(aes_cbc_encrypt)
+ 	cbz		w6, .Lcbcencloop
+ 
+ 	ld1		{v0.16b}, [x5]			/* get iv */
+-	enc_prepare	w3, x2, x5
++	enc_prepare	w3, x2, x6
+ 
+ .Lcbcencloop:
+ 	ld1		{v1.16b}, [x1], #16		/* get next pt block */
+ 	eor		v0.16b, v0.16b, v1.16b		/* ..and xor with iv */
+-	encrypt_block	v0, w3, x2, x5, w6
++	encrypt_block	v0, w3, x2, x6, w7
+ 	st1		{v0.16b}, [x0], #16
+ 	subs		w4, w4, #1
+ 	bne		.Lcbcencloop
++	st1		{v0.16b}, [x5]			/* return iv */
+ 	ret
+ AES_ENDPROC(aes_cbc_encrypt)
+ 
+@@ -211,7 +212,7 @@ AES_ENTRY(aes_cbc_decrypt)
+ 	cbz		w6, .LcbcdecloopNx
+ 
+ 	ld1		{v7.16b}, [x5]			/* get iv */
+-	dec_prepare	w3, x2, x5
++	dec_prepare	w3, x2, x6
+ 
+ .LcbcdecloopNx:
+ #if INTERLEAVE >= 2
+@@ -248,7 +249,7 @@ AES_ENTRY(aes_cbc_decrypt)
+ .Lcbcdecloop:
+ 	ld1		{v1.16b}, [x1], #16		/* get next ct block */
+ 	mov		v0.16b, v1.16b			/* ...and copy to v0 */
+-	decrypt_block	v0, w3, x2, x5, w6
++	decrypt_block	v0, w3, x2, x6, w7
+ 	eor		v0.16b, v0.16b, v7.16b		/* xor with iv => pt */
+ 	mov		v7.16b, v1.16b			/* ct is next iv */
+ 	st1		{v0.16b}, [x0], #16
+@@ -256,6 +257,7 @@ AES_ENTRY(aes_cbc_decrypt)
+ 	bne		.Lcbcdecloop
+ .Lcbcdecout:
+ 	FRAME_POP
++	st1		{v7.16b}, [x5]			/* return iv */
+ 	ret
+ AES_ENDPROC(aes_cbc_decrypt)
+ 
+@@ -267,24 +269,15 @@ AES_ENDPROC(aes_cbc_decrypt)
+ 
+ AES_ENTRY(aes_ctr_encrypt)
+ 	FRAME_PUSH
+-	cbnz		w6, .Lctrfirst		/* 1st time around? */
+-	umov		x5, v4.d[1]		/* keep swabbed ctr in reg */
+-	rev		x5, x5
+-#if INTERLEAVE >= 2
+-	cmn		w5, w4			/* 32 bit overflow? */
+-	bcs		.Lctrinc
+-	add		x5, x5, #1		/* increment BE ctr */
+-	b		.LctrincNx
+-#else
+-	b		.Lctrinc
+-#endif
+-.Lctrfirst:
++	cbz		w6, .Lctrnotfirst	/* 1st time around? */
+ 	enc_prepare	w3, x2, x6
+ 	ld1		{v4.16b}, [x5]
+-	umov		x5, v4.d[1]		/* keep swabbed ctr in reg */
+-	rev		x5, x5
++
++.Lctrnotfirst:
++	umov		x8, v4.d[1]		/* keep swabbed ctr in reg */
++	rev		x8, x8
+ #if INTERLEAVE >= 2
+-	cmn		w5, w4			/* 32 bit overflow? */
++	cmn		w8, w4			/* 32 bit overflow? */
+ 	bcs		.Lctrloop
+ .LctrloopNx:
+ 	subs		w4, w4, #INTERLEAVE
+@@ -292,11 +285,11 @@ AES_ENTRY(aes_ctr_encrypt)
+ #if INTERLEAVE == 2
+ 	mov		v0.8b, v4.8b
+ 	mov		v1.8b, v4.8b
+-	rev		x7, x5
+-	add		x5, x5, #1
++	rev		x7, x8
++	add		x8, x8, #1
+ 	ins		v0.d[1], x7
+-	rev		x7, x5
+-	add		x5, x5, #1
++	rev		x7, x8
++	add		x8, x8, #1
+ 	ins		v1.d[1], x7
+ 	ld1		{v2.16b-v3.16b}, [x1], #32	/* get 2 input blocks */
+ 	do_encrypt_block2x
+@@ -305,7 +298,7 @@ AES_ENTRY(aes_ctr_encrypt)
+ 	st1		{v0.16b-v1.16b}, [x0], #32
+ #else
+ 	ldr		q8, =0x30000000200000001	/* addends 1,2,3[,0] */
+-	dup		v7.4s, w5
++	dup		v7.4s, w8
+ 	mov		v0.16b, v4.16b
+ 	add		v7.4s, v7.4s, v8.4s
+ 	mov		v1.16b, v4.16b
+@@ -323,18 +316,12 @@ AES_ENTRY(aes_ctr_encrypt)
+ 	eor		v2.16b, v7.16b, v2.16b
+ 	eor		v3.16b, v5.16b, v3.16b
+ 	st1		{v0.16b-v3.16b}, [x0], #64
+-	add		x5, x5, #INTERLEAVE
++	add		x8, x8, #INTERLEAVE
+ #endif
+-	cbz		w4, .LctroutNx
+-.LctrincNx:
+-	rev		x7, x5
++	rev		x7, x8
+ 	ins		v4.d[1], x7
++	cbz		w4, .Lctrout
+ 	b		.LctrloopNx
+-.LctroutNx:
+-	sub		x5, x5, #1
+-	rev		x7, x5
+-	ins		v4.d[1], x7
+-	b		.Lctrout
+ .Lctr1x:
+ 	adds		w4, w4, #INTERLEAVE
+ 	beq		.Lctrout
+@@ -342,30 +329,39 @@ AES_ENTRY(aes_ctr_encrypt)
+ .Lctrloop:
+ 	mov		v0.16b, v4.16b
+ 	encrypt_block	v0, w3, x2, x6, w7
++
++	adds		x8, x8, #1		/* increment BE ctr */
++	rev		x7, x8
++	ins		v4.d[1], x7
++	bcs		.Lctrcarry		/* overflow? */
++
++.Lctrcarrydone:
+ 	subs		w4, w4, #1
+ 	bmi		.Lctrhalfblock		/* blocks < 0 means 1/2 block */
+ 	ld1		{v3.16b}, [x1], #16
+ 	eor		v3.16b, v0.16b, v3.16b
+ 	st1		{v3.16b}, [x0], #16
+-	beq		.Lctrout
+-.Lctrinc:
+-	adds		x5, x5, #1		/* increment BE ctr */
+-	rev		x7, x5
+-	ins		v4.d[1], x7
+-	bcc		.Lctrloop		/* no overflow? */
+-	umov		x7, v4.d[0]		/* load upper word of ctr  */
+-	rev		x7, x7			/* ... to handle the carry */
+-	add		x7, x7, #1
+-	rev		x7, x7
+-	ins		v4.d[0], x7
+-	b		.Lctrloop
++	bne		.Lctrloop
++
++.Lctrout:
++	st1		{v4.16b}, [x5]		/* return next CTR value */
++	FRAME_POP
++	ret
++
+ .Lctrhalfblock:
+ 	ld1		{v3.8b}, [x1]
+ 	eor		v3.8b, v0.8b, v3.8b
+ 	st1		{v3.8b}, [x0]
+-.Lctrout:
+ 	FRAME_POP
+ 	ret
++
++.Lctrcarry:
++	umov		x7, v4.d[0]		/* load upper word of ctr  */
++	rev		x7, x7			/* ... to handle the carry */
++	add		x7, x7, #1
++	rev		x7, x7
++	ins		v4.d[0], x7
++	b		.Lctrcarrydone
+ AES_ENDPROC(aes_ctr_encrypt)
+ 	.ltorg
+ 
+diff --git a/arch/powerpc/include/asm/cpu_has_feature.h b/arch/powerpc/include/asm/cpu_has_feature.h
+index b312b152461b..6e834caa3720 100644
+--- a/arch/powerpc/include/asm/cpu_has_feature.h
++++ b/arch/powerpc/include/asm/cpu_has_feature.h
+@@ -23,7 +23,9 @@ static __always_inline bool cpu_has_feature(unsigned long feature)
+ {
+ 	int i;
+ 
++#ifndef __clang__ /* clang can't cope with this */
+ 	BUILD_BUG_ON(!__builtin_constant_p(feature));
++#endif
+ 
+ #ifdef CONFIG_JUMP_LABEL_FEATURE_CHECK_DEBUG
+ 	if (!static_key_initialized) {
+diff --git a/arch/powerpc/include/asm/mmu.h b/arch/powerpc/include/asm/mmu.h
+index e311c25751a4..a244e09d2d88 100644
+--- a/arch/powerpc/include/asm/mmu.h
++++ b/arch/powerpc/include/asm/mmu.h
+@@ -160,7 +160,9 @@ static __always_inline bool mmu_has_feature(unsigned long feature)
+ {
+ 	int i;
+ 
++#ifndef __clang__ /* clang can't cope with this */
+ 	BUILD_BUG_ON(!__builtin_constant_p(feature));
++#endif
+ 
+ #ifdef CONFIG_JUMP_LABEL_FEATURE_CHECK_DEBUG
+ 	if (!static_key_initialized) {
+diff --git a/arch/powerpc/kernel/eeh_driver.c b/arch/powerpc/kernel/eeh_driver.c
+index 5c31369435f2..a5dd493670a0 100644
+--- a/arch/powerpc/kernel/eeh_driver.c
++++ b/arch/powerpc/kernel/eeh_driver.c
+@@ -545,7 +545,7 @@ static void *eeh_pe_detach_dev(void *data, void *userdata)
+ static void *__eeh_clear_pe_frozen_state(void *data, void *flag)
+ {
+ 	struct eeh_pe *pe = (struct eeh_pe *)data;
+-	bool *clear_sw_state = flag;
++	bool clear_sw_state = *(bool *)flag;
+ 	int i, rc = 1;
+ 
+ 	for (i = 0; rc && i < 3; i++)
+diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c
+index 88ac964f4858..1e8c57207346 100644
+--- a/arch/powerpc/kernel/prom_init.c
++++ b/arch/powerpc/kernel/prom_init.c
+@@ -2747,6 +2747,9 @@ static void __init prom_find_boot_cpu(void)
+ 
+ 	cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
+ 
++	if (!PHANDLE_VALID(cpu_pkg))
++		return;
++
+ 	prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval));
+ 	prom.cpu = be32_to_cpu(rval);
+ 
+diff --git a/arch/powerpc/mm/pgtable-radix.c b/arch/powerpc/mm/pgtable-radix.c
+index ebb7f46f0532..9a25dce87875 100644
+--- a/arch/powerpc/mm/pgtable-radix.c
++++ b/arch/powerpc/mm/pgtable-radix.c
+@@ -65,7 +65,7 @@ int radix__map_kernel_page(unsigned long ea, unsigned long pa,
+ 		if (!pmdp)
+ 			return -ENOMEM;
+ 		if (map_page_size == PMD_SIZE) {
+-			ptep = (pte_t *)pudp;
++			ptep = pmdp_ptep(pmdp);
+ 			goto set_the_pte;
+ 		}
+ 		ptep = pte_alloc_kernel(pmdp, ea);
+@@ -90,7 +90,7 @@ int radix__map_kernel_page(unsigned long ea, unsigned long pa,
+ 		}
+ 		pmdp = pmd_offset(pudp, ea);
+ 		if (map_page_size == PMD_SIZE) {
+-			ptep = (pte_t *)pudp;
++			ptep = pmdp_ptep(pmdp);
+ 			goto set_the_pte;
+ 		}
+ 		if (!pmd_present(*pmdp)) {
+diff --git a/arch/x86/events/intel/uncore.c b/arch/x86/events/intel/uncore.c
+index dbaaf7dc8373..19d646a783fd 100644
+--- a/arch/x86/events/intel/uncore.c
++++ b/arch/x86/events/intel/uncore.c
+@@ -763,30 +763,6 @@ static void uncore_pmu_unregister(struct intel_uncore_pmu *pmu)
+ 	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;
+@@ -1077,22 +1053,12 @@ static int uncore_cpu_dying(unsigned int cpu)
+ 	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));
+-	}
++	int i, pkg;
+ 
+ 	pkg = topology_logical_package_id(cpu);
+ 	for (; *types; types++) {
+@@ -1103,7 +1069,7 @@ static int uncore_cpu_starting(unsigned int cpu)
+ 			if (!box)
+ 				continue;
+ 			/* The first cpu on a package activates the box */
+-			if (atomic_add_return(ncpus, &box->refcnt) == ncpus)
++			if (atomic_inc_return(&box->refcnt) == 1)
+ 				uncore_box_init(box);
+ 		}
+ 	}
+@@ -1407,19 +1373,17 @@ static int __init intel_uncore_init(void)
+ 					  "PERF_X86_UNCORE_PREP",
+ 					  uncore_cpu_prepare, NULL);
+ 	}
+-	first_init = 1;
++
+ 	cpuhp_setup_state(CPUHP_AP_PERF_X86_UNCORE_STARTING,
+ 			  "AP_PERF_X86_UNCORE_STARTING",
+ 			  uncore_cpu_starting, uncore_cpu_dying);
+-	first_init = 0;
++
+ 	cpuhp_setup_state(CPUHP_AP_PERF_X86_UNCORE_ONLINE,
+ 			  "AP_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;
+diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c
+index 3d8ff40ecc6f..7249f1500bcb 100644
+--- a/arch/x86/kernel/apic/io_apic.c
++++ b/arch/x86/kernel/apic/io_apic.c
+@@ -2118,6 +2118,7 @@ static inline void __init check_timer(void)
+ 			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)
+@@ -2139,6 +2140,7 @@ static inline void __init check_timer(void)
+ 		 * 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()) {
+diff --git a/arch/x86/kernel/hpet.c b/arch/x86/kernel/hpet.c
+index 274fab99169d..932348fbb6ea 100644
+--- a/arch/x86/kernel/hpet.c
++++ b/arch/x86/kernel/hpet.c
+@@ -352,6 +352,7 @@ static int hpet_resume(struct clock_event_device *evt, int timer)
+ 	} else {
+ 		struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
+ 
++		irq_domain_deactivate_irq(irq_get_irq_data(hdev->irq));
+ 		irq_domain_activate_irq(irq_get_irq_data(hdev->irq));
+ 		disable_irq(hdev->irq);
+ 		irq_set_affinity(hdev->irq, cpumask_of(hdev->cpu));
+diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
+index 487b957e7802..731044efb195 100644
+--- a/arch/x86/kvm/x86.c
++++ b/arch/x86/kvm/x86.c
+@@ -3148,6 +3148,7 @@ static void fill_xsave(u8 *dest, struct kvm_vcpu *vcpu)
+ 	memcpy(dest, xsave, XSAVE_HDR_OFFSET);
+ 
+ 	/* Set XSTATE_BV */
++	xstate_bv &= vcpu->arch.guest_supported_xcr0 | XFEATURE_MASK_FPSSE;
+ 	*(u64 *)(dest + XSAVE_HDR_OFFSET) = xstate_bv;
+ 
+ 	/*
+diff --git a/arch/x86/platform/efi/efi_64.c b/arch/x86/platform/efi/efi_64.c
+index 319148bd4b05..2f25a363068c 100644
+--- a/arch/x86/platform/efi/efi_64.c
++++ b/arch/x86/platform/efi/efi_64.c
+@@ -269,6 +269,22 @@ int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages)
+ 	efi_scratch.use_pgd = true;
+ 
+ 	/*
++	 * Certain firmware versions are way too sentimential and still believe
++	 * they are exclusive and unquestionable owners of the first physical page,
++	 * even though they explicitly mark it as EFI_CONVENTIONAL_MEMORY
++	 * (but then write-access it later during SetVirtualAddressMap()).
++	 *
++	 * Create a 1:1 mapping for this page, to avoid triple faults during early
++	 * boot with such firmware. We are free to hand this page to the BIOS,
++	 * as trim_bios_range() will reserve the first page and isolate it away
++	 * from memory allocators anyway.
++	 */
++	if (kernel_map_pages_in_pgd(pgd, 0x0, 0x0, 1, _PAGE_RW)) {
++		pr_err("Failed to create 1:1 mapping for the first page!\n");
++		return 1;
++	}
++
++	/*
+ 	 * When making calls to the firmware everything needs to be 1:1
+ 	 * mapped and addressable with 32-bit pointers. Map the kernel
+ 	 * text and allocate a new stack because we can't rely on the
+diff --git a/arch/xtensa/kernel/setup.c b/arch/xtensa/kernel/setup.c
+index 88a044af7504..32cdc2c52e98 100644
+--- a/arch/xtensa/kernel/setup.c
++++ b/arch/xtensa/kernel/setup.c
+@@ -540,7 +540,7 @@ subsys_initcall(topology_init);
+ 
+ void cpu_reset(void)
+ {
+-#if XCHAL_HAVE_PTP_MMU
++#if XCHAL_HAVE_PTP_MMU && IS_ENABLED(CONFIG_MMU)
+ 	local_irq_disable();
+ 	/*
+ 	 * We have full MMU: all autoload ways, ways 7, 8 and 9 of DTLB must
+diff --git a/crypto/algapi.c b/crypto/algapi.c
+index df939b54b09f..1fad2a6b3bbb 100644
+--- a/crypto/algapi.c
++++ b/crypto/algapi.c
+@@ -356,6 +356,7 @@ int crypto_register_alg(struct crypto_alg *alg)
+ 	struct crypto_larval *larval;
+ 	int err;
+ 
++	alg->cra_flags &= ~CRYPTO_ALG_DEAD;
+ 	err = crypto_check_alg(alg);
+ 	if (err)
+ 		return err;
+diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
+index 223a770f78f3..33e363dcc63b 100644
+--- a/drivers/ata/libata-core.c
++++ b/drivers/ata/libata-core.c
+@@ -1695,6 +1695,8 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
+ 
+ 		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 */
+@@ -4316,10 +4318,10 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
+ 	{ "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 */
+ 
+diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
+index 823e938c9a78..2f32782cea6d 100644
+--- a/drivers/ata/sata_mv.c
++++ b/drivers/ata/sata_mv.c
+@@ -4132,6 +4132,9 @@ static int mv_platform_probe(struct platform_device *pdev)
+ 	host->iomap = NULL;
+ 	hpriv->base = devm_ioremap(&pdev->dev, res->start,
+ 				   resource_size(res));
++	if (!hpriv->base)
++		return -ENOMEM;
++
+ 	hpriv->base -= SATAHC0_REG_BASE;
+ 
+ 	hpriv->clk = clk_get(&pdev->dev, NULL);
+diff --git a/drivers/base/memory.c b/drivers/base/memory.c
+index e7f86a8887d2..c5cdd190b781 100644
+--- a/drivers/base/memory.c
++++ b/drivers/base/memory.c
+@@ -391,33 +391,33 @@ static ssize_t show_valid_zones(struct device *dev,
+ {
+ 	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);
+diff --git a/drivers/bcma/bcma_private.h b/drivers/bcma/bcma_private.h
+index f642c4264c27..168fa175d65a 100644
+--- a/drivers/bcma/bcma_private.h
++++ b/drivers/bcma/bcma_private.h
+@@ -45,6 +45,9 @@ int bcma_sprom_get(struct bcma_bus *bus);
+ 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);
+diff --git a/drivers/bcma/driver_chipcommon.c b/drivers/bcma/driver_chipcommon.c
+index b4f6520e74f0..62f5bfa5065d 100644
+--- a/drivers/bcma/driver_chipcommon.c
++++ b/drivers/bcma/driver_chipcommon.c
+@@ -15,8 +15,6 @@
+ #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)
+ {
+@@ -186,9 +184,6 @@ void bcma_core_chipcommon_early_init(struct bcma_drv_cc *cc)
+ 	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);
+ 
+@@ -378,9 +373,9 @@ u32 bcma_chipco_gpio_pulldown(struct bcma_drv_cc *cc, u32 mask, u32 value)
+ 	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;
+@@ -422,5 +417,5 @@ static void bcma_chipco_serial_init(struct bcma_drv_cc *cc)
+ 		ports[i].baud_base = baud_base;
+ 		ports[i].reg_shift = 0;
+ 	}
+-#endif /* CONFIG_BCM47XX */
+ }
++#endif /* CONFIG_BCMA_DRIVER_MIPS */
+diff --git a/drivers/bcma/driver_mips.c b/drivers/bcma/driver_mips.c
+index 96f171328200..89af807cf29c 100644
+--- a/drivers/bcma/driver_mips.c
++++ b/drivers/bcma/driver_mips.c
+@@ -278,9 +278,12 @@ static void bcma_core_mips_nvram_init(struct bcma_drv_mips *mcore)
+ 
+ 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;
+diff --git a/drivers/dma/cppi41.c b/drivers/dma/cppi41.c
+index d5ba43a87a68..55c1782e3623 100644
+--- a/drivers/dma/cppi41.c
++++ b/drivers/dma/cppi41.c
+@@ -153,6 +153,8 @@ struct cppi41_dd {
+ 
+ 	/* context for suspend/resume */
+ 	unsigned int dma_tdfdq;
++
++	bool is_suspended;
+ };
+ 
+ #define FIST_COMPLETION_QUEUE	93
+@@ -257,6 +259,10 @@ static struct cppi41_channel *desc_to_chan(struct cppi41_dd *cdd, u32 desc)
+ 	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;
+ }
+ 
+@@ -447,6 +453,15 @@ static void push_desc_queue(struct cppi41_channel *c)
+ 	 */
+ 	__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]);
+@@ -457,20 +472,26 @@ static void push_desc_queue(struct cppi41_channel *c)
+ 	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;
+-	unsigned long flags;
++	struct cppi41_channel *c, *_c;
+ 
+-	spin_lock_irqsave(&cdd->lock, flags);
+-	list_add_tail(&c->node, &cdd->pending);
+-	spin_unlock_irqrestore(&cdd->lock, flags);
++	list_for_each_entry_safe(c, _c, &cdd->pending, node) {
++		push_desc_queue(c);
++		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);
+@@ -482,10 +503,11 @@ static void cppi41_dma_issue_pending(struct dma_chan *chan)
+ 		return;
+ 	}
+ 
+-	if (likely(pm_runtime_active(cdd->ddev.dev)))
+-		push_desc_queue(c);
+-	else
+-		pending_desc(c);
++	spin_lock_irqsave(&cdd->lock, flags);
++	list_add_tail(&c->node, &cdd->pending);
++	if (!cdd->is_suspended)
++		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);
+@@ -705,6 +727,9 @@ static int cppi41_stop_chan(struct dma_chan *chan)
+ 	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;
+ }
+ 
+@@ -1150,8 +1175,12 @@ static int __maybe_unused cppi41_resume(struct device *dev)
+ 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;
+ }
+@@ -1159,14 +1188,11 @@ static int __maybe_unused cppi41_runtime_suspend(struct device *dev)
+ 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) {
+-		push_desc_queue(c);
+-		list_del(&c->node);
+-	}
++	cdd->is_suspended = false;
++	cppi41_run_queue(cdd);
+ 	spin_unlock_irqrestore(&cdd->lock, flags);
+ 
+ 	return 0;
+diff --git a/drivers/firmware/efi/libstub/fdt.c b/drivers/firmware/efi/libstub/fdt.c
+index 921dfa047202..260c4b4b492e 100644
+--- a/drivers/firmware/efi/libstub/fdt.c
++++ b/drivers/firmware/efi/libstub/fdt.c
+@@ -187,6 +187,7 @@ static efi_status_t update_fdt_memmap(void *fdt, struct efi_boot_memmap *map)
+ 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,
+@@ -202,7 +203,7 @@ 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);
+ }
+ 
+ /*
+@@ -300,22 +301,13 @@ efi_status_t allocate_new_fdt_and_exit_boot(efi_system_table_t *sys_table,
+ 
+ 	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,
+diff --git a/drivers/gpu/drm/amd/amdgpu/gmc_v6_0.c b/drivers/gpu/drm/amd/amdgpu/gmc_v6_0.c
+index b13c8aaec078..6df924f72f29 100644
+--- a/drivers/gpu/drm/amd/amdgpu/gmc_v6_0.c
++++ b/drivers/gpu/drm/amd/amdgpu/gmc_v6_0.c
+@@ -227,6 +227,9 @@ static void gmc_v6_0_mc_program(struct amdgpu_device *adev)
+ 	}
+ 	WREG32(HDP_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)) {
+@@ -256,7 +259,6 @@ static void gmc_v6_0_mc_program(struct amdgpu_device *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)
+diff --git a/drivers/gpu/drm/i915/intel_lrc.c b/drivers/gpu/drm/i915/intel_lrc.c
+index 67db1577ee49..4147e51cf893 100644
+--- a/drivers/gpu/drm/i915/intel_lrc.c
++++ b/drivers/gpu/drm/i915/intel_lrc.c
+@@ -2152,30 +2152,42 @@ static int execlists_context_deferred_alloc(struct i915_gem_context *ctx,
+ 
+ void intel_lr_context_resume(struct drm_i915_private *dev_priv)
+ {
+-	struct i915_gem_context *ctx = dev_priv->kernel_context;
+ 	struct intel_engine_cs *engine;
++	struct i915_gem_context *ctx;
++
++	/* Because we emit WA_TAIL_DWORDS there may be a disparity
++	 * between our bookkeeping in ce->ring->head and ce->ring->tail and
++	 * that stored in context. As we only write new commands from
++	 * ce->ring->tail onwards, everything before that is junk. If the GPU
++	 * starts reading from its RING_HEAD from the context, it may try to
++	 * execute that junk and die.
++	 *
++	 * So to avoid that we reset the context images upon resume. For
++	 * simplicity, we just zero everything out.
++	 */
++	list_for_each_entry(ctx, &dev_priv->context_list, link) {
++		for_each_engine(engine, dev_priv) {
++			struct intel_context *ce = &ctx->engine[engine->id];
++			u32 *reg;
+ 
+-	for_each_engine(engine, dev_priv) {
+-		struct intel_context *ce = &ctx->engine[engine->id];
+-		void *vaddr;
+-		uint32_t *reg_state;
+-
+-		if (!ce->state)
+-			continue;
+-
+-		vaddr = i915_gem_object_pin_map(ce->state->obj, I915_MAP_WB);
+-		if (WARN_ON(IS_ERR(vaddr)))
+-			continue;
++			if (!ce->state)
++				continue;
+ 
+-		reg_state = vaddr + LRC_STATE_PN * PAGE_SIZE;
++			reg = i915_gem_object_pin_map(ce->state->obj,
++						      I915_MAP_WB);
++			if (WARN_ON(IS_ERR(reg)))
++				continue;
+ 
+-		reg_state[CTX_RING_HEAD+1] = 0;
+-		reg_state[CTX_RING_TAIL+1] = 0;
++			reg += LRC_STATE_PN * PAGE_SIZE / sizeof(*reg);
++			reg[CTX_RING_HEAD+1] = 0;
++			reg[CTX_RING_TAIL+1] = 0;
+ 
+-		ce->state->obj->dirty = true;
+-		i915_gem_object_unpin_map(ce->state->obj);
++			ce->state->obj->dirty = true;
++			i915_gem_object_unpin_map(ce->state->obj);
+ 
+-		ce->ring->head = 0;
+-		ce->ring->tail = 0;
++			ce->ring->head = ce->ring->tail = 0;
++			ce->ring->last_retired_head = -1;
++			intel_ring_update_space(ce->ring);
++		}
+ 	}
+ }
+diff --git a/drivers/gpu/drm/nouveau/dispnv04/hw.c b/drivers/gpu/drm/nouveau/dispnv04/hw.c
+index 74856a8b8f35..e64f52464ecf 100644
+--- a/drivers/gpu/drm/nouveau/dispnv04/hw.c
++++ b/drivers/gpu/drm/nouveau/dispnv04/hw.c
+@@ -222,6 +222,7 @@ nouveau_hw_get_clock(struct drm_device *dev, enum nvbios_pll_type plltype)
+ 		uint32_t mpllP;
+ 
+ 		pci_read_config_dword(pci_get_bus_and_slot(0, 3), 0x6c, &mpllP);
++		mpllP = (mpllP >> 8) & 0xf;
+ 		if (!mpllP)
+ 			mpllP = 4;
+ 
+@@ -232,7 +233,7 @@ nouveau_hw_get_clock(struct drm_device *dev, enum nvbios_pll_type plltype)
+ 		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);
+diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/disp/hdagt215.c b/drivers/gpu/drm/nouveau/nvkm/engine/disp/hdagt215.c
+index 6f0436df0219..f8f2f16c22a2 100644
+--- a/drivers/gpu/drm/nouveau/nvkm/engine/disp/hdagt215.c
++++ b/drivers/gpu/drm/nouveau/nvkm/engine/disp/hdagt215.c
+@@ -59,7 +59,7 @@ gt215_hda_eld(NV50_DISP_MTHD_V1)
+ 			);
+ 		}
+ 		for (i = 0; i < size; i++)
+-			nvkm_wr32(device, 0x61c440 + soff, (i << 8) | args->v0.data[0]);
++			nvkm_wr32(device, 0x61c440 + soff, (i << 8) | args->v0.data[i]);
+ 		for (; i < 0x60; i++)
+ 			nvkm_wr32(device, 0x61c440 + soff, (i << 8));
+ 		nvkm_mask(device, 0x61c448 + soff, 0x80000003, 0x80000003);
+diff --git a/drivers/hid/hid-cp2112.c b/drivers/hid/hid-cp2112.c
+index 60d30203a5fa..e06c1344c913 100644
+--- a/drivers/hid/hid-cp2112.c
++++ b/drivers/hid/hid-cp2112.c
+@@ -167,7 +167,7 @@ struct cp2112_device {
+ 	atomic_t xfer_avail;
+ 	struct gpio_chip gc;
+ 	u8 *in_out_buffer;
+-	spinlock_t lock;
++	struct mutex lock;
+ };
+ 
+ static int gpio_push_pull = 0xFF;
+@@ -179,10 +179,9 @@ static int cp2112_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+ 	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,
+@@ -206,8 +205,8 @@ static int cp2112_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+ 	ret = 0;
+ 
+ exit:
+-	spin_unlock_irqrestore(&dev->lock, flags);
+-	return ret <= 0 ? ret : -EIO;
++	mutex_unlock(&dev->lock);
++	return ret < 0 ? ret : -EIO;
+ }
+ 
+ static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+@@ -215,10 +214,9 @@ 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;
+@@ -230,7 +228,7 @@ static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+ 	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(struct gpio_chip *chip, unsigned offset)
+@@ -238,10 +236,9 @@ static int cp2112_gpio_get(struct gpio_chip *chip, unsigned offset)
+ 	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,
+@@ -255,7 +252,7 @@ static int cp2112_gpio_get(struct gpio_chip *chip, unsigned offset)
+ 	ret = (buf[1] >> offset) & 1;
+ 
+ exit:
+-	spin_unlock_irqrestore(&dev->lock, flags);
++	mutex_unlock(&dev->lock);
+ 
+ 	return ret;
+ }
+@@ -266,10 +263,9 @@ static int cp2112_gpio_direction_output(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_CONFIG, buf,
+ 				 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
+@@ -290,7 +286,7 @@ static int cp2112_gpio_direction_output(struct gpio_chip *chip,
+ 		goto fail;
+ 	}
+ 
+-	spin_unlock_irqrestore(&dev->lock, flags);
++	mutex_unlock(&dev->lock);
+ 
+ 	/*
+ 	 * Set gpio value when output direction is already set,
+@@ -301,7 +297,7 @@ static int cp2112_gpio_direction_output(struct gpio_chip *chip,
+ 	return 0;
+ 
+ fail:
+-	spin_unlock_irqrestore(&dev->lock, flags);
++	mutex_unlock(&dev->lock);
+ 	return ret < 0 ? ret : -EIO;
+ }
+ 
+@@ -1057,7 +1053,7 @@ static int cp2112_probe(struct hid_device *hdev, const struct hid_device_id *id)
+ 	if (!dev->in_out_buffer)
+ 		return -ENOMEM;
+ 
+-	spin_lock_init(&dev->lock);
++	mutex_init(&dev->lock);
+ 
+ 	ret = hid_parse(hdev);
+ 	if (ret) {
+diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
+index 575aa65436d1..9845189fae92 100644
+--- a/drivers/hid/hid-ids.h
++++ b/drivers/hid/hid-ids.h
+@@ -76,6 +76,9 @@
+ #define USB_VENDOR_ID_ALPS_JP		0x044E
+ #define HID_DEVICE_ID_ALPS_U1_DUAL	0x120B
+ 
++#define USB_VENDOR_ID_AMI		0x046b
++#define USB_DEVICE_ID_AMI_VIRT_KEYBOARD_AND_MOUSE	0xff10
++
+ #define USB_VENDOR_ID_ANTON		0x1130
+ #define USB_DEVICE_ID_ANTON_TOUCH_PAD	0x3101
+ 
+diff --git a/drivers/hid/hid-lg.c b/drivers/hid/hid-lg.c
+index c5c5fbe9d605..52026dc94d5c 100644
+--- a/drivers/hid/hid-lg.c
++++ b/drivers/hid/hid-lg.c
+@@ -872,7 +872,7 @@ static const struct hid_device_id lg_devices[] = {
+ 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG),
+ 		.driver_data = LG_NOGET | LG_FF4 },
+ 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2),
+-		.driver_data = LG_FF2 },
++		.driver_data = LG_NOGET | LG_FF2 },
+ 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940),
+ 		.driver_data = LG_FF3 },
+ 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR),
+diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
+index e6cfd323babc..cde060fefa91 100644
+--- a/drivers/hid/usbhid/hid-quirks.c
++++ b/drivers/hid/usbhid/hid-quirks.c
+@@ -57,6 +57,7 @@ static const struct hid_blacklist {
+ 	{ USB_VENDOR_ID_AIREN, USB_DEVICE_ID_AIREN_SLIMPLUS, HID_QUIRK_NOGET },
+ 	{ USB_VENDOR_ID_AKAI, USB_DEVICE_ID_AKAI_MPKMINI2, HID_QUIRK_NO_INIT_REPORTS },
+ 	{ USB_VENDOR_ID_AKAI_09E8, USB_DEVICE_ID_AKAI_09E8_MIDIMIX, HID_QUIRK_NO_INIT_REPORTS },
++	{ USB_VENDOR_ID_AMI, USB_DEVICE_ID_AMI_VIRT_KEYBOARD_AND_MOUSE, HID_QUIRK_ALWAYS_POLL },
+ 	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM, HID_QUIRK_NOGET },
+ 	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_CS124U, HID_QUIRK_NOGET },
+ 	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET },
+diff --git a/drivers/hid/wacom_wac.c b/drivers/hid/wacom_wac.c
+index 1cb79925730d..623be90704ab 100644
+--- a/drivers/hid/wacom_wac.c
++++ b/drivers/hid/wacom_wac.c
+@@ -164,19 +164,21 @@ static int wacom_pl_irq(struct wacom_wac *wacom)
+ 		wacom->id[0] = STYLUS_DEVICE_ID;
+ 	}
+ 
+-	pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
+-	if (features->pressure_max > 255)
+-		pressure = (pressure << 1) | ((data[4] >> 6) & 1);
+-	pressure += (features->pressure_max + 1) / 2;
+-
+-	input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
+-	input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
+-	input_report_abs(input, ABS_PRESSURE, pressure);
+-
+-	input_report_key(input, BTN_TOUCH, data[4] & 0x08);
+-	input_report_key(input, BTN_STYLUS, data[4] & 0x10);
+-	/* Only allow the stylus2 button to be reported for the pen tool. */
+-	input_report_key(input, BTN_STYLUS2, (wacom->tool[0] == BTN_TOOL_PEN) && (data[4] & 0x20));
++	if (prox) {
++		pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
++		if (features->pressure_max > 255)
++			pressure = (pressure << 1) | ((data[4] >> 6) & 1);
++		pressure += (features->pressure_max + 1) / 2;
++
++		input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
++		input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
++		input_report_abs(input, ABS_PRESSURE, pressure);
++
++		input_report_key(input, BTN_TOUCH, data[4] & 0x08);
++		input_report_key(input, BTN_STYLUS, data[4] & 0x10);
++		/* Only allow the stylus2 button to be reported for the pen tool. */
++		input_report_key(input, BTN_STYLUS2, (wacom->tool[0] == BTN_TOOL_PEN) && (data[4] & 0x20));
++	}
+ 
+ 	if (!prox)
+ 		wacom->id[0] = 0;
+diff --git a/drivers/iio/adc/palmas_gpadc.c b/drivers/iio/adc/palmas_gpadc.c
+index 2bbf0c521beb..7d61b566e148 100644
+--- a/drivers/iio/adc/palmas_gpadc.c
++++ b/drivers/iio/adc/palmas_gpadc.c
+@@ -775,7 +775,7 @@ static int palmas_adc_wakeup_reset(struct palmas_gpadc *adc)
+ 
+ static int palmas_gpadc_suspend(struct device *dev)
+ {
+-	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
++	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ 	struct palmas_gpadc *adc = iio_priv(indio_dev);
+ 	int wakeup = adc->wakeup1_enable || adc->wakeup2_enable;
+ 	int ret;
+@@ -798,7 +798,7 @@ static int palmas_gpadc_suspend(struct device *dev)
+ 
+ static int palmas_gpadc_resume(struct device *dev)
+ {
+-	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
++	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ 	struct palmas_gpadc *adc = iio_priv(indio_dev);
+ 	int wakeup = adc->wakeup1_enable || adc->wakeup2_enable;
+ 	int ret;
+diff --git a/drivers/iio/health/afe4403.c b/drivers/iio/health/afe4403.c
+index 9a081465c42f..6bb23a49e81e 100644
+--- a/drivers/iio/health/afe4403.c
++++ b/drivers/iio/health/afe4403.c
+@@ -422,7 +422,7 @@ MODULE_DEVICE_TABLE(of, afe4403_of_match);
+ 
+ static int __maybe_unused afe4403_suspend(struct device *dev)
+ {
+-	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
++	struct iio_dev *indio_dev = spi_get_drvdata(to_spi_device(dev));
+ 	struct afe4403_data *afe = iio_priv(indio_dev);
+ 	int ret;
+ 
+@@ -443,7 +443,7 @@ static int __maybe_unused afe4403_suspend(struct device *dev)
+ 
+ static int __maybe_unused afe4403_resume(struct device *dev)
+ {
+-	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
++	struct iio_dev *indio_dev = spi_get_drvdata(to_spi_device(dev));
+ 	struct afe4403_data *afe = iio_priv(indio_dev);
+ 	int ret;
+ 
+diff --git a/drivers/iio/health/afe4404.c b/drivers/iio/health/afe4404.c
+index 45266404f7e3..964f5231a831 100644
+--- a/drivers/iio/health/afe4404.c
++++ b/drivers/iio/health/afe4404.c
+@@ -428,7 +428,7 @@ MODULE_DEVICE_TABLE(of, afe4404_of_match);
+ 
+ static int __maybe_unused afe4404_suspend(struct device *dev)
+ {
+-	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
++	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+ 	struct afe4404_data *afe = iio_priv(indio_dev);
+ 	int ret;
+ 
+@@ -449,7 +449,7 @@ static int __maybe_unused afe4404_suspend(struct device *dev)
+ 
+ static int __maybe_unused afe4404_resume(struct device *dev)
+ {
+-	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
++	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+ 	struct afe4404_data *afe = iio_priv(indio_dev);
+ 	int ret;
+ 
+diff --git a/drivers/iio/health/max30100.c b/drivers/iio/health/max30100.c
+index 90ab8a2d2846..183c14329d6e 100644
+--- a/drivers/iio/health/max30100.c
++++ b/drivers/iio/health/max30100.c
+@@ -238,7 +238,7 @@ static irqreturn_t max30100_interrupt_handler(int irq, void *private)
+ 
+ 	mutex_lock(&data->lock);
+ 
+-	while (cnt || (cnt = max30100_fifo_count(data) > 0)) {
++	while (cnt || (cnt = max30100_fifo_count(data)) > 0) {
+ 		ret = max30100_read_measurement(data);
+ 		if (ret)
+ 			break;
+diff --git a/drivers/iio/humidity/dht11.c b/drivers/iio/humidity/dht11.c
+index 9c47bc98f3ac..2a22ad920333 100644
+--- a/drivers/iio/humidity/dht11.c
++++ b/drivers/iio/humidity/dht11.c
+@@ -71,7 +71,8 @@
+  * 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 */
+@@ -228,7 +229,8 @@ static int dht11_read_raw(struct iio_dev *iio_dev,
+ 		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;
+diff --git a/drivers/infiniband/hw/cxgb4/qp.c b/drivers/infiniband/hw/cxgb4/qp.c
+index bb0fde6e2047..cc2243f6cc7f 100644
+--- a/drivers/infiniband/hw/cxgb4/qp.c
++++ b/drivers/infiniband/hw/cxgb4/qp.c
+@@ -321,7 +321,8 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
+ 		FW_RI_RES_WR_DCAEN_V(0) |
+ 		FW_RI_RES_WR_DCACPU_V(0) |
+ 		FW_RI_RES_WR_FBMIN_V(2) |
+-		FW_RI_RES_WR_FBMAX_V(2) |
++		(t4_sq_onchip(&wq->sq) ? FW_RI_RES_WR_FBMAX_V(2) :
++					 FW_RI_RES_WR_FBMAX_V(3)) |
+ 		FW_RI_RES_WR_CIDXFTHRESHO_V(0) |
+ 		FW_RI_RES_WR_CIDXFTHRESH_V(0) |
+ 		FW_RI_RES_WR_EQSIZE_V(eqsize));
+@@ -345,7 +346,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
+ 		FW_RI_RES_WR_DCAEN_V(0) |
+ 		FW_RI_RES_WR_DCACPU_V(0) |
+ 		FW_RI_RES_WR_FBMIN_V(2) |
+-		FW_RI_RES_WR_FBMAX_V(2) |
++		FW_RI_RES_WR_FBMAX_V(3) |
+ 		FW_RI_RES_WR_CIDXFTHRESHO_V(0) |
+ 		FW_RI_RES_WR_CIDXFTHRESH_V(0) |
+ 		FW_RI_RES_WR_EQSIZE_V(eqsize));
+diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
+index e1e274a0a34f..ba637ff8aa7e 100644
+--- a/drivers/mmc/host/sdhci.c
++++ b/drivers/mmc/host/sdhci.c
+@@ -2719,7 +2719,8 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id)
+ 		if (intmask & SDHCI_INT_RETUNE)
+ 			mmc_retune_needed(host->mmc);
+ 
+-		if (intmask & SDHCI_INT_CARD_INT) {
++		if ((intmask & SDHCI_INT_CARD_INT) &&
++		    (host->ier & SDHCI_INT_CARD_INT)) {
+ 			sdhci_enable_sdio_irq_nolock(host, false);
+ 			host->thread_isr |= SDHCI_INT_CARD_INT;
+ 			result = IRQ_WAKE_THREAD;
+diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-8000.c b/drivers/net/wireless/intel/iwlwifi/iwl-8000.c
+index d02ca1491d16..8d3e53fac1da 100644
+--- a/drivers/net/wireless/intel/iwlwifi/iwl-8000.c
++++ b/drivers/net/wireless/intel/iwlwifi/iwl-8000.c
+@@ -91,7 +91,7 @@
+ 
+ #define IWL8000_FW_PRE "iwlwifi-8000C-"
+ #define IWL8000_MODULE_FIRMWARE(api) \
+-	IWL8000_FW_PRE "-" __stringify(api) ".ucode"
++	IWL8000_FW_PRE __stringify(api) ".ucode"
+ 
+ #define IWL8265_FW_PRE "iwlwifi-8265-"
+ #define IWL8265_MODULE_FIRMWARE(api) \
+diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
+index fc771885e383..52de3c6d760c 100644
+--- a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
++++ b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c
+@@ -1144,9 +1144,10 @@ static void iwl_mvm_realloc_queues_after_restart(struct iwl_mvm *mvm,
+ 		.frame_limit = IWL_FRAME_LIMIT,
+ 	};
+ 
+-	/* Make sure reserved queue is still marked as such (or allocated) */
+-	mvm->queue_info[mvm_sta->reserved_queue].status =
+-		IWL_MVM_QUEUE_RESERVED;
++	/* Make sure reserved queue is still marked as such (if allocated) */
++	if (mvm_sta->reserved_queue != IEEE80211_INVAL_HW_QUEUE)
++		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];
+diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c
+index 0ec649d961d7..b0916b126923 100644
+--- a/drivers/pci/pcie/aspm.c
++++ b/drivers/pci/pcie/aspm.c
+@@ -518,25 +518,32 @@ static struct pcie_link_state *alloc_pcie_link_state(struct pci_dev *pdev)
+ 	link = kzalloc(sizeof(*link), GFP_KERNEL);
+ 	if (!link)
+ 		return NULL;
++
+ 	INIT_LIST_HEAD(&link->sibling);
+ 	INIT_LIST_HEAD(&link->children);
+ 	INIT_LIST_HEAD(&link->link);
+ 	link->pdev = pdev;
+-	if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT) {
++
++	/*
++	 * Root Ports and PCI/PCI-X to PCIe Bridges are roots of PCIe
++	 * hierarchies.
++	 */
++	if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT ||
++	    pci_pcie_type(pdev) == PCI_EXP_TYPE_PCIE_BRIDGE) {
++		link->root = link;
++	} else {
+ 		struct pcie_link_state *parent;
++
+ 		parent = pdev->bus->parent->self->link_state;
+ 		if (!parent) {
+ 			kfree(link);
+ 			return NULL;
+ 		}
++
+ 		link->parent = parent;
++		link->root = link->parent->root;
+ 		list_add(&link->link, &parent->children);
+ 	}
+-	/* Setup a pointer to the root port link */
+-	if (!link->parent)
+-		link->root = link;
+-	else
+-		link->root = link->parent->root;
+ 
+ 	list_add(&link->sibling, &link_list);
+ 	pdev->link_state = link;
+diff --git a/drivers/pinctrl/intel/pinctrl-baytrail.c b/drivers/pinctrl/intel/pinctrl-baytrail.c
+index 079015385fd8..583ae3f38fc0 100644
+--- a/drivers/pinctrl/intel/pinctrl-baytrail.c
++++ b/drivers/pinctrl/intel/pinctrl-baytrail.c
+@@ -731,16 +731,23 @@ static void __iomem *byt_gpio_reg(struct byt_gpio *vg, unsigned int offset,
+ 				  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;
+ }
+@@ -1612,7 +1619,9 @@ static void byt_gpio_irq_handler(struct irq_desc *desc)
+ 			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);
+diff --git a/drivers/pinctrl/intel/pinctrl-merrifield.c b/drivers/pinctrl/intel/pinctrl-merrifield.c
+index 7826c7f0cb7c..9931be6af0ca 100644
+--- a/drivers/pinctrl/intel/pinctrl-merrifield.c
++++ b/drivers/pinctrl/intel/pinctrl-merrifield.c
+@@ -794,6 +794,9 @@ static int mrfld_config_set(struct pinctrl_dev *pctldev, unsigned int pin,
+ 	unsigned int i;
+ 	int ret;
+ 
++	if (!mrfld_buf_available(mp, pin))
++		return -ENOTSUPP;
++
+ 	for (i = 0; i < nconfigs; i++) {
+ 		switch (pinconf_to_config_param(configs[i])) {
+ 		case PIN_CONFIG_BIAS_DISABLE:
+diff --git a/drivers/regulator/axp20x-regulator.c b/drivers/regulator/axp20x-regulator.c
+index e6a512ebeae2..a3ade9e4ef47 100644
+--- a/drivers/regulator/axp20x-regulator.c
++++ b/drivers/regulator/axp20x-regulator.c
+@@ -272,7 +272,7 @@ static const struct regulator_desc axp806_regulators[] = {
+ 			64, AXP806_DCDCD_V_CTRL, 0x3f, AXP806_PWR_OUT_CTRL1,
+ 			BIT(3)),
+ 	AXP_DESC(AXP806, DCDCE, "dcdce", "vine", 1100, 3400, 100,
+-		 AXP806_DCDCB_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(4)),
++		 AXP806_DCDCE_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(4)),
+ 	AXP_DESC(AXP806, ALDO1, "aldo1", "aldoin", 700, 3300, 100,
+ 		 AXP806_ALDO1_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(5)),
+ 	AXP_DESC(AXP806, ALDO2, "aldo2", "aldoin", 700, 3400, 100,
+diff --git a/drivers/staging/greybus/timesync_platform.c b/drivers/staging/greybus/timesync_platform.c
+index 113f3d6c4b3a..27f75b17679b 100644
+--- a/drivers/staging/greybus/timesync_platform.c
++++ b/drivers/staging/greybus/timesync_platform.c
+@@ -45,12 +45,18 @@ u32 gb_timesync_platform_get_clock_rate(void)
+ 
+ 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);
+ }
+ 
+diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
+index d2e50a27140c..24f9f98968a5 100644
+--- a/drivers/usb/core/quirks.c
++++ b/drivers/usb/core/quirks.c
+@@ -37,6 +37,10 @@ static const struct usb_device_id usb_quirk_list[] = {
+ 	/* 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 },
+diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c
+index 17989b72cdae..8d412d8b1f29 100644
+--- a/drivers/usb/gadget/function/f_fs.c
++++ b/drivers/usb/gadget/function/f_fs.c
+@@ -2269,6 +2269,8 @@ static int __ffs_data_do_os_desc(enum ffs_os_desc_type type,
+ 		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) {
+@@ -2277,6 +2279,11 @@ static int __ffs_data_do_os_desc(enum ffs_os_desc_type type,
+ 			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",
+@@ -2363,6 +2370,9 @@ static int __ffs_data_got_descs(struct ffs_data *ffs,
+ 		}
+ 	}
+ 	if (flags & (1 << i)) {
++		if (len < 4) {
++			goto error;
++		}
+ 		os_descs_count = get_unaligned_le32(data);
+ 		data += 4;
+ 		len -= 4;
+@@ -2435,7 +2445,8 @@ static int __ffs_data_got_strings(struct ffs_data *ffs,
+ 
+ 	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);
+diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
+index c3e172e15ec3..338575fb2d27 100644
+--- a/drivers/usb/musb/musb_core.c
++++ b/drivers/usb/musb/musb_core.c
+@@ -578,11 +578,11 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
+ 						| 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;
+@@ -2691,11 +2691,6 @@ static int musb_resume(struct device *dev)
+ 	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
+@@ -2747,12 +2742,6 @@ static int musb_runtime_resume(struct device *dev)
+ 
+ 	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)
+diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
+index 47331dbdde29..854fbf7b6b23 100644
+--- a/drivers/usb/musb/musb_core.h
++++ b/drivers/usb/musb/musb_core.h
+@@ -410,7 +410,6 @@ struct musb {
+ 
+ 	/* is_suspended means USB B_PERIPHERAL suspend */
+ 	unsigned		is_suspended:1;
+-	unsigned		need_finish_resume :1;
+ 
+ 	/* may_wakeup means remote wakeup is enabled */
+ 	unsigned		may_wakeup:1;
+diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
+index 7ce31a4c7e7f..42cc72e54c05 100644
+--- a/drivers/usb/serial/option.c
++++ b/drivers/usb/serial/option.c
+@@ -2007,6 +2007,7 @@ static const struct usb_device_id option_ids[] = {
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_WMD200, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_6802, 0xff, 0xff, 0xff) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_WMD300, 0xff, 0xff, 0xff) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(0x03f0, 0x421d, 0xff, 0xff, 0xff) }, /* HP lt2523 (Novatel E371) */
+ 	{ } /* Terminating entry */
+ };
+ MODULE_DEVICE_TABLE(usb, option_ids);
+diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
+index 46fca6b75846..1db4b61bdf7b 100644
+--- a/drivers/usb/serial/pl2303.c
++++ b/drivers/usb/serial/pl2303.c
+@@ -49,6 +49,7 @@ static const struct usb_device_id id_table[] = {
+ 	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
+ 	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
+ 	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
++	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
+ 	{ USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
+ 	{ USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
+ 	{ USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
+diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
+index e3b7af8adfb7..09d9be88209e 100644
+--- a/drivers/usb/serial/pl2303.h
++++ b/drivers/usb/serial/pl2303.h
+@@ -27,6 +27,7 @@
+ #define ATEN_VENDOR_ID		0x0557
+ #define ATEN_VENDOR_ID2		0x0547
+ #define ATEN_PRODUCT_ID		0x2008
++#define ATEN_PRODUCT_ID2	0x2118
+ 
+ #define IODATA_VENDOR_ID	0x04bb
+ #define IODATA_PRODUCT_ID	0x0a03
+diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c
+index 1bc6089b9008..696458db7e3c 100644
+--- a/drivers/usb/serial/qcserial.c
++++ b/drivers/usb/serial/qcserial.c
+@@ -124,6 +124,7 @@ static const struct usb_device_id id_table[] = {
+ 	{USB_DEVICE(0x1410, 0xa021)},	/* Novatel Gobi 3000 Composite */
+ 	{USB_DEVICE(0x413c, 0x8193)},	/* Dell Gobi 3000 QDL */
+ 	{USB_DEVICE(0x413c, 0x8194)},	/* Dell Gobi 3000 Composite */
++	{USB_DEVICE(0x413c, 0x81a6)},	/* Dell DW5570 QDL (MC8805) */
+ 	{USB_DEVICE(0x1199, 0x68a4)},	/* Sierra Wireless QDL */
+ 	{USB_DEVICE(0x1199, 0x68a5)},	/* Sierra Wireless Modem */
+ 	{USB_DEVICE(0x1199, 0x68a8)},	/* Sierra Wireless QDL */
+diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
+index c6f2d89c0e97..64613fbf5cf8 100644
+--- a/drivers/vhost/vhost.c
++++ b/drivers/vhost/vhost.c
+@@ -130,14 +130,14 @@ static long vhost_get_vring_endian(struct vhost_virtqueue *vq, u32 idx,
+ 
+ static void vhost_init_is_le(struct vhost_virtqueue *vq)
+ {
+-	if (vhost_has_feature(vq, VIRTIO_F_VERSION_1))
+-		vq->is_le = true;
++	vq->is_le = vhost_has_feature(vq, VIRTIO_F_VERSION_1)
++		|| 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 {
+@@ -1713,10 +1713,8 @@ int vhost_vq_init_access(struct vhost_virtqueue *vq)
+ 	int r;
+ 	bool is_le = vq->is_le;
+ 
+-	if (!vq->private_data) {
+-		vhost_reset_is_le(vq);
++	if (!vq->private_data)
+ 		return 0;
+-	}
+ 
+ 	vhost_init_is_le(vq);
+ 
+diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
+index f1360487a594..489bfc61cf30 100644
+--- a/drivers/virtio/virtio_ring.c
++++ b/drivers/virtio/virtio_ring.c
+@@ -159,13 +159,6 @@ static bool vring_use_dma_api(struct virtio_device *vdev)
+ 	if (xen_domain())
+ 		return true;
+ 
+-	/*
+-	 * On ARM-based machines, the DMA ops will do the right thing,
+-	 * so always use them with legacy devices.
+-	 */
+-	if (IS_ENABLED(CONFIG_ARM) || IS_ENABLED(CONFIG_ARM64))
+-		return !virtio_has_feature(vdev, VIRTIO_F_VERSION_1);
+-
+ 	return false;
+ }
+ 
+diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
+index 8f6a2a5863b9..a27fc8791551 100644
+--- a/fs/cifs/readdir.c
++++ b/fs/cifs/readdir.c
+@@ -285,6 +285,7 @@ initiate_cifs_search(const unsigned int xid, struct file *file)
+ 			rc = -ENOMEM;
+ 			goto error_exit;
+ 		}
++		spin_lock_init(&cifsFile->file_info_lock);
+ 		file->private_data = cifsFile;
+ 		cifsFile->tlink = cifs_get_tlink(tlink);
+ 		tcon = tlink_tcon(tlink);
+diff --git a/fs/dax.c b/fs/dax.c
+index 014defd2e744..bf6218da7928 100644
+--- a/fs/dax.c
++++ b/fs/dax.c
+@@ -1270,6 +1270,11 @@ iomap_dax_actor(struct inode *inode, loff_t pos, loff_t length, void *data,
+ 		struct blk_dax_ctl dax = { 0 };
+ 		ssize_t map_len;
+ 
++		if (fatal_signal_pending(current)) {
++			ret = -EINTR;
++			break;
++		}
++
+ 		dax.sector = iomap->blkno +
+ 			(((pos & PAGE_MASK) - iomap->offset) >> 9);
+ 		dax.size = (length + offset + PAGE_SIZE - 1) & PAGE_MASK;
+diff --git a/fs/ext4/super.c b/fs/ext4/super.c
+index 478630af0d19..bbc316db9495 100644
+--- a/fs/ext4/super.c
++++ b/fs/ext4/super.c
+@@ -3827,6 +3827,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
+ 			(EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb)));
+ 	db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
+ 		   EXT4_DESC_PER_BLOCK(sb);
++	if (ext4_has_feature_meta_bg(sb)) {
++		if (le32_to_cpu(es->s_first_meta_bg) >= db_count) {
++			ext4_msg(sb, KERN_WARNING,
++				 "first meta block group too large: %u "
++				 "(group descriptor block count %u)",
++				 le32_to_cpu(es->s_first_meta_bg), db_count);
++			goto failed_mount;
++		}
++	}
+ 	sbi->s_group_desc = ext4_kvmalloc(db_count *
+ 					  sizeof(struct buffer_head *),
+ 					  GFP_KERNEL);
+diff --git a/fs/iomap.c b/fs/iomap.c
+index a8ee8c33ca78..814ae8f9587d 100644
+--- a/fs/iomap.c
++++ b/fs/iomap.c
+@@ -113,6 +113,9 @@ iomap_write_begin(struct inode *inode, loff_t pos, unsigned len, unsigned flags,
+ 
+ 	BUG_ON(pos + len > iomap->offset + iomap->length);
+ 
++	if (fatal_signal_pending(current))
++		return -EINTR;
++
+ 	page = grab_cache_page_write_begin(inode->i_mapping, index, flags);
+ 	if (!page)
+ 		return -ENOMEM;
+diff --git a/fs/nfsd/nfs4layouts.c b/fs/nfsd/nfs4layouts.c
+index 42aace4fc4c8..64813697f4c4 100644
+--- a/fs/nfsd/nfs4layouts.c
++++ b/fs/nfsd/nfs4layouts.c
+@@ -223,10 +223,11 @@ nfsd4_alloc_layout_stateid(struct nfsd4_compound_state *cstate,
+ 	struct nfs4_layout_stateid *ls;
+ 	struct nfs4_stid *stp;
+ 
+-	stp = nfs4_alloc_stid(cstate->clp, nfs4_layout_stateid_cache);
++	stp = nfs4_alloc_stid(cstate->clp, nfs4_layout_stateid_cache,
++					nfsd4_free_layout_stateid);
+ 	if (!stp)
+ 		return NULL;
+-	stp->sc_free = nfsd4_free_layout_stateid;
++
+ 	get_nfs4_file(fp);
+ 	stp->sc_file = fp;
+ 
+diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
+index 4b4beaaa4eaa..a0dee8ae9f97 100644
+--- a/fs/nfsd/nfs4state.c
++++ b/fs/nfsd/nfs4state.c
+@@ -633,8 +633,8 @@ find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new)
+ 	return co;
+ }
+ 
+-struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl,
+-					 struct kmem_cache *slab)
++struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab,
++				  void (*sc_free)(struct nfs4_stid *))
+ {
+ 	struct nfs4_stid *stid;
+ 	int new_id;
+@@ -650,6 +650,8 @@ struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl,
+ 	idr_preload_end();
+ 	if (new_id < 0)
+ 		goto out_free;
++
++	stid->sc_free = sc_free;
+ 	stid->sc_client = cl;
+ 	stid->sc_stateid.si_opaque.so_id = new_id;
+ 	stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
+@@ -675,15 +677,12 @@ struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl,
+ static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp)
+ {
+ 	struct nfs4_stid *stid;
+-	struct nfs4_ol_stateid *stp;
+ 
+-	stid = nfs4_alloc_stid(clp, stateid_slab);
++	stid = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_ol_stateid);
+ 	if (!stid)
+ 		return NULL;
+ 
+-	stp = openlockstateid(stid);
+-	stp->st_stid.sc_free = nfs4_free_ol_stateid;
+-	return stp;
++	return openlockstateid(stid);
+ }
+ 
+ static void nfs4_free_deleg(struct nfs4_stid *stid)
+@@ -781,11 +780,10 @@ alloc_init_deleg(struct nfs4_client *clp, struct svc_fh *current_fh,
+ 		goto out_dec;
+ 	if (delegation_blocked(&current_fh->fh_handle))
+ 		goto out_dec;
+-	dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
++	dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab, nfs4_free_deleg));
+ 	if (dp == NULL)
+ 		goto out_dec;
+ 
+-	dp->dl_stid.sc_free = nfs4_free_deleg;
+ 	/*
+ 	 * delegation seqid's are never incremented.  The 4.1 special
+ 	 * meaning of seqid 0 isn't meaningful, really, but let's avoid
+@@ -5580,7 +5578,6 @@ init_lock_stateid(struct nfs4_ol_stateid *stp, struct nfs4_lockowner *lo,
+ 	stp->st_stateowner = nfs4_get_stateowner(&lo->lo_owner);
+ 	get_nfs4_file(fp);
+ 	stp->st_stid.sc_file = fp;
+-	stp->st_stid.sc_free = nfs4_free_lock_stateid;
+ 	stp->st_access_bmap = 0;
+ 	stp->st_deny_bmap = open_stp->st_deny_bmap;
+ 	stp->st_openstp = open_stp;
+@@ -5623,7 +5620,7 @@ find_or_create_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fi,
+ 	lst = find_lock_stateid(lo, fi);
+ 	if (lst == NULL) {
+ 		spin_unlock(&clp->cl_lock);
+-		ns = nfs4_alloc_stid(clp, stateid_slab);
++		ns = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_lock_stateid);
+ 		if (ns == NULL)
+ 			return NULL;
+ 
+diff --git a/fs/nfsd/state.h b/fs/nfsd/state.h
+index c9399366f9df..4516e8b7d776 100644
+--- a/fs/nfsd/state.h
++++ b/fs/nfsd/state.h
+@@ -603,8 +603,8 @@ extern __be32 nfs4_preprocess_stateid_op(struct svc_rqst *rqstp,
+ __be32 nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate,
+ 		     stateid_t *stateid, unsigned char typemask,
+ 		     struct nfs4_stid **s, struct nfsd_net *nn);
+-struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl,
+-		struct kmem_cache *slab);
++struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab,
++				  void (*sc_free)(struct nfs4_stid *));
+ void nfs4_unhash_stid(struct nfs4_stid *s);
+ void nfs4_put_stid(struct nfs4_stid *s);
+ void nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid);
+diff --git a/include/linux/irq.h b/include/linux/irq.h
+index e79875574b39..39e3254e5769 100644
+--- a/include/linux/irq.h
++++ b/include/linux/irq.h
+@@ -184,6 +184,7 @@ struct irq_data {
+  *
+  * 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
+@@ -202,6 +203,7 @@ struct irq_data {
+ 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),
+@@ -312,6 +314,21 @@ static inline bool irqd_affinity_is_managed(struct irq_data *d)
+ 	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)
+diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
+index c1784c0b4f35..134a2f69c21a 100644
+--- a/include/linux/memory_hotplug.h
++++ b/include/linux/memory_hotplug.h
+@@ -85,7 +85,8 @@ extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages);
+ extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
+ /* VM interface that may be used by firmware interface */
+ extern int online_pages(unsigned long, unsigned long, int);
+-extern int test_pages_in_a_zone(unsigned long, unsigned long);
++extern int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn,
++	unsigned long *valid_start, unsigned long *valid_end);
+ extern void __offline_isolated_pages(unsigned long, unsigned long);
+ 
+ typedef void (*online_page_callback_t)(struct page *page);
+diff --git a/include/linux/percpu-refcount.h b/include/linux/percpu-refcount.h
+index 1c7eec09e5eb..3a481a49546e 100644
+--- a/include/linux/percpu-refcount.h
++++ b/include/linux/percpu-refcount.h
+@@ -204,7 +204,7 @@ static inline void percpu_ref_get(struct percpu_ref *ref)
+ static inline bool percpu_ref_tryget(struct percpu_ref *ref)
+ {
+ 	unsigned long __percpu *percpu_count;
+-	int ret;
++	bool ret;
+ 
+ 	rcu_read_lock_sched();
+ 
+@@ -238,7 +238,7 @@ static inline bool percpu_ref_tryget(struct percpu_ref *ref)
+ static inline bool percpu_ref_tryget_live(struct percpu_ref *ref)
+ {
+ 	unsigned long __percpu *percpu_count;
+-	int ret = false;
++	bool ret = false;
+ 
+ 	rcu_read_lock_sched();
+ 
+diff --git a/kernel/cgroup.c b/kernel/cgroup.c
+index 85bc9beb046d..4e2f3de0e40b 100644
+--- a/kernel/cgroup.c
++++ b/kernel/cgroup.c
+@@ -5219,6 +5219,11 @@ static struct cgroup_subsys_state *css_create(struct cgroup *cgrp,
+ 	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;
+@@ -5283,11 +5288,6 @@ static struct cgroup *cgroup_create(struct cgroup *parent)
+ 
+ 	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:
+@@ -5295,9 +5295,6 @@ static struct cgroup *cgroup_create(struct cgroup *parent)
+ 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,
+diff --git a/kernel/events/core.c b/kernel/events/core.c
+index e5a8839e7076..b1cfd7416db0 100644
+--- a/kernel/events/core.c
++++ b/kernel/events/core.c
+@@ -1469,7 +1469,6 @@ ctx_group_list(struct perf_event *event, struct perf_event_context *ctx)
+ 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);
+@@ -1624,6 +1623,8 @@ static void perf_group_attach(struct perf_event *event)
+ {
+ 	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.
+ 	 */
+@@ -1697,6 +1698,8 @@ static void perf_group_detach(struct perf_event *event)
+ 	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.
+ 	 */
+@@ -1895,9 +1898,29 @@ __perf_remove_from_context(struct perf_event *event,
+  */
+ 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);
++	}
+ }
+ 
+ /*
+@@ -6583,6 +6606,27 @@ static void perf_event_mmap_event(struct perf_mmap_event *mmap_event)
+ 	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;
+@@ -6609,27 +6653,6 @@ static void perf_event_mmap_event(struct perf_mmap_event *mmap_event)
+ 		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) {
+diff --git a/kernel/irq/irqdomain.c b/kernel/irq/irqdomain.c
+index 8c0a0ae43521..b59e6768c5e9 100644
+--- a/kernel/irq/irqdomain.c
++++ b/kernel/irq/irqdomain.c
+@@ -1346,6 +1346,30 @@ void irq_domain_free_irqs_parent(struct irq_domain *domain,
+ }
+ EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent);
+ 
++static void __irq_domain_activate_irq(struct irq_data *irq_data)
++{
++	if (irq_data && irq_data->domain) {
++		struct irq_domain *domain = irq_data->domain;
++
++		if (irq_data->parent_data)
++			__irq_domain_activate_irq(irq_data->parent_data);
++		if (domain->ops->activate)
++			domain->ops->activate(domain, irq_data);
++	}
++}
++
++static void __irq_domain_deactivate_irq(struct irq_data *irq_data)
++{
++	if (irq_data && irq_data->domain) {
++		struct irq_domain *domain = irq_data->domain;
++
++		if (domain->ops->deactivate)
++			domain->ops->deactivate(domain, irq_data);
++		if (irq_data->parent_data)
++			__irq_domain_deactivate_irq(irq_data->parent_data);
++	}
++}
++
+ /**
+  * irq_domain_activate_irq - Call domain_ops->activate recursively to activate
+  *			     interrupt
+@@ -1356,13 +1380,9 @@ EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent);
+  */
+ void irq_domain_activate_irq(struct irq_data *irq_data)
+ {
+-	if (irq_data && irq_data->domain) {
+-		struct irq_domain *domain = irq_data->domain;
+-
+-		if (irq_data->parent_data)
+-			irq_domain_activate_irq(irq_data->parent_data);
+-		if (domain->ops->activate)
+-			domain->ops->activate(domain, irq_data);
++	if (!irqd_is_activated(irq_data)) {
++		__irq_domain_activate_irq(irq_data);
++		irqd_set_activated(irq_data);
+ 	}
+ }
+ 
+@@ -1376,13 +1396,9 @@ void irq_domain_activate_irq(struct irq_data *irq_data)
+  */
+ void irq_domain_deactivate_irq(struct irq_data *irq_data)
+ {
+-	if (irq_data && irq_data->domain) {
+-		struct irq_domain *domain = irq_data->domain;
+-
+-		if (domain->ops->deactivate)
+-			domain->ops->deactivate(domain, irq_data);
+-		if (irq_data->parent_data)
+-			irq_domain_deactivate_irq(irq_data->parent_data);
++	if (irqd_is_activated(irq_data)) {
++		__irq_domain_deactivate_irq(irq_data);
++		irqd_clr_activated(irq_data);
+ 	}
+ }
+ 
+diff --git a/kernel/trace/trace_hwlat.c b/kernel/trace/trace_hwlat.c
+index b97286c48735..f00b0131c8f9 100644
+--- a/kernel/trace/trace_hwlat.c
++++ b/kernel/trace/trace_hwlat.c
+@@ -266,7 +266,7 @@ static int get_sample(void)
+ 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;
+@@ -275,7 +275,7 @@ static void move_to_next_cpu(void)
+ 		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);
+@@ -330,10 +330,12 @@ static void move_to_next_cpu(void)
+ 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();
+diff --git a/mm/filemap.c b/mm/filemap.c
+index 779801092ef1..d8d7df82c69a 100644
+--- a/mm/filemap.c
++++ b/mm/filemap.c
+@@ -1703,6 +1703,11 @@ static ssize_t do_generic_file_read(struct file *filp, loff_t *ppos,
+ 
+ 		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,
+diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
+index c3a8141ac788..ede137345a99 100644
+--- a/mm/memory_hotplug.c
++++ b/mm/memory_hotplug.c
+@@ -1483,17 +1483,20 @@ bool is_mem_section_removable(unsigned long start_pfn, unsigned long nr_pages)
+ }
+ 
+ /*
+- * Confirm all pages in a range [start, end) is belongs to the same zone.
++ * Confirm all pages in a range [start, end) belong to the same zone.
++ * When true, return its valid [start, end).
+  */
+-int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn)
++int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn,
++			 unsigned long *valid_start, unsigned long *valid_end)
+ {
+ 	unsigned long pfn, sec_end_pfn;
++	unsigned long start, end;
+ 	struct zone *zone = NULL;
+ 	struct page *page;
+ 	int i;
+-	for (pfn = start_pfn, sec_end_pfn = SECTION_ALIGN_UP(start_pfn);
++	for (pfn = start_pfn, sec_end_pfn = SECTION_ALIGN_UP(start_pfn + 1);
+ 	     pfn < end_pfn;
+-	     pfn = sec_end_pfn + 1, sec_end_pfn += PAGES_PER_SECTION) {
++	     pfn = sec_end_pfn, sec_end_pfn += PAGES_PER_SECTION) {
+ 		/* Make sure the memory section is present first */
+ 		if (!present_section_nr(pfn_to_section_nr(pfn)))
+ 			continue;
+@@ -1509,10 +1512,20 @@ int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn)
+ 			page = pfn_to_page(pfn + i);
+ 			if (zone && page_zone(page) != zone)
+ 				return 0;
++			if (!zone)
++				start = pfn + i;
+ 			zone = page_zone(page);
++			end = pfn + MAX_ORDER_NR_PAGES;
+ 		}
+ 	}
+-	return 1;
++
++	if (zone) {
++		*valid_start = start;
++		*valid_end = end;
++		return 1;
++	} else {
++		return 0;
++	}
+ }
+ 
+ /*
+@@ -1859,6 +1872,7 @@ static int __ref __offline_pages(unsigned long start_pfn,
+ 	long offlined_pages;
+ 	int ret, drain, retry_max, node;
+ 	unsigned long flags;
++	unsigned long valid_start, valid_end;
+ 	struct zone *zone;
+ 	struct memory_notify arg;
+ 
+@@ -1869,10 +1883,10 @@ static int __ref __offline_pages(unsigned long start_pfn,
+ 		return -EINVAL;
+ 	/* This makes hotplug much easier...and readable.
+ 	   we assume this for now. .*/
+-	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 -EINVAL;
+ 
+-	zone = page_zone(pfn_to_page(start_pfn));
++	zone = page_zone(pfn_to_page(valid_start));
+ 	node = zone_to_nid(zone);
+ 	nr_pages = end_pfn - start_pfn;
+ 
+diff --git a/mm/zswap.c b/mm/zswap.c
+index 275b22cc8df4..dbef27822a98 100644
+--- a/mm/zswap.c
++++ b/mm/zswap.c
+@@ -78,7 +78,13 @@ static u64 zswap_duplicate_entry;
+ 
+ /* 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"
+@@ -176,6 +182,9 @@ static atomic_t zswap_pools_count = ATOMIC_INIT(0);
+ /* used by param callback function */
+ static bool zswap_init_started;
+ 
++/* fatal error during init */
++static bool zswap_init_failed;
++
+ /*********************************
+ * helpers and fwd declarations
+ **********************************/
+@@ -706,6 +715,11 @@ static int __zswap_param_set(const char *val, const struct kernel_param *kp,
+ 	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;
+@@ -785,6 +799,17 @@ static int zswap_zpool_param_set(const char *val,
+ 	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
+ **********************************/
+@@ -1271,6 +1296,9 @@ static int __init init_zswap(void)
+ 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 */
+diff --git a/net/can/bcm.c b/net/can/bcm.c
+index 436a7537e6a9..5e9ed5ec2860 100644
+--- a/net/can/bcm.c
++++ b/net/can/bcm.c
+@@ -734,14 +734,23 @@ static struct bcm_op *bcm_find_op(struct list_head *ops,
+ 
+ static void bcm_remove_op(struct bcm_op *op)
+ {
+-	hrtimer_cancel(&op->timer);
+-	hrtimer_cancel(&op->thrtimer);
+-
+-	if (op->tsklet.func)
+-		tasklet_kill(&op->tsklet);
++	if (op->tsklet.func) {
++		while (test_bit(TASKLET_STATE_SCHED, &op->tsklet.state) ||
++		       test_bit(TASKLET_STATE_RUN, &op->tsklet.state) ||
++		       hrtimer_active(&op->timer)) {
++			hrtimer_cancel(&op->timer);
++			tasklet_kill(&op->tsklet);
++		}
++	}
+ 
+-	if (op->thrtsklet.func)
+-		tasklet_kill(&op->thrtsklet);
++	if (op->thrtsklet.func) {
++		while (test_bit(TASKLET_STATE_SCHED, &op->thrtsklet.state) ||
++		       test_bit(TASKLET_STATE_RUN, &op->thrtsklet.state) ||
++		       hrtimer_active(&op->thrtimer)) {
++			hrtimer_cancel(&op->thrtimer);
++			tasklet_kill(&op->thrtsklet);
++		}
++	}
+ 
+ 	if ((op->frames) && (op->frames != &op->sframe))
+ 		kfree(op->frames);
+diff --git a/net/sunrpc/auth_gss/gss_rpc_xdr.c b/net/sunrpc/auth_gss/gss_rpc_xdr.c
+index dc6fb79a361f..25d9a9cf7b66 100644
+--- a/net/sunrpc/auth_gss/gss_rpc_xdr.c
++++ b/net/sunrpc/auth_gss/gss_rpc_xdr.c
+@@ -260,7 +260,7 @@ static int gssx_dec_option_array(struct xdr_stream *xdr,
+ 	if (!oa->data)
+ 		return -ENOMEM;
+ 
+-	creds = kmalloc(sizeof(struct svc_cred), GFP_KERNEL);
++	creds = kzalloc(sizeof(struct svc_cred), GFP_KERNEL);
+ 	if (!creds) {
+ 		kfree(oa->data);
+ 		return -ENOMEM;