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

[Mike Pagano]

commit:     399567b8a50e0c5f641df8c4df0de14f2655e652
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Fri Aug 25 10:59:10 2017 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Fri Aug 25 10:59:10 2017 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=399567b8

Linux patch 4.9.45

 0000_README             |    4 +
 1044_linux-4.9.45.patch | 1028 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 1032 insertions(+)

diff --git a/0000_README b/0000_README
index 8800832..e142b57 100644
--- a/0000_README
+++ b/0000_README
@@ -219,6 +219,10 @@ Patch:  1043_linux-4.9.44.patch
 From:   http://www.kernel.org
 Desc:   Linux 4.9.44
 
+Patch:  1044_linux-4.9.45.patch
+From:   http://www.kernel.org
+Desc:   Linux 4.9.45
+
 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/1044_linux-4.9.45.patch b/1044_linux-4.9.45.patch
new file mode 100644
index 0000000..0641b8f
--- /dev/null
+++ b/1044_linux-4.9.45.patch
@@ -0,0 +1,1028 @@
+diff --git a/Makefile b/Makefile
+index 3e95dfdbe572..ccd6d91f616e 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,6 +1,6 @@
+ VERSION = 4
+ PATCHLEVEL = 9
+-SUBLEVEL = 44
++SUBLEVEL = 45
+ EXTRAVERSION =
+ NAME = Roaring Lionus
+ 
+diff --git a/arch/arm64/include/asm/elf.h b/arch/arm64/include/asm/elf.h
+index afa23b057def..1fb023076dfc 100644
+--- a/arch/arm64/include/asm/elf.h
++++ b/arch/arm64/include/asm/elf.h
+@@ -114,10 +114,10 @@
+ 
+ /*
+  * This is the base location for PIE (ET_DYN with INTERP) loads. On
+- * 64-bit, this is raised to 4GB to leave the entire 32-bit address
++ * 64-bit, this is above 4GB to leave the entire 32-bit address
+  * space open for things that want to use the area for 32-bit pointers.
+  */
+-#define ELF_ET_DYN_BASE		0x100000000UL
++#define ELF_ET_DYN_BASE		(2 * TASK_SIZE_64 / 3)
+ 
+ #ifndef __ASSEMBLY__
+ 
+diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
+index b249c2fb99c8..1c141d50fbc6 100644
+--- a/arch/powerpc/kernel/process.c
++++ b/arch/powerpc/kernel/process.c
+@@ -359,7 +359,8 @@ void enable_kernel_vsx(void)
+ 
+ 	cpumsr = msr_check_and_set(MSR_FP|MSR_VEC|MSR_VSX);
+ 
+-	if (current->thread.regs && (current->thread.regs->msr & MSR_VSX)) {
++	if (current->thread.regs &&
++	    (current->thread.regs->msr & (MSR_VSX|MSR_VEC|MSR_FP))) {
+ 		check_if_tm_restore_required(current);
+ 		/*
+ 		 * If a thread has already been reclaimed then the
+@@ -383,7 +384,7 @@ void flush_vsx_to_thread(struct task_struct *tsk)
+ {
+ 	if (tsk->thread.regs) {
+ 		preempt_disable();
+-		if (tsk->thread.regs->msr & MSR_VSX) {
++		if (tsk->thread.regs->msr & (MSR_VSX|MSR_VEC|MSR_FP)) {
+ 			BUG_ON(tsk != current);
+ 			giveup_vsx(tsk);
+ 		}
+diff --git a/arch/x86/crypto/sha1_avx2_x86_64_asm.S b/arch/x86/crypto/sha1_avx2_x86_64_asm.S
+index 1cd792db15ef..1eab79c9ac48 100644
+--- a/arch/x86/crypto/sha1_avx2_x86_64_asm.S
++++ b/arch/x86/crypto/sha1_avx2_x86_64_asm.S
+@@ -117,11 +117,10 @@
+ 	.set T1, REG_T1
+ .endm
+ 
+-#define K_BASE		%r8
+ #define HASH_PTR	%r9
++#define BLOCKS_CTR	%r8
+ #define BUFFER_PTR	%r10
+ #define BUFFER_PTR2	%r13
+-#define BUFFER_END	%r11
+ 
+ #define PRECALC_BUF	%r14
+ #define WK_BUF		%r15
+@@ -205,14 +204,14 @@
+ 		 * blended AVX2 and ALU instruction scheduling
+ 		 * 1 vector iteration per 8 rounds
+ 		 */
+-		vmovdqu ((i * 2) + PRECALC_OFFSET)(BUFFER_PTR), W_TMP
++		vmovdqu (i * 2)(BUFFER_PTR), W_TMP
+ 	.elseif ((i & 7) == 1)
+-		vinsertf128 $1, (((i-1) * 2)+PRECALC_OFFSET)(BUFFER_PTR2),\
++		vinsertf128 $1, ((i-1) * 2)(BUFFER_PTR2),\
+ 			 WY_TMP, WY_TMP
+ 	.elseif ((i & 7) == 2)
+ 		vpshufb YMM_SHUFB_BSWAP, WY_TMP, WY
+ 	.elseif ((i & 7) == 4)
+-		vpaddd  K_XMM(K_BASE), WY, WY_TMP
++		vpaddd  K_XMM + K_XMM_AR(%rip), WY, WY_TMP
+ 	.elseif ((i & 7) == 7)
+ 		vmovdqu  WY_TMP, PRECALC_WK(i&~7)
+ 
+@@ -255,7 +254,7 @@
+ 		vpxor	WY, WY_TMP, WY_TMP
+ 	.elseif ((i & 7) == 7)
+ 		vpxor	WY_TMP2, WY_TMP, WY
+-		vpaddd	K_XMM(K_BASE), WY, WY_TMP
++		vpaddd  K_XMM + K_XMM_AR(%rip), WY, WY_TMP
+ 		vmovdqu	WY_TMP, PRECALC_WK(i&~7)
+ 
+ 		PRECALC_ROTATE_WY
+@@ -291,7 +290,7 @@
+ 		vpsrld	$30, WY, WY
+ 		vpor	WY, WY_TMP, WY
+ 	.elseif ((i & 7) == 7)
+-		vpaddd	K_XMM(K_BASE), WY, WY_TMP
++		vpaddd  K_XMM + K_XMM_AR(%rip), WY, WY_TMP
+ 		vmovdqu	WY_TMP, PRECALC_WK(i&~7)
+ 
+ 		PRECALC_ROTATE_WY
+@@ -446,6 +445,16 @@
+ 
+ .endm
+ 
++/* Add constant only if (%2 > %3) condition met (uses RTA as temp)
++ * %1 + %2 >= %3 ? %4 : 0
++ */
++.macro ADD_IF_GE a, b, c, d
++	mov     \a, RTA
++	add     $\d, RTA
++	cmp     $\c, \b
++	cmovge  RTA, \a
++.endm
++
+ /*
+  * macro implements 80 rounds of SHA-1, for multiple blocks with s/w pipelining
+  */
+@@ -463,13 +472,16 @@
+ 	lea	(2*4*80+32)(%rsp), WK_BUF
+ 
+ 	# Precalc WK for first 2 blocks
+-	PRECALC_OFFSET = 0
++	ADD_IF_GE BUFFER_PTR2, BLOCKS_CTR, 2, 64
+ 	.set i, 0
+ 	.rept    160
+ 		PRECALC i
+ 		.set i, i + 1
+ 	.endr
+-	PRECALC_OFFSET = 128
++
++	/* Go to next block if needed */
++	ADD_IF_GE BUFFER_PTR, BLOCKS_CTR, 3, 128
++	ADD_IF_GE BUFFER_PTR2, BLOCKS_CTR, 4, 128
+ 	xchg	WK_BUF, PRECALC_BUF
+ 
+ 	.align 32
+@@ -479,8 +491,8 @@ _loop:
+ 	 * we use K_BASE value as a signal of a last block,
+ 	 * it is set below by: cmovae BUFFER_PTR, K_BASE
+ 	 */
+-	cmp	K_BASE, BUFFER_PTR
+-	jne	_begin
++	test BLOCKS_CTR, BLOCKS_CTR
++	jnz _begin
+ 	.align 32
+ 	jmp	_end
+ 	.align 32
+@@ -512,10 +524,10 @@ _loop0:
+ 		.set j, j+2
+ 	.endr
+ 
+-	add	$(2*64), BUFFER_PTR       /* move to next odd-64-byte block */
+-	cmp	BUFFER_END, BUFFER_PTR    /* is current block the last one? */
+-	cmovae	K_BASE, BUFFER_PTR	/* signal the last iteration smartly */
+-
++	/* Update Counter */
++	sub $1, BLOCKS_CTR
++	/* Move to the next block only if needed*/
++	ADD_IF_GE BUFFER_PTR, BLOCKS_CTR, 4, 128
+ 	/*
+ 	 * rounds
+ 	 * 60,62,64,66,68
+@@ -532,8 +544,8 @@ _loop0:
+ 	UPDATE_HASH	12(HASH_PTR), D
+ 	UPDATE_HASH	16(HASH_PTR), E
+ 
+-	cmp	K_BASE, BUFFER_PTR	/* is current block the last one? */
+-	je	_loop
++	test	BLOCKS_CTR, BLOCKS_CTR
++	jz	_loop
+ 
+ 	mov	TB, B
+ 
+@@ -575,10 +587,10 @@ _loop2:
+ 		.set j, j+2
+ 	.endr
+ 
+-	add	$(2*64), BUFFER_PTR2      /* move to next even-64-byte block */
+-
+-	cmp	BUFFER_END, BUFFER_PTR2   /* is current block the last one */
+-	cmovae	K_BASE, BUFFER_PTR       /* signal the last iteration smartly */
++	/* update counter */
++	sub     $1, BLOCKS_CTR
++	/* Move to the next block only if needed*/
++	ADD_IF_GE BUFFER_PTR2, BLOCKS_CTR, 4, 128
+ 
+ 	jmp	_loop3
+ _loop3:
+@@ -641,19 +653,12 @@ _loop3:
+ 
+ 	avx2_zeroupper
+ 
+-	lea	K_XMM_AR(%rip), K_BASE
+-
++	/* Setup initial values */
+ 	mov	CTX, HASH_PTR
+ 	mov	BUF, BUFFER_PTR
+-	lea	64(BUF), BUFFER_PTR2
+-
+-	shl	$6, CNT			/* mul by 64 */
+-	add	BUF, CNT
+-	add	$64, CNT
+-	mov	CNT, BUFFER_END
+ 
+-	cmp	BUFFER_END, BUFFER_PTR2
+-	cmovae	K_BASE, BUFFER_PTR2
++	mov	BUF, BUFFER_PTR2
++	mov	CNT, BLOCKS_CTR
+ 
+ 	xmm_mov	BSWAP_SHUFB_CTL(%rip), YMM_SHUFB_BSWAP
+ 
+diff --git a/arch/x86/crypto/sha1_ssse3_glue.c b/arch/x86/crypto/sha1_ssse3_glue.c
+index f960a043cdeb..fc61739150e7 100644
+--- a/arch/x86/crypto/sha1_ssse3_glue.c
++++ b/arch/x86/crypto/sha1_ssse3_glue.c
+@@ -201,7 +201,7 @@ asmlinkage void sha1_transform_avx2(u32 *digest, const char *data,
+ 
+ static bool avx2_usable(void)
+ {
+-	if (false && avx_usable() && boot_cpu_has(X86_FEATURE_AVX2)
++	if (avx_usable() && boot_cpu_has(X86_FEATURE_AVX2)
+ 		&& boot_cpu_has(X86_FEATURE_BMI1)
+ 		&& boot_cpu_has(X86_FEATURE_BMI2))
+ 		return true;
+diff --git a/arch/x86/entry/entry_64.S b/arch/x86/entry/entry_64.S
+index ef766a358b37..e7b0e7ff4c58 100644
+--- a/arch/x86/entry/entry_64.S
++++ b/arch/x86/entry/entry_64.S
+@@ -1215,6 +1215,8 @@ ENTRY(nmi)
+ 	 * other IST entries.
+ 	 */
+ 
++	ASM_CLAC
++
+ 	/* Use %rdx as our temp variable throughout */
+ 	pushq	%rdx
+ 
+diff --git a/arch/x86/include/asm/elf.h b/arch/x86/include/asm/elf.h
+index c152db2ab687..b31761ecce63 100644
+--- a/arch/x86/include/asm/elf.h
++++ b/arch/x86/include/asm/elf.h
+@@ -247,11 +247,11 @@ extern int force_personality32;
+ 
+ /*
+  * This is the base location for PIE (ET_DYN with INTERP) loads. On
+- * 64-bit, this is raised to 4GB to leave the entire 32-bit address
++ * 64-bit, this is above 4GB to leave the entire 32-bit address
+  * space open for things that want to use the area for 32-bit pointers.
+  */
+ #define ELF_ET_DYN_BASE		(mmap_is_ia32() ? 0x000400000UL : \
+-						  0x100000000UL)
++						  (TASK_SIZE / 3 * 2))
+ 
+ /* This yields a mask that user programs can use to figure out what
+    instruction set this CPU supports.  This could be done in user space,
+diff --git a/block/blk-mq-pci.c b/block/blk-mq-pci.c
+index 966c2169762e..ee9d3d958fbe 100644
+--- a/block/blk-mq-pci.c
++++ b/block/blk-mq-pci.c
+@@ -36,12 +36,18 @@ int blk_mq_pci_map_queues(struct blk_mq_tag_set *set, struct pci_dev *pdev)
+ 	for (queue = 0; queue < set->nr_hw_queues; queue++) {
+ 		mask = pci_irq_get_affinity(pdev, queue);
+ 		if (!mask)
+-			return -EINVAL;
++			goto fallback;
+ 
+ 		for_each_cpu(cpu, mask)
+ 			set->mq_map[cpu] = queue;
+ 	}
+ 
+ 	return 0;
++
++fallback:
++	WARN_ON_ONCE(set->nr_hw_queues > 1);
++	for_each_possible_cpu(cpu)
++		set->mq_map[cpu] = 0;
++	return 0;
+ }
+ EXPORT_SYMBOL_GPL(blk_mq_pci_map_queues);
+diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
+index 9908597c5209..f11d62de2272 100644
+--- a/drivers/block/xen-blkfront.c
++++ b/drivers/block/xen-blkfront.c
+@@ -2112,9 +2112,9 @@ static int blkfront_resume(struct xenbus_device *dev)
+ 			/*
+ 			 * Get the bios in the request so we can re-queue them.
+ 			 */
+-			if (req_op(shadow[i].request) == REQ_OP_FLUSH ||
+-			    req_op(shadow[i].request) == REQ_OP_DISCARD ||
+-			    req_op(shadow[i].request) == REQ_OP_SECURE_ERASE ||
++			if (req_op(shadow[j].request) == REQ_OP_FLUSH ||
++			    req_op(shadow[j].request) == REQ_OP_DISCARD ||
++			    req_op(shadow[j].request) == REQ_OP_SECURE_ERASE ||
+ 			    shadow[j].request->cmd_flags & REQ_FUA) {
+ 				/*
+ 				 * Flush operations don't contain bios, so
+diff --git a/drivers/crypto/ixp4xx_crypto.c b/drivers/crypto/ixp4xx_crypto.c
+index 7868765a70c5..b54af97a20bb 100644
+--- a/drivers/crypto/ixp4xx_crypto.c
++++ b/drivers/crypto/ixp4xx_crypto.c
+@@ -1074,7 +1074,7 @@ static int aead_perform(struct aead_request *req, int encrypt,
+ 		req_ctx->hmac_virt = dma_pool_alloc(buffer_pool, flags,
+ 				&crypt->icv_rev_aes);
+ 		if (unlikely(!req_ctx->hmac_virt))
+-			goto free_buf_src;
++			goto free_buf_dst;
+ 		if (!encrypt) {
+ 			scatterwalk_map_and_copy(req_ctx->hmac_virt,
+ 				req->src, cryptlen, authsize, 0);
+@@ -1089,10 +1089,10 @@ static int aead_perform(struct aead_request *req, int encrypt,
+ 	BUG_ON(qmgr_stat_overflow(SEND_QID));
+ 	return -EINPROGRESS;
+ 
+-free_buf_src:
+-	free_buf_chain(dev, req_ctx->src, crypt->src_buf);
+ free_buf_dst:
+ 	free_buf_chain(dev, req_ctx->dst, crypt->dst_buf);
++free_buf_src:
++	free_buf_chain(dev, req_ctx->src, crypt->src_buf);
+ 	crypt->ctl_flags = CTL_FLAG_UNUSED;
+ 	return -ENOMEM;
+ }
+diff --git a/drivers/input/mouse/elan_i2c_core.c b/drivers/input/mouse/elan_i2c_core.c
+index da5458dfb1e3..98d4e515587a 100644
+--- a/drivers/input/mouse/elan_i2c_core.c
++++ b/drivers/input/mouse/elan_i2c_core.c
+@@ -1235,6 +1235,10 @@ static const struct acpi_device_id elan_acpi_id[] = {
+ 	{ "ELAN0100", 0 },
+ 	{ "ELAN0600", 0 },
+ 	{ "ELAN0605", 0 },
++	{ "ELAN0608", 0 },
++	{ "ELAN0605", 0 },
++	{ "ELAN0609", 0 },
++	{ "ELAN060B", 0 },
+ 	{ "ELAN1000", 0 },
+ 	{ }
+ };
+diff --git a/drivers/irqchip/irq-atmel-aic-common.c b/drivers/irqchip/irq-atmel-aic-common.c
+index 28b26c80f4cf..056507099725 100644
+--- a/drivers/irqchip/irq-atmel-aic-common.c
++++ b/drivers/irqchip/irq-atmel-aic-common.c
+@@ -142,9 +142,9 @@ void __init aic_common_rtc_irq_fixup(struct device_node *root)
+ 	struct device_node *np;
+ 	void __iomem *regs;
+ 
+-	np = of_find_compatible_node(root, NULL, "atmel,at91rm9200-rtc");
++	np = of_find_compatible_node(NULL, NULL, "atmel,at91rm9200-rtc");
+ 	if (!np)
+-		np = of_find_compatible_node(root, NULL,
++		np = of_find_compatible_node(NULL, NULL,
+ 					     "atmel,at91sam9x5-rtc");
+ 
+ 	if (!np)
+@@ -196,7 +196,6 @@ static void __init aic_common_irq_fixup(const struct of_device_id *matches)
+ 		return;
+ 
+ 	match = of_match_node(matches, root);
+-	of_node_put(root);
+ 
+ 	if (match) {
+ 		void (*fixup)(struct device_node *) = match->data;
+diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
+index 2f260c63c383..49a27dc46e5e 100644
+--- a/drivers/net/usb/qmi_wwan.c
++++ b/drivers/net/usb/qmi_wwan.c
+@@ -876,6 +876,7 @@ static const struct usb_device_id products[] = {
+ 	{QMI_FIXED_INTF(0x19d2, 0x1428, 2)},	/* Telewell TW-LTE 4G v2 */
+ 	{QMI_FIXED_INTF(0x19d2, 0x2002, 4)},	/* ZTE (Vodafone) K3765-Z */
+ 	{QMI_FIXED_INTF(0x2001, 0x7e19, 4)},	/* D-Link DWM-221 B1 */
++	{QMI_FIXED_INTF(0x2001, 0x7e35, 4)},	/* D-Link DWM-222 */
+ 	{QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)},    /* Sierra Wireless MC7700 */
+ 	{QMI_FIXED_INTF(0x114f, 0x68a2, 8)},    /* Sierra Wireless MC7750 */
+ 	{QMI_FIXED_INTF(0x1199, 0x68a2, 8)},	/* Sierra Wireless MC7710 in QMI mode */
+diff --git a/drivers/parisc/dino.c b/drivers/parisc/dino.c
+index 5c63b920b471..ed92c1254cff 100644
+--- a/drivers/parisc/dino.c
++++ b/drivers/parisc/dino.c
+@@ -956,7 +956,7 @@ static int __init dino_probe(struct parisc_device *dev)
+ 
+ 	dino_dev->hba.dev = dev;
+ 	dino_dev->hba.base_addr = ioremap_nocache(hpa, 4096);
+-	dino_dev->hba.lmmio_space_offset = 0;	/* CPU addrs == bus addrs */
++	dino_dev->hba.lmmio_space_offset = PCI_F_EXTEND;
+ 	spin_lock_init(&dino_dev->dinosaur_pen);
+ 	dino_dev->hba.iommu = ccio_get_iommu(dev);
+ 
+diff --git a/drivers/usb/core/usb-acpi.c b/drivers/usb/core/usb-acpi.c
+index 2776cfe64c09..ef9cf4a21afe 100644
+--- a/drivers/usb/core/usb-acpi.c
++++ b/drivers/usb/core/usb-acpi.c
+@@ -127,6 +127,22 @@ static enum usb_port_connect_type usb_acpi_get_connect_type(acpi_handle handle,
+  */
+ #define USB_ACPI_LOCATION_VALID (1 << 31)
+ 
++static struct acpi_device *usb_acpi_find_port(struct acpi_device *parent,
++					      int raw)
++{
++	struct acpi_device *adev;
++
++	if (!parent)
++		return NULL;
++
++	list_for_each_entry(adev, &parent->children, node) {
++		if (acpi_device_adr(adev) == raw)
++			return adev;
++	}
++
++	return acpi_find_child_device(parent, raw, false);
++}
++
+ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
+ {
+ 	struct usb_device *udev;
+@@ -174,8 +190,10 @@ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
+ 			int raw;
+ 
+ 			raw = usb_hcd_find_raw_port_number(hcd, port1);
+-			adev = acpi_find_child_device(ACPI_COMPANION(&udev->dev),
+-					raw, false);
++
++			adev = usb_acpi_find_port(ACPI_COMPANION(&udev->dev),
++						  raw);
++
+ 			if (!adev)
+ 				return NULL;
+ 		} else {
+@@ -186,7 +204,9 @@ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
+ 				return NULL;
+ 
+ 			acpi_bus_get_device(parent_handle, &adev);
+-			adev = acpi_find_child_device(adev, port1, false);
++
++			adev = usb_acpi_find_port(adev, port1);
++
+ 			if (!adev)
+ 				return NULL;
+ 		}
+diff --git a/drivers/xen/biomerge.c b/drivers/xen/biomerge.c
+index 4da69dbf7dca..1bdd02a6d6ac 100644
+--- a/drivers/xen/biomerge.c
++++ b/drivers/xen/biomerge.c
+@@ -10,8 +10,7 @@ bool xen_biovec_phys_mergeable(const struct bio_vec *vec1,
+ 	unsigned long bfn1 = pfn_to_bfn(page_to_pfn(vec1->bv_page));
+ 	unsigned long bfn2 = pfn_to_bfn(page_to_pfn(vec2->bv_page));
+ 
+-	return __BIOVEC_PHYS_MERGEABLE(vec1, vec2) &&
+-		((bfn1 == bfn2) || ((bfn1+1) == bfn2));
++	return bfn1 + PFN_DOWN(vec1->bv_offset + vec1->bv_len) == bfn2;
+ #else
+ 	/*
+ 	 * XXX: Add support for merging bio_vec when using different page
+diff --git a/include/linux/memblock.h b/include/linux/memblock.h
+index e8fba68e5d03..4024af00b137 100644
+--- a/include/linux/memblock.h
++++ b/include/linux/memblock.h
+@@ -64,6 +64,7 @@ extern bool movable_node_enabled;
+ #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
+ #define __init_memblock __meminit
+ #define __initdata_memblock __meminitdata
++void memblock_discard(void);
+ #else
+ #define __init_memblock
+ #define __initdata_memblock
+@@ -77,8 +78,6 @@ phys_addr_t memblock_find_in_range_node(phys_addr_t size, phys_addr_t align,
+ 					int nid, ulong flags);
+ phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end,
+ 				   phys_addr_t size, phys_addr_t align);
+-phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr);
+-phys_addr_t get_allocated_memblock_memory_regions_info(phys_addr_t *addr);
+ void memblock_allow_resize(void);
+ int memblock_add_node(phys_addr_t base, phys_addr_t size, int nid);
+ int memblock_add(phys_addr_t base, phys_addr_t size);
+@@ -112,6 +111,9 @@ void __next_mem_range_rev(u64 *idx, int nid, ulong flags,
+ void __next_reserved_mem_region(u64 *idx, phys_addr_t *out_start,
+ 				phys_addr_t *out_end);
+ 
++void __memblock_free_early(phys_addr_t base, phys_addr_t size);
++void __memblock_free_late(phys_addr_t base, phys_addr_t size);
++
+ /**
+  * for_each_mem_range - iterate through memblock areas from type_a and not
+  * included in type_b. Or just type_a if type_b is NULL.
+diff --git a/include/linux/pid.h b/include/linux/pid.h
+index 23705a53abba..97b745ddece5 100644
+--- a/include/linux/pid.h
++++ b/include/linux/pid.h
+@@ -8,7 +8,9 @@ enum pid_type
+ 	PIDTYPE_PID,
+ 	PIDTYPE_PGID,
+ 	PIDTYPE_SID,
+-	PIDTYPE_MAX
++	PIDTYPE_MAX,
++	/* only valid to __task_pid_nr_ns() */
++	__PIDTYPE_TGID
+ };
+ 
+ /*
+diff --git a/include/linux/sched.h b/include/linux/sched.h
+index 14f58cf06054..a4d0afc009a7 100644
+--- a/include/linux/sched.h
++++ b/include/linux/sched.h
+@@ -2132,31 +2132,8 @@ static inline pid_t task_tgid_nr(struct task_struct *tsk)
+ 	return tsk->tgid;
+ }
+ 
+-pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
+-
+-static inline pid_t task_tgid_vnr(struct task_struct *tsk)
+-{
+-	return pid_vnr(task_tgid(tsk));
+-}
+-
+ 
+ static inline int pid_alive(const struct task_struct *p);
+-static inline pid_t task_ppid_nr_ns(const struct task_struct *tsk, struct pid_namespace *ns)
+-{
+-	pid_t pid = 0;
+-
+-	rcu_read_lock();
+-	if (pid_alive(tsk))
+-		pid = task_tgid_nr_ns(rcu_dereference(tsk->real_parent), ns);
+-	rcu_read_unlock();
+-
+-	return pid;
+-}
+-
+-static inline pid_t task_ppid_nr(const struct task_struct *tsk)
+-{
+-	return task_ppid_nr_ns(tsk, &init_pid_ns);
+-}
+ 
+ static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
+ 					struct pid_namespace *ns)
+@@ -2181,6 +2158,33 @@ static inline pid_t task_session_vnr(struct task_struct *tsk)
+ 	return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
+ }
+ 
++static inline pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
++{
++	return __task_pid_nr_ns(tsk, __PIDTYPE_TGID, ns);
++}
++
++static inline pid_t task_tgid_vnr(struct task_struct *tsk)
++{
++	return __task_pid_nr_ns(tsk, __PIDTYPE_TGID, NULL);
++}
++
++static inline pid_t task_ppid_nr_ns(const struct task_struct *tsk, struct pid_namespace *ns)
++{
++	pid_t pid = 0;
++
++	rcu_read_lock();
++	if (pid_alive(tsk))
++		pid = task_tgid_nr_ns(rcu_dereference(tsk->real_parent), ns);
++	rcu_read_unlock();
++
++	return pid;
++}
++
++static inline pid_t task_ppid_nr(const struct task_struct *tsk)
++{
++	return task_ppid_nr_ns(tsk, &init_pid_ns);
++}
++
+ /* obsolete, do not use */
+ static inline pid_t task_pgrp_nr(struct task_struct *tsk)
+ {
+diff --git a/kernel/audit_watch.c b/kernel/audit_watch.c
+index 0d302a87f21b..690e1e3c59f7 100644
+--- a/kernel/audit_watch.c
++++ b/kernel/audit_watch.c
+@@ -457,13 +457,15 @@ void audit_remove_watch_rule(struct audit_krule *krule)
+ 	list_del(&krule->rlist);
+ 
+ 	if (list_empty(&watch->rules)) {
++		/*
++		 * audit_remove_watch() drops our reference to 'parent' which
++		 * can get freed. Grab our own reference to be safe.
++		 */
++		audit_get_parent(parent);
+ 		audit_remove_watch(watch);
+-
+-		if (list_empty(&parent->watches)) {
+-			audit_get_parent(parent);
++		if (list_empty(&parent->watches))
+ 			fsnotify_destroy_mark(&parent->mark, audit_watch_group);
+-			audit_put_parent(parent);
+-		}
++		audit_put_parent(parent);
+ 	}
+ }
+ 
+diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
+index 077c87f40f4d..f30110e1b8c9 100644
+--- a/kernel/irq/chip.c
++++ b/kernel/irq/chip.c
+@@ -895,13 +895,15 @@ EXPORT_SYMBOL_GPL(irq_set_chip_and_handler_name);
+ 
+ void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set)
+ {
+-	unsigned long flags;
++	unsigned long flags, trigger, tmp;
+ 	struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
+ 
+ 	if (!desc)
+ 		return;
+ 	irq_settings_clr_and_set(desc, clr, set);
+ 
++	trigger = irqd_get_trigger_type(&desc->irq_data);
++
+ 	irqd_clear(&desc->irq_data, IRQD_NO_BALANCING | IRQD_PER_CPU |
+ 		   IRQD_TRIGGER_MASK | IRQD_LEVEL | IRQD_MOVE_PCNTXT);
+ 	if (irq_settings_has_no_balance_set(desc))
+@@ -913,7 +915,11 @@ void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set)
+ 	if (irq_settings_is_level(desc))
+ 		irqd_set(&desc->irq_data, IRQD_LEVEL);
+ 
+-	irqd_set(&desc->irq_data, irq_settings_get_trigger_mask(desc));
++	tmp = irq_settings_get_trigger_mask(desc);
++	if (tmp != IRQ_TYPE_NONE)
++		trigger = tmp;
++
++	irqd_set(&desc->irq_data, trigger);
+ 
+ 	irq_put_desc_unlock(desc, flags);
+ }
+diff --git a/kernel/irq/ipi.c b/kernel/irq/ipi.c
+index 1a9abc1c8ea0..259a22aa9934 100644
+--- a/kernel/irq/ipi.c
++++ b/kernel/irq/ipi.c
+@@ -165,7 +165,7 @@ irq_hw_number_t ipi_get_hwirq(unsigned int irq, unsigned int cpu)
+ 	struct irq_data *data = irq_get_irq_data(irq);
+ 	struct cpumask *ipimask = data ? irq_data_get_affinity_mask(data) : NULL;
+ 
+-	if (!data || !ipimask || cpu > nr_cpu_ids)
++	if (!data || !ipimask || cpu >= nr_cpu_ids)
+ 		return INVALID_HWIRQ;
+ 
+ 	if (!cpumask_test_cpu(cpu, ipimask))
+@@ -195,7 +195,7 @@ static int ipi_send_verify(struct irq_chip *chip, struct irq_data *data,
+ 	if (!chip->ipi_send_single && !chip->ipi_send_mask)
+ 		return -EINVAL;
+ 
+-	if (cpu > nr_cpu_ids)
++	if (cpu >= nr_cpu_ids)
+ 		return -EINVAL;
+ 
+ 	if (dest) {
+diff --git a/kernel/pid.c b/kernel/pid.c
+index f66162f2359b..693a64385d59 100644
+--- a/kernel/pid.c
++++ b/kernel/pid.c
+@@ -526,8 +526,11 @@ pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
+ 	if (!ns)
+ 		ns = task_active_pid_ns(current);
+ 	if (likely(pid_alive(task))) {
+-		if (type != PIDTYPE_PID)
++		if (type != PIDTYPE_PID) {
++			if (type == __PIDTYPE_TGID)
++				type = PIDTYPE_PID;
+ 			task = task->group_leader;
++		}
+ 		nr = pid_nr_ns(rcu_dereference(task->pids[type].pid), ns);
+ 	}
+ 	rcu_read_unlock();
+@@ -536,12 +539,6 @@ pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
+ }
+ EXPORT_SYMBOL(__task_pid_nr_ns);
+ 
+-pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
+-{
+-	return pid_nr_ns(task_tgid(tsk), ns);
+-}
+-EXPORT_SYMBOL(task_tgid_nr_ns);
+-
+ struct pid_namespace *task_active_pid_ns(struct task_struct *tsk)
+ {
+ 	return ns_of_pid(task_pid(tsk));
+diff --git a/mm/memblock.c b/mm/memblock.c
+index 68849d0ead09..ccec42c12ba8 100644
+--- a/mm/memblock.c
++++ b/mm/memblock.c
+@@ -297,31 +297,27 @@ static void __init_memblock memblock_remove_region(struct memblock_type *type, u
+ }
+ 
+ #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
+-
+-phys_addr_t __init_memblock get_allocated_memblock_reserved_regions_info(
+-					phys_addr_t *addr)
+-{
+-	if (memblock.reserved.regions == memblock_reserved_init_regions)
+-		return 0;
+-
+-	*addr = __pa(memblock.reserved.regions);
+-
+-	return PAGE_ALIGN(sizeof(struct memblock_region) *
+-			  memblock.reserved.max);
+-}
+-
+-phys_addr_t __init_memblock get_allocated_memblock_memory_regions_info(
+-					phys_addr_t *addr)
++/**
++ * Discard memory and reserved arrays if they were allocated
++ */
++void __init memblock_discard(void)
+ {
+-	if (memblock.memory.regions == memblock_memory_init_regions)
+-		return 0;
++	phys_addr_t addr, size;
+ 
+-	*addr = __pa(memblock.memory.regions);
++	if (memblock.reserved.regions != memblock_reserved_init_regions) {
++		addr = __pa(memblock.reserved.regions);
++		size = PAGE_ALIGN(sizeof(struct memblock_region) *
++				  memblock.reserved.max);
++		__memblock_free_late(addr, size);
++	}
+ 
+-	return PAGE_ALIGN(sizeof(struct memblock_region) *
+-			  memblock.memory.max);
++	if (memblock.memory.regions == memblock_memory_init_regions) {
++		addr = __pa(memblock.memory.regions);
++		size = PAGE_ALIGN(sizeof(struct memblock_region) *
++				  memblock.memory.max);
++		__memblock_free_late(addr, size);
++	}
+ }
+-
+ #endif
+ 
+ /**
+diff --git a/mm/memory.c b/mm/memory.c
+index 9bf3da0d0e14..d064caff9d7d 100644
+--- a/mm/memory.c
++++ b/mm/memory.c
+@@ -3635,8 +3635,18 @@ int handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
+ 	 * further.
+ 	 */
+ 	if (unlikely((current->flags & PF_KTHREAD) && !(ret & VM_FAULT_ERROR)
+-				&& test_bit(MMF_UNSTABLE, &vma->vm_mm->flags)))
++				&& test_bit(MMF_UNSTABLE, &vma->vm_mm->flags))) {
++
++		/*
++		 * We are going to enforce SIGBUS but the PF path might have
++		 * dropped the mmap_sem already so take it again so that
++		 * we do not break expectations of all arch specific PF paths
++		 * and g-u-p
++		 */
++		if (ret & VM_FAULT_RETRY)
++			down_read(&vma->vm_mm->mmap_sem);
+ 		ret = VM_FAULT_SIGBUS;
++	}
+ 
+ 	return ret;
+ }
+diff --git a/mm/mempolicy.c b/mm/mempolicy.c
+index 23471526d424..a8ab5e73dc61 100644
+--- a/mm/mempolicy.c
++++ b/mm/mempolicy.c
+@@ -926,11 +926,6 @@ static long do_get_mempolicy(int *policy, nodemask_t *nmask,
+ 		*policy |= (pol->flags & MPOL_MODE_FLAGS);
+ 	}
+ 
+-	if (vma) {
+-		up_read(&current->mm->mmap_sem);
+-		vma = NULL;
+-	}
+-
+ 	err = 0;
+ 	if (nmask) {
+ 		if (mpol_store_user_nodemask(pol)) {
+diff --git a/mm/migrate.c b/mm/migrate.c
+index 6850f62998cd..821623fc7091 100644
+--- a/mm/migrate.c
++++ b/mm/migrate.c
+@@ -40,6 +40,7 @@
+ #include <linux/mmu_notifier.h>
+ #include <linux/page_idle.h>
+ #include <linux/page_owner.h>
++#include <linux/ptrace.h>
+ 
+ #include <asm/tlbflush.h>
+ 
+@@ -1663,7 +1664,6 @@ SYSCALL_DEFINE6(move_pages, pid_t, pid, unsigned long, nr_pages,
+ 		const int __user *, nodes,
+ 		int __user *, status, int, flags)
+ {
+-	const struct cred *cred = current_cred(), *tcred;
+ 	struct task_struct *task;
+ 	struct mm_struct *mm;
+ 	int err;
+@@ -1687,14 +1687,9 @@ SYSCALL_DEFINE6(move_pages, pid_t, pid, unsigned long, nr_pages,
+ 
+ 	/*
+ 	 * Check if this process has the right to modify the specified
+-	 * process. The right exists if the process has administrative
+-	 * capabilities, superuser privileges or the same
+-	 * userid as the target process.
++	 * process. Use the regular "ptrace_may_access()" checks.
+ 	 */
+-	tcred = __task_cred(task);
+-	if (!uid_eq(cred->euid, tcred->suid) && !uid_eq(cred->euid, tcred->uid) &&
+-	    !uid_eq(cred->uid,  tcred->suid) && !uid_eq(cred->uid,  tcred->uid) &&
+-	    !capable(CAP_SYS_NICE)) {
++	if (!ptrace_may_access(task, PTRACE_MODE_READ_REALCREDS)) {
+ 		rcu_read_unlock();
+ 		err = -EPERM;
+ 		goto out;
+diff --git a/mm/nobootmem.c b/mm/nobootmem.c
+index 487dad610731..ab998125f04d 100644
+--- a/mm/nobootmem.c
++++ b/mm/nobootmem.c
+@@ -146,22 +146,6 @@ static unsigned long __init free_low_memory_core_early(void)
+ 				NULL)
+ 		count += __free_memory_core(start, end);
+ 
+-#ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
+-	{
+-		phys_addr_t size;
+-
+-		/* Free memblock.reserved array if it was allocated */
+-		size = get_allocated_memblock_reserved_regions_info(&start);
+-		if (size)
+-			count += __free_memory_core(start, start + size);
+-
+-		/* Free memblock.memory array if it was allocated */
+-		size = get_allocated_memblock_memory_regions_info(&start);
+-		if (size)
+-			count += __free_memory_core(start, start + size);
+-	}
+-#endif
+-
+ 	return count;
+ }
+ 
+diff --git a/mm/page_alloc.c b/mm/page_alloc.c
+index 9419aa4e5441..2abf8d5f0ad4 100644
+--- a/mm/page_alloc.c
++++ b/mm/page_alloc.c
+@@ -1587,6 +1587,10 @@ void __init page_alloc_init_late(void)
+ 	/* Reinit limits that are based on free pages after the kernel is up */
+ 	files_maxfiles_init();
+ #endif
++#ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
++	/* Discard memblock private memory */
++	memblock_discard();
++#endif
+ 
+ 	for_each_populated_zone(zone)
+ 		set_zone_contiguous(zone);
+diff --git a/net/netfilter/nf_conntrack_extend.c b/net/netfilter/nf_conntrack_extend.c
+index 02bcf00c2492..008299b7f78f 100644
+--- a/net/netfilter/nf_conntrack_extend.c
++++ b/net/netfilter/nf_conntrack_extend.c
+@@ -53,7 +53,11 @@ nf_ct_ext_create(struct nf_ct_ext **ext, enum nf_ct_ext_id id,
+ 
+ 	rcu_read_lock();
+ 	t = rcu_dereference(nf_ct_ext_types[id]);
+-	BUG_ON(t == NULL);
++	if (!t) {
++		rcu_read_unlock();
++		return NULL;
++	}
++
+ 	off = ALIGN(sizeof(struct nf_ct_ext), t->align);
+ 	len = off + t->len + var_alloc_len;
+ 	alloc_size = t->alloc_size + var_alloc_len;
+@@ -88,7 +92,10 @@ void *__nf_ct_ext_add_length(struct nf_conn *ct, enum nf_ct_ext_id id,
+ 
+ 	rcu_read_lock();
+ 	t = rcu_dereference(nf_ct_ext_types[id]);
+-	BUG_ON(t == NULL);
++	if (!t) {
++		rcu_read_unlock();
++		return NULL;
++	}
+ 
+ 	newoff = ALIGN(old->len, t->align);
+ 	newlen = newoff + t->len + var_alloc_len;
+@@ -175,6 +182,6 @@ void nf_ct_extend_unregister(struct nf_ct_ext_type *type)
+ 	RCU_INIT_POINTER(nf_ct_ext_types[type->id], NULL);
+ 	update_alloc_size(type);
+ 	mutex_unlock(&nf_ct_ext_type_mutex);
+-	rcu_barrier(); /* Wait for completion of call_rcu()'s */
++	synchronize_rcu();
+ }
+ EXPORT_SYMBOL_GPL(nf_ct_extend_unregister);
+diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
+index f3b1d7f50b81..67c4c68ce041 100644
+--- a/sound/core/seq/seq_clientmgr.c
++++ b/sound/core/seq/seq_clientmgr.c
+@@ -1502,16 +1502,11 @@ static int snd_seq_ioctl_unsubscribe_port(struct snd_seq_client *client,
+ static int snd_seq_ioctl_create_queue(struct snd_seq_client *client, void *arg)
+ {
+ 	struct snd_seq_queue_info *info = arg;
+-	int result;
+ 	struct snd_seq_queue *q;
+ 
+-	result = snd_seq_queue_alloc(client->number, info->locked, info->flags);
+-	if (result < 0)
+-		return result;
+-
+-	q = queueptr(result);
+-	if (q == NULL)
+-		return -EINVAL;
++	q = snd_seq_queue_alloc(client->number, info->locked, info->flags);
++	if (IS_ERR(q))
++		return PTR_ERR(q);
+ 
+ 	info->queue = q->queue;
+ 	info->locked = q->locked;
+@@ -1521,7 +1516,7 @@ static int snd_seq_ioctl_create_queue(struct snd_seq_client *client, void *arg)
+ 	if (!info->name[0])
+ 		snprintf(info->name, sizeof(info->name), "Queue-%d", q->queue);
+ 	strlcpy(q->name, info->name, sizeof(q->name));
+-	queuefree(q);
++	snd_use_lock_free(&q->use_lock);
+ 
+ 	return 0;
+ }
+diff --git a/sound/core/seq/seq_queue.c b/sound/core/seq/seq_queue.c
+index 450c5187eecb..79e0c5604ef8 100644
+--- a/sound/core/seq/seq_queue.c
++++ b/sound/core/seq/seq_queue.c
+@@ -184,22 +184,26 @@ void __exit snd_seq_queues_delete(void)
+ static void queue_use(struct snd_seq_queue *queue, int client, int use);
+ 
+ /* allocate a new queue -
+- * return queue index value or negative value for error
++ * return pointer to new queue or ERR_PTR(-errno) for error
++ * The new queue's use_lock is set to 1. It is the caller's responsibility to
++ * call snd_use_lock_free(&q->use_lock).
+  */
+-int snd_seq_queue_alloc(int client, int locked, unsigned int info_flags)
++struct snd_seq_queue *snd_seq_queue_alloc(int client, int locked, unsigned int info_flags)
+ {
+ 	struct snd_seq_queue *q;
+ 
+ 	q = queue_new(client, locked);
+ 	if (q == NULL)
+-		return -ENOMEM;
++		return ERR_PTR(-ENOMEM);
+ 	q->info_flags = info_flags;
+ 	queue_use(q, client, 1);
++	snd_use_lock_use(&q->use_lock);
+ 	if (queue_list_add(q) < 0) {
++		snd_use_lock_free(&q->use_lock);
+ 		queue_delete(q);
+-		return -ENOMEM;
++		return ERR_PTR(-ENOMEM);
+ 	}
+-	return q->queue;
++	return q;
+ }
+ 
+ /* delete a queue - queue must be owned by the client */
+diff --git a/sound/core/seq/seq_queue.h b/sound/core/seq/seq_queue.h
+index 30c8111477f6..719093489a2c 100644
+--- a/sound/core/seq/seq_queue.h
++++ b/sound/core/seq/seq_queue.h
+@@ -71,7 +71,7 @@ void snd_seq_queues_delete(void);
+ 
+ 
+ /* create new queue (constructor) */
+-int snd_seq_queue_alloc(int client, int locked, unsigned int flags);
++struct snd_seq_queue *snd_seq_queue_alloc(int client, int locked, unsigned int flags);
+ 
+ /* delete queue (destructor) */
+ int snd_seq_queue_delete(int client, int queueid);
+diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
+index 4703caea56b2..d09c28c1deaf 100644
+--- a/sound/usb/mixer.c
++++ b/sound/usb/mixer.c
+@@ -542,6 +542,8 @@ int snd_usb_mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
+ 
+ 	if (size < sizeof(scale))
+ 		return -ENOMEM;
++	if (cval->min_mute)
++		scale[0] = SNDRV_CTL_TLVT_DB_MINMAX_MUTE;
+ 	scale[2] = cval->dBmin;
+ 	scale[3] = cval->dBmax;
+ 	if (copy_to_user(_tlv, scale, sizeof(scale)))
+diff --git a/sound/usb/mixer.h b/sound/usb/mixer.h
+index 3417ef347e40..2b4b067646ab 100644
+--- a/sound/usb/mixer.h
++++ b/sound/usb/mixer.h
+@@ -64,6 +64,7 @@ struct usb_mixer_elem_info {
+ 	int cached;
+ 	int cache_val[MAX_CHANNELS];
+ 	u8 initialized;
++	u8 min_mute;
+ 	void *private_data;
+ };
+ 
+diff --git a/sound/usb/mixer_quirks.c b/sound/usb/mixer_quirks.c
+index 04991b009132..5d2fc5f58bfe 100644
+--- a/sound/usb/mixer_quirks.c
++++ b/sound/usb/mixer_quirks.c
+@@ -1873,6 +1873,12 @@ void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
+ 		if (unitid == 7 && cval->control == UAC_FU_VOLUME)
+ 			snd_dragonfly_quirk_db_scale(mixer, cval, kctl);
+ 		break;
++	/* lowest playback value is muted on C-Media devices */
++	case USB_ID(0x0d8c, 0x000c):
++	case USB_ID(0x0d8c, 0x0014):
++		if (strstr(kctl->id.name, "Playback"))
++			cval->min_mute = 1;
++		break;
+ 	}
+ }
+ 
+diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
+index eb4b9f7a571e..95c2749ac8a3 100644
+--- a/sound/usb/quirks.c
++++ b/sound/usb/quirks.c
+@@ -1142,6 +1142,7 @@ bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip)
+ 	case USB_ID(0x0556, 0x0014): /* Phoenix Audio TMX320VC */
+ 	case USB_ID(0x05A3, 0x9420): /* ELP HD USB Camera */
+ 	case USB_ID(0x074D, 0x3553): /* Outlaw RR2150 (Micronas UAC3553B) */
++	case USB_ID(0x1395, 0x740a): /* Sennheiser DECT */
+ 	case USB_ID(0x1901, 0x0191): /* GE B850V3 CP2114 audio interface */
+ 	case USB_ID(0x1de7, 0x0013): /* Phoenix Audio MT202exe */
+ 	case USB_ID(0x1de7, 0x0014): /* Phoenix Audio TMX320 */