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

[Mike Pagano]

commit:     1d92f75ee86e750cd47eb0715ba6ba4d2b6d68ee
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Tue Jul  8 18:30:47 2014 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Tue Jul  8 18:30:47 2014 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/linux-patches.git;a=commit;h=1d92f75e

Linux patch 3.15.4

---
 0000_README             |    4 +
 1003_linux-3.15.4.patch | 2843 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 2847 insertions(+)

diff --git a/0000_README b/0000_README
index 236fcc9..be75984 100644
--- a/0000_README
+++ b/0000_README
@@ -55,6 +55,10 @@ Patch:  1002_linux-3.15.3.patch
 From:   http://www.kernel.org
 Desc:   Linux 3.15.3
 
+Patch:  1003_linux-3.15.4.patch
+From:   http://www.kernel.org
+Desc:   Linux 3.15.4
+
 Patch:  1700_enable-thinkpad-micled.patch
 From:   https://bugs.gentoo.org/show_bug.cgi?id=449248
 Desc:   Enable mic mute led in thinkpads

diff --git a/1003_linux-3.15.4.patch b/1003_linux-3.15.4.patch
new file mode 100644
index 0000000..2d3f2db
--- /dev/null
+++ b/1003_linux-3.15.4.patch
@@ -0,0 +1,2843 @@
+diff --git a/Documentation/SubmittingPatches b/Documentation/SubmittingPatches
+index 2a8e89e13e45..7e9abb8a276b 100644
+--- a/Documentation/SubmittingPatches
++++ b/Documentation/SubmittingPatches
+@@ -132,6 +132,20 @@ Example:
+ 	platform_set_drvdata(), but left the variable "dev" unused,
+ 	delete it.
+ 
++If your patch fixes a bug in a specific commit, e.g. you found an issue using
++git-bisect, please use the 'Fixes:' tag with the first 12 characters of the
++SHA-1 ID, and the one line summary.
++Example:
++
++	Fixes: e21d2170f366 ("video: remove unnecessary platform_set_drvdata()")
++
++The following git-config settings can be used to add a pretty format for
++outputting the above style in the git log or git show commands
++
++	[core]
++		abbrev = 12
++	[pretty]
++		fixes = Fixes: %h (\"%s\")
+ 
+ 3) Separate your changes.
+ 
+@@ -443,7 +457,7 @@ person it names.  This tag documents that potentially interested parties
+ have been included in the discussion
+ 
+ 
+-14) Using Reported-by:, Tested-by:, Reviewed-by: and Suggested-by:
++14) Using Reported-by:, Tested-by:, Reviewed-by:, Suggested-by: and Fixes:
+ 
+ If this patch fixes a problem reported by somebody else, consider adding a
+ Reported-by: tag to credit the reporter for their contribution.  Please
+@@ -498,6 +512,12 @@ idea was not posted in a public forum. That said, if we diligently credit our
+ idea reporters, they will, hopefully, be inspired to help us again in the
+ future.
+ 
++A Fixes: tag indicates that the patch fixes an issue in a previous commit. It
++is used to make it easy to determine where a bug originated, which can help
++review a bug fix. This tag also assists the stable kernel team in determining
++which stable kernel versions should receive your fix. This is the preferred
++method for indicating a bug fixed by the patch. See #2 above for more details.
++
+ 
+ 15) The canonical patch format
+ 
+diff --git a/Documentation/sound/alsa/HD-Audio-Models.txt b/Documentation/sound/alsa/HD-Audio-Models.txt
+index 85c362d8ea34..d1ab5e17eb13 100644
+--- a/Documentation/sound/alsa/HD-Audio-Models.txt
++++ b/Documentation/sound/alsa/HD-Audio-Models.txt
+@@ -286,6 +286,11 @@ STAC92HD83*
+   hp-inv-led	HP with broken BIOS for inverted mute LED
+   auto		BIOS setup (default)
+ 
++STAC92HD95
++==========
++  hp-led	LED support for HP laptops
++  hp-bass	Bass HPF setup for HP Spectre 13
++
+ STAC9872
+ ========
+   vaio		VAIO laptop without SPDIF
+diff --git a/Makefile b/Makefile
+index 2e37d8b0bb96..25ecc1dd5bb5 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,6 +1,6 @@
+ VERSION = 3
+ PATCHLEVEL = 15
+-SUBLEVEL = 3
++SUBLEVEL = 4
+ EXTRAVERSION =
+ NAME = Shuffling Zombie Juror
+ 
+diff --git a/arch/mips/include/asm/sigcontext.h b/arch/mips/include/asm/sigcontext.h
+index f54bdbe85c0d..eeeb0f48c767 100644
+--- a/arch/mips/include/asm/sigcontext.h
++++ b/arch/mips/include/asm/sigcontext.h
+@@ -32,8 +32,6 @@ struct sigcontext32 {
+ 	__u32		sc_lo2;
+ 	__u32		sc_hi3;
+ 	__u32		sc_lo3;
+-	__u64		sc_msaregs[32];	/* Most significant 64 bits */
+-	__u32		sc_msa_csr;
+ };
+ #endif /* _MIPS_SIM == _MIPS_SIM_ABI64 || _MIPS_SIM == _MIPS_SIM_NABI32 */
+ #endif /* _ASM_SIGCONTEXT_H */
+diff --git a/arch/mips/include/uapi/asm/sigcontext.h b/arch/mips/include/uapi/asm/sigcontext.h
+index 681c17603a48..6c9906f59c6e 100644
+--- a/arch/mips/include/uapi/asm/sigcontext.h
++++ b/arch/mips/include/uapi/asm/sigcontext.h
+@@ -12,10 +12,6 @@
+ #include <linux/types.h>
+ #include <asm/sgidefs.h>
+ 
+-/* Bits which may be set in sc_used_math */
+-#define USEDMATH_FP	(1 << 0)
+-#define USEDMATH_MSA	(1 << 1)
+-
+ #if _MIPS_SIM == _MIPS_SIM_ABI32
+ 
+ /*
+@@ -41,8 +37,6 @@ struct sigcontext {
+ 	unsigned long		sc_lo2;
+ 	unsigned long		sc_hi3;
+ 	unsigned long		sc_lo3;
+-	unsigned long long	sc_msaregs[32];	/* Most significant 64 bits */
+-	unsigned long		sc_msa_csr;
+ };
+ 
+ #endif /* _MIPS_SIM == _MIPS_SIM_ABI32 */
+@@ -76,8 +70,6 @@ struct sigcontext {
+ 	__u32	sc_used_math;
+ 	__u32	sc_dsp;
+ 	__u32	sc_reserved;
+-	__u64	sc_msaregs[32];
+-	__u32	sc_msa_csr;
+ };
+ 
+ 
+diff --git a/arch/mips/kernel/asm-offsets.c b/arch/mips/kernel/asm-offsets.c
+index 0ea75c244b48..7ff80622c8d9 100644
+--- a/arch/mips/kernel/asm-offsets.c
++++ b/arch/mips/kernel/asm-offsets.c
+@@ -295,7 +295,6 @@ void output_sc_defines(void)
+ 	OFFSET(SC_LO2, sigcontext, sc_lo2);
+ 	OFFSET(SC_HI3, sigcontext, sc_hi3);
+ 	OFFSET(SC_LO3, sigcontext, sc_lo3);
+-	OFFSET(SC_MSAREGS, sigcontext, sc_msaregs);
+ 	BLANK();
+ }
+ #endif
+@@ -310,7 +309,6 @@ void output_sc_defines(void)
+ 	OFFSET(SC_MDLO, sigcontext, sc_mdlo);
+ 	OFFSET(SC_PC, sigcontext, sc_pc);
+ 	OFFSET(SC_FPC_CSR, sigcontext, sc_fpc_csr);
+-	OFFSET(SC_MSAREGS, sigcontext, sc_msaregs);
+ 	BLANK();
+ }
+ #endif
+@@ -322,7 +320,6 @@ void output_sc32_defines(void)
+ 	OFFSET(SC32_FPREGS, sigcontext32, sc_fpregs);
+ 	OFFSET(SC32_FPC_CSR, sigcontext32, sc_fpc_csr);
+ 	OFFSET(SC32_FPC_EIR, sigcontext32, sc_fpc_eir);
+-	OFFSET(SC32_MSAREGS, sigcontext32, sc_msaregs);
+ 	BLANK();
+ }
+ #endif
+diff --git a/arch/mips/kernel/irq-msc01.c b/arch/mips/kernel/irq-msc01.c
+index fab40f7d2e03..ac9facc08694 100644
+--- a/arch/mips/kernel/irq-msc01.c
++++ b/arch/mips/kernel/irq-msc01.c
+@@ -131,7 +131,7 @@ void __init init_msc_irqs(unsigned long icubase, unsigned int irqbase, msc_irqma
+ 
+ 	board_bind_eic_interrupt = &msc_bind_eic_interrupt;
+ 
+-	for (; nirq >= 0; nirq--, imp++) {
++	for (; nirq > 0; nirq--, imp++) {
+ 		int n = imp->im_irq;
+ 
+ 		switch (imp->im_type) {
+diff --git a/arch/mips/kernel/r4k_fpu.S b/arch/mips/kernel/r4k_fpu.S
+index 71814272d148..8352523568e6 100644
+--- a/arch/mips/kernel/r4k_fpu.S
++++ b/arch/mips/kernel/r4k_fpu.S
+@@ -13,7 +13,6 @@
+  * Copyright (C) 1999, 2001 Silicon Graphics, Inc.
+  */
+ #include <asm/asm.h>
+-#include <asm/asmmacro.h>
+ #include <asm/errno.h>
+ #include <asm/fpregdef.h>
+ #include <asm/mipsregs.h>
+@@ -246,218 +245,6 @@ LEAF(_restore_fp_context32)
+ 	END(_restore_fp_context32)
+ #endif
+ 
+-#ifdef CONFIG_CPU_HAS_MSA
+-
+-	.macro	save_sc_msareg	wr, off, sc, tmp
+-#ifdef CONFIG_64BIT
+-	copy_u_d \tmp, \wr, 1
+-	EX sd	\tmp, (\off+(\wr*8))(\sc)
+-#elif defined(CONFIG_CPU_LITTLE_ENDIAN)
+-	copy_u_w \tmp, \wr, 2
+-	EX sw	\tmp, (\off+(\wr*8)+0)(\sc)
+-	copy_u_w \tmp, \wr, 3
+-	EX sw	\tmp, (\off+(\wr*8)+4)(\sc)
+-#else /* CONFIG_CPU_BIG_ENDIAN */
+-	copy_u_w \tmp, \wr, 2
+-	EX sw	\tmp, (\off+(\wr*8)+4)(\sc)
+-	copy_u_w \tmp, \wr, 3
+-	EX sw	\tmp, (\off+(\wr*8)+0)(\sc)
+-#endif
+-	.endm
+-
+-/*
+- * int _save_msa_context(struct sigcontext *sc)
+- *
+- * Save the upper 64 bits of each vector register along with the MSA_CSR
+- * register into sc. Returns zero on success, else non-zero.
+- */
+-LEAF(_save_msa_context)
+-	save_sc_msareg	0, SC_MSAREGS, a0, t0
+-	save_sc_msareg	1, SC_MSAREGS, a0, t0
+-	save_sc_msareg	2, SC_MSAREGS, a0, t0
+-	save_sc_msareg	3, SC_MSAREGS, a0, t0
+-	save_sc_msareg	4, SC_MSAREGS, a0, t0
+-	save_sc_msareg	5, SC_MSAREGS, a0, t0
+-	save_sc_msareg	6, SC_MSAREGS, a0, t0
+-	save_sc_msareg	7, SC_MSAREGS, a0, t0
+-	save_sc_msareg	8, SC_MSAREGS, a0, t0
+-	save_sc_msareg	9, SC_MSAREGS, a0, t0
+-	save_sc_msareg	10, SC_MSAREGS, a0, t0
+-	save_sc_msareg	11, SC_MSAREGS, a0, t0
+-	save_sc_msareg	12, SC_MSAREGS, a0, t0
+-	save_sc_msareg	13, SC_MSAREGS, a0, t0
+-	save_sc_msareg	14, SC_MSAREGS, a0, t0
+-	save_sc_msareg	15, SC_MSAREGS, a0, t0
+-	save_sc_msareg	16, SC_MSAREGS, a0, t0
+-	save_sc_msareg	17, SC_MSAREGS, a0, t0
+-	save_sc_msareg	18, SC_MSAREGS, a0, t0
+-	save_sc_msareg	19, SC_MSAREGS, a0, t0
+-	save_sc_msareg	20, SC_MSAREGS, a0, t0
+-	save_sc_msareg	21, SC_MSAREGS, a0, t0
+-	save_sc_msareg	22, SC_MSAREGS, a0, t0
+-	save_sc_msareg	23, SC_MSAREGS, a0, t0
+-	save_sc_msareg	24, SC_MSAREGS, a0, t0
+-	save_sc_msareg	25, SC_MSAREGS, a0, t0
+-	save_sc_msareg	26, SC_MSAREGS, a0, t0
+-	save_sc_msareg	27, SC_MSAREGS, a0, t0
+-	save_sc_msareg	28, SC_MSAREGS, a0, t0
+-	save_sc_msareg	29, SC_MSAREGS, a0, t0
+-	save_sc_msareg	30, SC_MSAREGS, a0, t0
+-	save_sc_msareg	31, SC_MSAREGS, a0, t0
+-	jr	ra
+-	 li	v0, 0
+-	END(_save_msa_context)
+-
+-#ifdef CONFIG_MIPS32_COMPAT
+-
+-/*
+- * int _save_msa_context32(struct sigcontext32 *sc)
+- *
+- * Save the upper 64 bits of each vector register along with the MSA_CSR
+- * register into sc. Returns zero on success, else non-zero.
+- */
+-LEAF(_save_msa_context32)
+-	save_sc_msareg	0, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	1, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	2, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	3, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	4, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	5, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	6, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	7, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	8, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	9, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	10, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	11, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	12, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	13, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	14, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	15, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	16, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	17, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	18, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	19, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	20, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	21, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	22, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	23, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	24, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	25, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	26, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	27, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	28, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	29, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	30, SC32_MSAREGS, a0, t0
+-	save_sc_msareg	31, SC32_MSAREGS, a0, t0
+-	jr	ra
+-	 li	v0, 0
+-	END(_save_msa_context32)
+-
+-#endif /* CONFIG_MIPS32_COMPAT */
+-
+-	.macro restore_sc_msareg	wr, off, sc, tmp
+-#ifdef CONFIG_64BIT
+-	EX ld	\tmp, (\off+(\wr*8))(\sc)
+-	insert_d \wr, 1, \tmp
+-#elif defined(CONFIG_CPU_LITTLE_ENDIAN)
+-	EX lw	\tmp, (\off+(\wr*8)+0)(\sc)
+-	insert_w \wr, 2, \tmp
+-	EX lw	\tmp, (\off+(\wr*8)+4)(\sc)
+-	insert_w \wr, 3, \tmp
+-#else /* CONFIG_CPU_BIG_ENDIAN */
+-	EX lw	\tmp, (\off+(\wr*8)+4)(\sc)
+-	insert_w \wr, 2, \tmp
+-	EX lw	\tmp, (\off+(\wr*8)+0)(\sc)
+-	insert_w \wr, 3, \tmp
+-#endif
+-	.endm
+-
+-/*
+- * int _restore_msa_context(struct sigcontext *sc)
+- */
+-LEAF(_restore_msa_context)
+-	restore_sc_msareg	0, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	1, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	2, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	3, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	4, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	5, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	6, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	7, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	8, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	9, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	10, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	11, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	12, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	13, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	14, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	15, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	16, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	17, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	18, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	19, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	20, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	21, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	22, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	23, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	24, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	25, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	26, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	27, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	28, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	29, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	30, SC_MSAREGS, a0, t0
+-	restore_sc_msareg	31, SC_MSAREGS, a0, t0
+-	jr	ra
+-	 li	v0, 0
+-	END(_restore_msa_context)
+-
+-#ifdef CONFIG_MIPS32_COMPAT
+-
+-/*
+- * int _restore_msa_context32(struct sigcontext32 *sc)
+- */
+-LEAF(_restore_msa_context32)
+-	restore_sc_msareg	0, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	1, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	2, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	3, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	4, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	5, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	6, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	7, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	8, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	9, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	10, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	11, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	12, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	13, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	14, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	15, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	16, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	17, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	18, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	19, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	20, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	21, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	22, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	23, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	24, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	25, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	26, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	27, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	28, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	29, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	30, SC32_MSAREGS, a0, t0
+-	restore_sc_msareg	31, SC32_MSAREGS, a0, t0
+-	jr	ra
+-	 li	v0, 0
+-	END(_restore_msa_context32)
+-
+-#endif /* CONFIG_MIPS32_COMPAT */
+-
+-#endif /* CONFIG_CPU_HAS_MSA */
+-
+ 	.set	reorder
+ 
+ 	.type	fault@function
+diff --git a/arch/mips/kernel/signal.c b/arch/mips/kernel/signal.c
+index 33133d3df3e5..9e60d117e41e 100644
+--- a/arch/mips/kernel/signal.c
++++ b/arch/mips/kernel/signal.c
+@@ -31,7 +31,6 @@
+ #include <linux/bitops.h>
+ #include <asm/cacheflush.h>
+ #include <asm/fpu.h>
+-#include <asm/msa.h>
+ #include <asm/sim.h>
+ #include <asm/ucontext.h>
+ #include <asm/cpu-features.h>
+@@ -48,9 +47,6 @@ static int (*restore_fp_context)(struct sigcontext __user *sc);
+ extern asmlinkage int _save_fp_context(struct sigcontext __user *sc);
+ extern asmlinkage int _restore_fp_context(struct sigcontext __user *sc);
+ 
+-extern asmlinkage int _save_msa_context(struct sigcontext __user *sc);
+-extern asmlinkage int _restore_msa_context(struct sigcontext __user *sc);
+-
+ struct sigframe {
+ 	u32 sf_ass[4];		/* argument save space for o32 */
+ 	u32 sf_pad[2];		/* Was: signal trampoline */
+@@ -100,60 +96,20 @@ static int copy_fp_from_sigcontext(struct sigcontext __user *sc)
+ }
+ 
+ /*
+- * These functions will save only the upper 64 bits of the vector registers,
+- * since the lower 64 bits have already been saved as the scalar FP context.
+- */
+-static int copy_msa_to_sigcontext(struct sigcontext __user *sc)
+-{
+-	int i;
+-	int err = 0;
+-
+-	for (i = 0; i < NUM_FPU_REGS; i++) {
+-		err |=
+-		    __put_user(get_fpr64(&current->thread.fpu.fpr[i], 1),
+-			       &sc->sc_msaregs[i]);
+-	}
+-	err |= __put_user(current->thread.fpu.msacsr, &sc->sc_msa_csr);
+-
+-	return err;
+-}
+-
+-static int copy_msa_from_sigcontext(struct sigcontext __user *sc)
+-{
+-	int i;
+-	int err = 0;
+-	u64 val;
+-
+-	for (i = 0; i < NUM_FPU_REGS; i++) {
+-		err |= __get_user(val, &sc->sc_msaregs[i]);
+-		set_fpr64(&current->thread.fpu.fpr[i], 1, val);
+-	}
+-	err |= __get_user(current->thread.fpu.msacsr, &sc->sc_msa_csr);
+-
+-	return err;
+-}
+-
+-/*
+  * Helper routines
+  */
+-static int protected_save_fp_context(struct sigcontext __user *sc,
+-				     unsigned used_math)
++static int protected_save_fp_context(struct sigcontext __user *sc)
+ {
+ 	int err;
+-	bool save_msa = cpu_has_msa && (used_math & USEDMATH_MSA);
+ #ifndef CONFIG_EVA
+ 	while (1) {
+ 		lock_fpu_owner();
+ 		if (is_fpu_owner()) {
+ 			err = save_fp_context(sc);
+-			if (save_msa && !err)
+-				err = _save_msa_context(sc);
+ 			unlock_fpu_owner();
+ 		} else {
+ 			unlock_fpu_owner();
+ 			err = copy_fp_to_sigcontext(sc);
+-			if (save_msa && !err)
+-				err = copy_msa_to_sigcontext(sc);
+ 		}
+ 		if (likely(!err))
+ 			break;
+@@ -169,38 +125,24 @@ static int protected_save_fp_context(struct sigcontext __user *sc,
+ 	 * EVA does not have FPU EVA instructions so saving fpu context directly
+ 	 * does not work.
+ 	 */
+-	disable_msa();
+ 	lose_fpu(1);
+ 	err = save_fp_context(sc); /* this might fail */
+-	if (save_msa && !err)
+-		err = copy_msa_to_sigcontext(sc);
+ #endif
+ 	return err;
+ }
+ 
+-static int protected_restore_fp_context(struct sigcontext __user *sc,
+-					unsigned used_math)
++static int protected_restore_fp_context(struct sigcontext __user *sc)
+ {
+ 	int err, tmp __maybe_unused;
+-	bool restore_msa = cpu_has_msa && (used_math & USEDMATH_MSA);
+ #ifndef CONFIG_EVA
+ 	while (1) {
+ 		lock_fpu_owner();
+ 		if (is_fpu_owner()) {
+ 			err = restore_fp_context(sc);
+-			if (restore_msa && !err) {
+-				enable_msa();
+-				err = _restore_msa_context(sc);
+-			} else {
+-				/* signal handler may have used MSA */
+-				disable_msa();
+-			}
+ 			unlock_fpu_owner();
+ 		} else {
+ 			unlock_fpu_owner();
+ 			err = copy_fp_from_sigcontext(sc);
+-			if (!err && (used_math & USEDMATH_MSA))
+-				err = copy_msa_from_sigcontext(sc);
+ 		}
+ 		if (likely(!err))
+ 			break;
+@@ -216,11 +158,8 @@ static int protected_restore_fp_context(struct sigcontext __user *sc,
+ 	 * EVA does not have FPU EVA instructions so restoring fpu context
+ 	 * directly does not work.
+ 	 */
+-	enable_msa();
+ 	lose_fpu(0);
+ 	err = restore_fp_context(sc); /* this might fail */
+-	if (restore_msa && !err)
+-		err = copy_msa_from_sigcontext(sc);
+ #endif
+ 	return err;
+ }
+@@ -252,8 +191,7 @@ int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
+ 		err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
+ 	}
+ 
+-	used_math = used_math() ? USEDMATH_FP : 0;
+-	used_math |= thread_msa_context_live() ? USEDMATH_MSA : 0;
++	used_math = !!used_math();
+ 	err |= __put_user(used_math, &sc->sc_used_math);
+ 
+ 	if (used_math) {
+@@ -261,7 +199,7 @@ int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
+ 		 * Save FPU state to signal context. Signal handler
+ 		 * will "inherit" current FPU state.
+ 		 */
+-		err |= protected_save_fp_context(sc, used_math);
++		err |= protected_save_fp_context(sc);
+ 	}
+ 	return err;
+ }
+@@ -286,14 +224,14 @@ int fpcsr_pending(unsigned int __user *fpcsr)
+ }
+ 
+ static int
+-check_and_restore_fp_context(struct sigcontext __user *sc, unsigned used_math)
++check_and_restore_fp_context(struct sigcontext __user *sc)
+ {
+ 	int err, sig;
+ 
+ 	err = sig = fpcsr_pending(&sc->sc_fpc_csr);
+ 	if (err > 0)
+ 		err = 0;
+-	err |= protected_restore_fp_context(sc, used_math);
++	err |= protected_restore_fp_context(sc);
+ 	return err ?: sig;
+ }
+ 
+@@ -333,10 +271,9 @@ int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
+ 	if (used_math) {
+ 		/* restore fpu context if we have used it before */
+ 		if (!err)
+-			err = check_and_restore_fp_context(sc, used_math);
++			err = check_and_restore_fp_context(sc);
+ 	} else {
+-		/* signal handler may have used FPU or MSA. Disable them. */
+-		disable_msa();
++		/* signal handler may have used FPU.  Give it up. */
+ 		lose_fpu(0);
+ 	}
+ 
+diff --git a/arch/mips/kernel/signal32.c b/arch/mips/kernel/signal32.c
+index 299f956e4db3..bae2e6ee2109 100644
+--- a/arch/mips/kernel/signal32.c
++++ b/arch/mips/kernel/signal32.c
+@@ -30,7 +30,6 @@
+ #include <asm/sim.h>
+ #include <asm/ucontext.h>
+ #include <asm/fpu.h>
+-#include <asm/msa.h>
+ #include <asm/war.h>
+ #include <asm/vdso.h>
+ #include <asm/dsp.h>
+@@ -43,9 +42,6 @@ static int (*restore_fp_context32)(struct sigcontext32 __user *sc);
+ extern asmlinkage int _save_fp_context32(struct sigcontext32 __user *sc);
+ extern asmlinkage int _restore_fp_context32(struct sigcontext32 __user *sc);
+ 
+-extern asmlinkage int _save_msa_context32(struct sigcontext32 __user *sc);
+-extern asmlinkage int _restore_msa_context32(struct sigcontext32 __user *sc);
+-
+ /*
+  * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
+  */
+@@ -115,59 +111,19 @@ static int copy_fp_from_sigcontext32(struct sigcontext32 __user *sc)
+ }
+ 
+ /*
+- * These functions will save only the upper 64 bits of the vector registers,
+- * since the lower 64 bits have already been saved as the scalar FP context.
+- */
+-static int copy_msa_to_sigcontext32(struct sigcontext32 __user *sc)
+-{
+-	int i;
+-	int err = 0;
+-
+-	for (i = 0; i < NUM_FPU_REGS; i++) {
+-		err |=
+-		    __put_user(get_fpr64(&current->thread.fpu.fpr[i], 1),
+-			       &sc->sc_msaregs[i]);
+-	}
+-	err |= __put_user(current->thread.fpu.msacsr, &sc->sc_msa_csr);
+-
+-	return err;
+-}
+-
+-static int copy_msa_from_sigcontext32(struct sigcontext32 __user *sc)
+-{
+-	int i;
+-	int err = 0;
+-	u64 val;
+-
+-	for (i = 0; i < NUM_FPU_REGS; i++) {
+-		err |= __get_user(val, &sc->sc_msaregs[i]);
+-		set_fpr64(&current->thread.fpu.fpr[i], 1, val);
+-	}
+-	err |= __get_user(current->thread.fpu.msacsr, &sc->sc_msa_csr);
+-
+-	return err;
+-}
+-
+-/*
+  * sigcontext handlers
+  */
+-static int protected_save_fp_context32(struct sigcontext32 __user *sc,
+-				       unsigned used_math)
++static int protected_save_fp_context32(struct sigcontext32 __user *sc)
+ {
+ 	int err;
+-	bool save_msa = cpu_has_msa && (used_math & USEDMATH_MSA);
+ 	while (1) {
+ 		lock_fpu_owner();
+ 		if (is_fpu_owner()) {
+ 			err = save_fp_context32(sc);
+-			if (save_msa && !err)
+-				err = _save_msa_context32(sc);
+ 			unlock_fpu_owner();
+ 		} else {
+ 			unlock_fpu_owner();
+ 			err = copy_fp_to_sigcontext32(sc);
+-			if (save_msa && !err)
+-				err = copy_msa_to_sigcontext32(sc);
+ 		}
+ 		if (likely(!err))
+ 			break;
+@@ -181,28 +137,17 @@ static int protected_save_fp_context32(struct sigcontext32 __user *sc,
+ 	return err;
+ }
+ 
+-static int protected_restore_fp_context32(struct sigcontext32 __user *sc,
+-					  unsigned used_math)
++static int protected_restore_fp_context32(struct sigcontext32 __user *sc)
+ {
+ 	int err, tmp __maybe_unused;
+-	bool restore_msa = cpu_has_msa && (used_math & USEDMATH_MSA);
+ 	while (1) {
+ 		lock_fpu_owner();
+ 		if (is_fpu_owner()) {
+ 			err = restore_fp_context32(sc);
+-			if (restore_msa && !err) {
+-				enable_msa();
+-				err = _restore_msa_context32(sc);
+-			} else {
+-				/* signal handler may have used MSA */
+-				disable_msa();
+-			}
+ 			unlock_fpu_owner();
+ 		} else {
+ 			unlock_fpu_owner();
+ 			err = copy_fp_from_sigcontext32(sc);
+-			if (restore_msa && !err)
+-				err = copy_msa_from_sigcontext32(sc);
+ 		}
+ 		if (likely(!err))
+ 			break;
+@@ -241,8 +186,7 @@ static int setup_sigcontext32(struct pt_regs *regs,
+ 		err |= __put_user(mflo3(), &sc->sc_lo3);
+ 	}
+ 
+-	used_math = used_math() ? USEDMATH_FP : 0;
+-	used_math |= thread_msa_context_live() ? USEDMATH_MSA : 0;
++	used_math = !!used_math();
+ 	err |= __put_user(used_math, &sc->sc_used_math);
+ 
+ 	if (used_math) {
+@@ -250,21 +194,20 @@ static int setup_sigcontext32(struct pt_regs *regs,
+ 		 * Save FPU state to signal context.  Signal handler
+ 		 * will "inherit" current FPU state.
+ 		 */
+-		err |= protected_save_fp_context32(sc, used_math);
++		err |= protected_save_fp_context32(sc);
+ 	}
+ 	return err;
+ }
+ 
+ static int
+-check_and_restore_fp_context32(struct sigcontext32 __user *sc,
+-			       unsigned used_math)
++check_and_restore_fp_context32(struct sigcontext32 __user *sc)
+ {
+ 	int err, sig;
+ 
+ 	err = sig = fpcsr_pending(&sc->sc_fpc_csr);
+ 	if (err > 0)
+ 		err = 0;
+-	err |= protected_restore_fp_context32(sc, used_math);
++	err |= protected_restore_fp_context32(sc);
+ 	return err ?: sig;
+ }
+ 
+@@ -301,10 +244,9 @@ static int restore_sigcontext32(struct pt_regs *regs,
+ 	if (used_math) {
+ 		/* restore fpu context if we have used it before */
+ 		if (!err)
+-			err = check_and_restore_fp_context32(sc, used_math);
++			err = check_and_restore_fp_context32(sc);
+ 	} else {
+-		/* signal handler may have used FPU or MSA. Disable them. */
+-		disable_msa();
++		/* signal handler may have used FPU.  Give it up. */
+ 		lose_fpu(0);
+ 	}
+ 
+diff --git a/arch/mips/kvm/kvm_mips.c b/arch/mips/kvm/kvm_mips.c
+index 5efce56f0df0..3e0ff8d0fbf9 100644
+--- a/arch/mips/kvm/kvm_mips.c
++++ b/arch/mips/kvm/kvm_mips.c
+@@ -149,9 +149,7 @@ void kvm_mips_free_vcpus(struct kvm *kvm)
+ 		if (kvm->arch.guest_pmap[i] != KVM_INVALID_PAGE)
+ 			kvm_mips_release_pfn_clean(kvm->arch.guest_pmap[i]);
+ 	}
+-
+-	if (kvm->arch.guest_pmap)
+-		kfree(kvm->arch.guest_pmap);
++	kfree(kvm->arch.guest_pmap);
+ 
+ 	kvm_for_each_vcpu(i, vcpu, kvm) {
+ 		kvm_arch_vcpu_free(vcpu);
+@@ -389,12 +387,9 @@ void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
+ 
+ 	kvm_mips_dump_stats(vcpu);
+ 
+-	if (vcpu->arch.guest_ebase)
+-		kfree(vcpu->arch.guest_ebase);
+-
+-	if (vcpu->arch.kseg0_commpage)
+-		kfree(vcpu->arch.kseg0_commpage);
+-
++	kfree(vcpu->arch.guest_ebase);
++	kfree(vcpu->arch.kseg0_commpage);
++	kfree(vcpu);
+ }
+ 
+ void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
+diff --git a/arch/powerpc/include/asm/switch_to.h b/arch/powerpc/include/asm/switch_to.h
+index 0e83e7d8c73f..b5fad8afe837 100644
+--- a/arch/powerpc/include/asm/switch_to.h
++++ b/arch/powerpc/include/asm/switch_to.h
+@@ -84,6 +84,8 @@ static inline void clear_task_ebb(struct task_struct *t)
+ {
+ #ifdef CONFIG_PPC_BOOK3S_64
+     /* EBB perf events are not inherited, so clear all EBB state. */
++    t->thread.ebbrr = 0;
++    t->thread.ebbhr = 0;
+     t->thread.bescr = 0;
+     t->thread.mmcr2 = 0;
+     t->thread.mmcr0 = 0;
+diff --git a/arch/powerpc/include/asm/systbl.h b/arch/powerpc/include/asm/systbl.h
+index ea4dc3a89c1f..14b2862533b5 100644
+--- a/arch/powerpc/include/asm/systbl.h
++++ b/arch/powerpc/include/asm/systbl.h
+@@ -190,7 +190,7 @@ SYSCALL_SPU(getcwd)
+ SYSCALL_SPU(capget)
+ SYSCALL_SPU(capset)
+ COMPAT_SYS(sigaltstack)
+-COMPAT_SYS_SPU(sendfile)
++SYSX_SPU(sys_sendfile64,compat_sys_sendfile,sys_sendfile)
+ SYSCALL(ni_syscall)
+ SYSCALL(ni_syscall)
+ PPC_SYS(vfork)
+diff --git a/arch/powerpc/include/uapi/asm/cputable.h b/arch/powerpc/include/uapi/asm/cputable.h
+index 5b7657959faa..de2c0e4ee1aa 100644
+--- a/arch/powerpc/include/uapi/asm/cputable.h
++++ b/arch/powerpc/include/uapi/asm/cputable.h
+@@ -41,5 +41,6 @@
+ #define PPC_FEATURE2_EBB		0x10000000
+ #define PPC_FEATURE2_ISEL		0x08000000
+ #define PPC_FEATURE2_TAR		0x04000000
++#define PPC_FEATURE2_VEC_CRYPTO		0x02000000
+ 
+ #endif /* _UAPI__ASM_POWERPC_CPUTABLE_H */
+diff --git a/arch/powerpc/kernel/cputable.c b/arch/powerpc/kernel/cputable.c
+index c1faade6506d..11da04a4625a 100644
+--- a/arch/powerpc/kernel/cputable.c
++++ b/arch/powerpc/kernel/cputable.c
+@@ -109,7 +109,8 @@ extern void __restore_cpu_e6500(void);
+ 				 PPC_FEATURE_PSERIES_PERFMON_COMPAT)
+ #define COMMON_USER2_POWER8	(PPC_FEATURE2_ARCH_2_07 | \
+ 				 PPC_FEATURE2_HTM_COMP | PPC_FEATURE2_DSCR | \
+-				 PPC_FEATURE2_ISEL | PPC_FEATURE2_TAR)
++				 PPC_FEATURE2_ISEL | PPC_FEATURE2_TAR | \
++				 PPC_FEATURE2_VEC_CRYPTO)
+ #define COMMON_USER_PA6T	(COMMON_USER_PPC64 | PPC_FEATURE_PA6T |\
+ 				 PPC_FEATURE_TRUE_LE | \
+ 				 PPC_FEATURE_HAS_ALTIVEC_COMP)
+diff --git a/arch/powerpc/kernel/legacy_serial.c b/arch/powerpc/kernel/legacy_serial.c
+index 40bd7bd4e19a..8a8b722870a1 100644
+--- a/arch/powerpc/kernel/legacy_serial.c
++++ b/arch/powerpc/kernel/legacy_serial.c
+@@ -48,6 +48,9 @@ static struct of_device_id legacy_serial_parents[] __initdata = {
+ static unsigned int legacy_serial_count;
+ static int legacy_serial_console = -1;
+ 
++static const upf_t legacy_port_flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST |
++	UPF_SHARE_IRQ | UPF_FIXED_PORT;
++
+ static unsigned int tsi_serial_in(struct uart_port *p, int offset)
+ {
+ 	unsigned int tmp;
+@@ -153,8 +156,6 @@ static int __init add_legacy_soc_port(struct device_node *np,
+ {
+ 	u64 addr;
+ 	const __be32 *addrp;
+-	upf_t flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ
+-		| UPF_FIXED_PORT;
+ 	struct device_node *tsi = of_get_parent(np);
+ 
+ 	/* We only support ports that have a clock frequency properly
+@@ -185,9 +186,11 @@ static int __init add_legacy_soc_port(struct device_node *np,
+ 	 * IO port value. It will be fixed up later along with the irq
+ 	 */
+ 	if (tsi && !strcmp(tsi->type, "tsi-bridge"))
+-		return add_legacy_port(np, -1, UPIO_TSI, addr, addr, NO_IRQ, flags, 0);
++		return add_legacy_port(np, -1, UPIO_TSI, addr, addr,
++				       NO_IRQ, legacy_port_flags, 0);
+ 	else
+-		return add_legacy_port(np, -1, UPIO_MEM, addr, addr, NO_IRQ, flags, 0);
++		return add_legacy_port(np, -1, UPIO_MEM, addr, addr,
++				       NO_IRQ, legacy_port_flags, 0);
+ }
+ 
+ static int __init add_legacy_isa_port(struct device_node *np,
+@@ -233,7 +236,7 @@ static int __init add_legacy_isa_port(struct device_node *np,
+ 
+ 	/* Add port, irq will be dealt with later */
+ 	return add_legacy_port(np, index, UPIO_PORT, be32_to_cpu(reg[1]),
+-			       taddr, NO_IRQ, UPF_BOOT_AUTOCONF, 0);
++			       taddr, NO_IRQ, legacy_port_flags, 0);
+ 
+ }
+ 
+@@ -306,7 +309,7 @@ static int __init add_legacy_pci_port(struct device_node *np,
+ 	 * IO port value. It will be fixed up later along with the irq
+ 	 */
+ 	return add_legacy_port(np, index, iotype, base, addr, NO_IRQ,
+-			       UPF_BOOT_AUTOCONF, np != pci_dev);
++			       legacy_port_flags, np != pci_dev);
+ }
+ #endif
+ 
+diff --git a/arch/powerpc/kernel/setup-common.c b/arch/powerpc/kernel/setup-common.c
+index 79b7612ac6fa..aa3e7c0f60e2 100644
+--- a/arch/powerpc/kernel/setup-common.c
++++ b/arch/powerpc/kernel/setup-common.c
+@@ -459,9 +459,17 @@ void __init smp_setup_cpu_maps(void)
+ 		}
+ 
+ 		for (j = 0; j < nthreads && cpu < nr_cpu_ids; j++) {
++			bool avail;
++
+ 			DBG("    thread %d -> cpu %d (hard id %d)\n",
+ 			    j, cpu, be32_to_cpu(intserv[j]));
+-			set_cpu_present(cpu, true);
++
++			avail = of_device_is_available(dn);
++			if (!avail)
++				avail = !of_property_match_string(dn,
++						"enable-method", "spin-table");
++
++			set_cpu_present(cpu, avail);
+ 			set_hard_smp_processor_id(cpu, be32_to_cpu(intserv[j]));
+ 			set_cpu_possible(cpu, true);
+ 			cpu++;
+diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
+index 7e711bdcc6da..9fff9cdcc519 100644
+--- a/arch/powerpc/kernel/time.c
++++ b/arch/powerpc/kernel/time.c
+@@ -551,7 +551,7 @@ void timer_interrupt(struct pt_regs * regs)
+ 	may_hard_irq_enable();
+ 
+ 
+-#if defined(CONFIG_PPC32) && defined(CONFIG_PMAC)
++#if defined(CONFIG_PPC32) && defined(CONFIG_PPC_PMAC)
+ 	if (atomic_read(&ppc_n_lost_interrupts) != 0)
+ 		do_IRQ(regs);
+ #endif
+diff --git a/arch/powerpc/lib/sstep.c b/arch/powerpc/lib/sstep.c
+index c0511c27a733..412dd46dd0b7 100644
+--- a/arch/powerpc/lib/sstep.c
++++ b/arch/powerpc/lib/sstep.c
+@@ -1470,7 +1470,7 @@ int __kprobes emulate_step(struct pt_regs *regs, unsigned int instr)
+ 				regs->gpr[rd] = byterev_4(val);
+ 			goto ldst_done;
+ 
+-#ifdef CONFIG_PPC_CPU
++#ifdef CONFIG_PPC_FPU
+ 		case 535:	/* lfsx */
+ 		case 567:	/* lfsux */
+ 			if (!(regs->msr & MSR_FP))
+diff --git a/arch/powerpc/mm/hash_utils_64.c b/arch/powerpc/mm/hash_utils_64.c
+index 06ba83b036d3..5cbfde131839 100644
+--- a/arch/powerpc/mm/hash_utils_64.c
++++ b/arch/powerpc/mm/hash_utils_64.c
+@@ -964,6 +964,22 @@ void hash_failure_debug(unsigned long ea, unsigned long access,
+ 		trap, vsid, ssize, psize, lpsize, pte);
+ }
+ 
++static void check_paca_psize(unsigned long ea, struct mm_struct *mm,
++			     int psize, bool user_region)
++{
++	if (user_region) {
++		if (psize != get_paca_psize(ea)) {
++			get_paca()->context = mm->context;
++			slb_flush_and_rebolt();
++		}
++	} else if (get_paca()->vmalloc_sllp !=
++		   mmu_psize_defs[mmu_vmalloc_psize].sllp) {
++		get_paca()->vmalloc_sllp =
++			mmu_psize_defs[mmu_vmalloc_psize].sllp;
++		slb_vmalloc_update();
++	}
++}
++
+ /* Result code is:
+  *  0 - handled
+  *  1 - normal page fault
+@@ -1085,6 +1101,8 @@ int hash_page(unsigned long ea, unsigned long access, unsigned long trap)
+ 			WARN_ON(1);
+ 		}
+ #endif
++		check_paca_psize(ea, mm, psize, user_region);
++
+ 		goto bail;
+ 	}
+ 
+@@ -1125,17 +1143,8 @@ int hash_page(unsigned long ea, unsigned long access, unsigned long trap)
+ #endif
+ 		}
+ 	}
+-	if (user_region) {
+-		if (psize != get_paca_psize(ea)) {
+-			get_paca()->context = mm->context;
+-			slb_flush_and_rebolt();
+-		}
+-	} else if (get_paca()->vmalloc_sllp !=
+-		   mmu_psize_defs[mmu_vmalloc_psize].sllp) {
+-		get_paca()->vmalloc_sllp =
+-			mmu_psize_defs[mmu_vmalloc_psize].sllp;
+-		slb_vmalloc_update();
+-	}
++
++	check_paca_psize(ea, mm, psize, user_region);
+ #endif /* CONFIG_PPC_64K_PAGES */
+ 
+ #ifdef CONFIG_PPC_HAS_HASH_64K
+diff --git a/arch/powerpc/platforms/powernv/opal-sysparam.c b/arch/powerpc/platforms/powernv/opal-sysparam.c
+index d202f9bc3683..9d1acf22a099 100644
+--- a/arch/powerpc/platforms/powernv/opal-sysparam.c
++++ b/arch/powerpc/platforms/powernv/opal-sysparam.c
+@@ -260,10 +260,10 @@ void __init opal_sys_param_init(void)
+ 			attr[i].kobj_attr.attr.mode = S_IRUGO;
+ 			break;
+ 		case OPAL_SYSPARAM_WRITE:
+-			attr[i].kobj_attr.attr.mode = S_IWUGO;
++			attr[i].kobj_attr.attr.mode = S_IWUSR;
+ 			break;
+ 		case OPAL_SYSPARAM_RW:
+-			attr[i].kobj_attr.attr.mode = S_IRUGO | S_IWUGO;
++			attr[i].kobj_attr.attr.mode = S_IRUGO | S_IWUSR;
+ 			break;
+ 		default:
+ 			break;
+diff --git a/arch/powerpc/platforms/pseries/eeh_pseries.c b/arch/powerpc/platforms/pseries/eeh_pseries.c
+index 8a8f0472d98f..83da53fde6b5 100644
+--- a/arch/powerpc/platforms/pseries/eeh_pseries.c
++++ b/arch/powerpc/platforms/pseries/eeh_pseries.c
+@@ -464,6 +464,7 @@ static int pseries_eeh_get_state(struct eeh_pe *pe, int *state)
+ 			} else {
+ 				result = EEH_STATE_NOT_SUPPORT;
+ 			}
++			break;
+ 		default:
+ 			result = EEH_STATE_NOT_SUPPORT;
+ 		}
+diff --git a/arch/x86/include/asm/ptrace.h b/arch/x86/include/asm/ptrace.h
+index 14fd6fd75a19..6205f0c434db 100644
+--- a/arch/x86/include/asm/ptrace.h
++++ b/arch/x86/include/asm/ptrace.h
+@@ -231,6 +231,22 @@ static inline unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
+ 
+ #define ARCH_HAS_USER_SINGLE_STEP_INFO
+ 
++/*
++ * When hitting ptrace_stop(), we cannot return using SYSRET because
++ * that does not restore the full CPU state, only a minimal set.  The
++ * ptracer can change arbitrary register values, which is usually okay
++ * because the usual ptrace stops run off the signal delivery path which
++ * forces IRET; however, ptrace_event() stops happen in arbitrary places
++ * in the kernel and don't force IRET path.
++ *
++ * So force IRET path after a ptrace stop.
++ */
++#define arch_ptrace_stop_needed(code, info)				\
++({									\
++	set_thread_flag(TIF_NOTIFY_RESUME);				\
++	false;								\
++})
++
+ struct user_desc;
+ extern int do_get_thread_area(struct task_struct *p, int idx,
+ 			      struct user_desc __user *info);
+diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
+index 59c5abe32f06..fb624469d0ee 100644
+--- a/drivers/block/mtip32xx/mtip32xx.c
++++ b/drivers/block/mtip32xx/mtip32xx.c
+@@ -1529,6 +1529,37 @@ static inline void ata_swap_string(u16 *buf, unsigned int len)
+ 		be16_to_cpus(&buf[i]);
+ }
+ 
++static void mtip_set_timeout(struct driver_data *dd,
++					struct host_to_dev_fis *fis,
++					unsigned int *timeout, u8 erasemode)
++{
++	switch (fis->command) {
++	case ATA_CMD_DOWNLOAD_MICRO:
++		*timeout = 120000; /* 2 minutes */
++		break;
++	case ATA_CMD_SEC_ERASE_UNIT:
++	case 0xFC:
++		if (erasemode)
++			*timeout = ((*(dd->port->identify + 90) * 2) * 60000);
++		else
++			*timeout = ((*(dd->port->identify + 89) * 2) * 60000);
++		break;
++	case ATA_CMD_STANDBYNOW1:
++		*timeout = 120000;  /* 2 minutes */
++		break;
++	case 0xF7:
++	case 0xFA:
++		*timeout = 60000;  /* 60 seconds */
++		break;
++	case ATA_CMD_SMART:
++		*timeout = 15000;  /* 15 seconds */
++		break;
++	default:
++		*timeout = MTIP_IOCTL_COMMAND_TIMEOUT_MS;
++		break;
++	}
++}
++
+ /*
+  * Request the device identity information.
+  *
+@@ -1644,6 +1675,7 @@ static int mtip_standby_immediate(struct mtip_port *port)
+ 	int rv;
+ 	struct host_to_dev_fis	fis;
+ 	unsigned long start;
++	unsigned int timeout;
+ 
+ 	/* Build the FIS. */
+ 	memset(&fis, 0, sizeof(struct host_to_dev_fis));
+@@ -1651,6 +1683,8 @@ static int mtip_standby_immediate(struct mtip_port *port)
+ 	fis.opts	= 1 << 7;
+ 	fis.command	= ATA_CMD_STANDBYNOW1;
+ 
++	mtip_set_timeout(port->dd, &fis, &timeout, 0);
++
+ 	start = jiffies;
+ 	rv = mtip_exec_internal_command(port,
+ 					&fis,
+@@ -1659,7 +1693,7 @@ static int mtip_standby_immediate(struct mtip_port *port)
+ 					0,
+ 					0,
+ 					GFP_ATOMIC,
+-					15000);
++					timeout);
+ 	dbg_printk(MTIP_DRV_NAME "Time taken to complete standby cmd: %d ms\n",
+ 			jiffies_to_msecs(jiffies - start));
+ 	if (rv)
+@@ -2202,36 +2236,6 @@ static unsigned int implicit_sector(unsigned char command,
+ 	}
+ 	return rv;
+ }
+-static void mtip_set_timeout(struct driver_data *dd,
+-					struct host_to_dev_fis *fis,
+-					unsigned int *timeout, u8 erasemode)
+-{
+-	switch (fis->command) {
+-	case ATA_CMD_DOWNLOAD_MICRO:
+-		*timeout = 120000; /* 2 minutes */
+-		break;
+-	case ATA_CMD_SEC_ERASE_UNIT:
+-	case 0xFC:
+-		if (erasemode)
+-			*timeout = ((*(dd->port->identify + 90) * 2) * 60000);
+-		else
+-			*timeout = ((*(dd->port->identify + 89) * 2) * 60000);
+-		break;
+-	case ATA_CMD_STANDBYNOW1:
+-		*timeout = 120000;  /* 2 minutes */
+-		break;
+-	case 0xF7:
+-	case 0xFA:
+-		*timeout = 60000;  /* 60 seconds */
+-		break;
+-	case ATA_CMD_SMART:
+-		*timeout = 15000;  /* 15 seconds */
+-		break;
+-	default:
+-		*timeout = MTIP_IOCTL_COMMAND_TIMEOUT_MS;
+-		break;
+-	}
+-}
+ 
+ /*
+  * Executes a taskfile
+@@ -4479,6 +4483,57 @@ static DEFINE_HANDLER(5);
+ static DEFINE_HANDLER(6);
+ static DEFINE_HANDLER(7);
+ 
++static void mtip_disable_link_opts(struct driver_data *dd, struct pci_dev *pdev)
++{
++	int pos;
++	unsigned short pcie_dev_ctrl;
++
++	pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
++	if (pos) {
++		pci_read_config_word(pdev,
++			pos + PCI_EXP_DEVCTL,
++			&pcie_dev_ctrl);
++		if (pcie_dev_ctrl & (1 << 11) ||
++		    pcie_dev_ctrl & (1 << 4)) {
++			dev_info(&dd->pdev->dev,
++				"Disabling ERO/No-Snoop on bridge device %04x:%04x\n",
++					pdev->vendor, pdev->device);
++			pcie_dev_ctrl &= ~(PCI_EXP_DEVCTL_NOSNOOP_EN |
++						PCI_EXP_DEVCTL_RELAX_EN);
++			pci_write_config_word(pdev,
++				pos + PCI_EXP_DEVCTL,
++				pcie_dev_ctrl);
++		}
++	}
++}
++
++static void mtip_fix_ero_nosnoop(struct driver_data *dd, struct pci_dev *pdev)
++{
++	/*
++	 * This workaround is specific to AMD/ATI chipset with a PCI upstream
++	 * device with device id 0x5aXX
++	 */
++	if (pdev->bus && pdev->bus->self) {
++		if (pdev->bus->self->vendor == PCI_VENDOR_ID_ATI &&
++		    ((pdev->bus->self->device & 0xff00) == 0x5a00)) {
++			mtip_disable_link_opts(dd, pdev->bus->self);
++		} else {
++			/* Check further up the topology */
++			struct pci_dev *parent_dev = pdev->bus->self;
++			if (parent_dev->bus &&
++				parent_dev->bus->parent &&
++				parent_dev->bus->parent->self &&
++				parent_dev->bus->parent->self->vendor ==
++					 PCI_VENDOR_ID_ATI &&
++				(parent_dev->bus->parent->self->device &
++					0xff00) == 0x5a00) {
++				mtip_disable_link_opts(dd,
++					parent_dev->bus->parent->self);
++			}
++		}
++	}
++}
++
+ /*
+  * Called for each supported PCI device detected.
+  *
+@@ -4630,6 +4685,8 @@ static int mtip_pci_probe(struct pci_dev *pdev,
+ 		goto msi_initialize_err;
+ 	}
+ 
++	mtip_fix_ero_nosnoop(dd, pdev);
++
+ 	/* Initialize the block layer. */
+ 	rv = mtip_block_initialize(dd);
+ 	if (rv < 0) {
+@@ -4935,13 +4992,13 @@ static int __init mtip_init(void)
+  */
+ static void __exit mtip_exit(void)
+ {
+-	debugfs_remove_recursive(dfs_parent);
+-
+ 	/* Release the allocated major block device number. */
+ 	unregister_blkdev(mtip_major, MTIP_DRV_NAME);
+ 
+ 	/* Unregister the PCI driver. */
+ 	pci_unregister_driver(&mtip_pci_driver);
++
++	debugfs_remove_recursive(dfs_parent);
+ }
+ 
+ MODULE_AUTHOR("Micron Technology, Inc");
+diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
+index abda6609d3e7..558224cf55bf 100644
+--- a/drivers/cpufreq/cpufreq.c
++++ b/drivers/cpufreq/cpufreq.c
+@@ -2166,10 +2166,8 @@ int cpufreq_update_policy(unsigned int cpu)
+ 	struct cpufreq_policy new_policy;
+ 	int ret;
+ 
+-	if (!policy) {
+-		ret = -ENODEV;
+-		goto no_policy;
+-	}
++	if (!policy)
++		return -ENODEV;
+ 
+ 	down_write(&policy->rwsem);
+ 
+@@ -2188,7 +2186,7 @@ int cpufreq_update_policy(unsigned int cpu)
+ 		new_policy.cur = cpufreq_driver->get(cpu);
+ 		if (WARN_ON(!new_policy.cur)) {
+ 			ret = -EIO;
+-			goto no_policy;
++			goto unlock;
+ 		}
+ 
+ 		if (!policy->cur) {
+@@ -2203,10 +2201,10 @@ int cpufreq_update_policy(unsigned int cpu)
+ 
+ 	ret = cpufreq_set_policy(policy, &new_policy);
+ 
++unlock:
+ 	up_write(&policy->rwsem);
+ 
+ 	cpufreq_cpu_put(policy);
+-no_policy:
+ 	return ret;
+ }
+ EXPORT_SYMBOL(cpufreq_update_policy);
+diff --git a/drivers/cpufreq/ppc-corenet-cpufreq.c b/drivers/cpufreq/ppc-corenet-cpufreq.c
+index 0af618abebaf..3607070797af 100644
+--- a/drivers/cpufreq/ppc-corenet-cpufreq.c
++++ b/drivers/cpufreq/ppc-corenet-cpufreq.c
+@@ -138,7 +138,7 @@ static int corenet_cpufreq_cpu_init(struct cpufreq_policy *policy)
+ 	struct cpufreq_frequency_table *table;
+ 	struct cpu_data *data;
+ 	unsigned int cpu = policy->cpu;
+-	u64 transition_latency_hz;
++	u64 u64temp;
+ 
+ 	np = of_get_cpu_node(cpu, NULL);
+ 	if (!np)
+@@ -206,9 +206,10 @@ static int corenet_cpufreq_cpu_init(struct cpufreq_policy *policy)
+ 	for_each_cpu(i, per_cpu(cpu_mask, cpu))
+ 		per_cpu(cpu_data, i) = data;
+ 
+-	transition_latency_hz = 12ULL * NSEC_PER_SEC;
+-	policy->cpuinfo.transition_latency =
+-		do_div(transition_latency_hz, fsl_get_sys_freq());
++	/* Minimum transition latency is 12 platform clocks */
++	u64temp = 12ULL * NSEC_PER_SEC;
++	do_div(u64temp, fsl_get_sys_freq());
++	policy->cpuinfo.transition_latency = u64temp + 1;
+ 
+ 	of_node_put(np);
+ 
+diff --git a/drivers/infiniband/core/user_mad.c b/drivers/infiniband/core/user_mad.c
+index f0d588f8859e..1acb99100556 100644
+--- a/drivers/infiniband/core/user_mad.c
++++ b/drivers/infiniband/core/user_mad.c
+@@ -98,7 +98,7 @@ struct ib_umad_port {
+ 
+ struct ib_umad_device {
+ 	int                  start_port, end_port;
+-	struct kref          ref;
++	struct kobject       kobj;
+ 	struct ib_umad_port  port[0];
+ };
+ 
+@@ -134,14 +134,18 @@ static DECLARE_BITMAP(dev_map, IB_UMAD_MAX_PORTS);
+ static void ib_umad_add_one(struct ib_device *device);
+ static void ib_umad_remove_one(struct ib_device *device);
+ 
+-static void ib_umad_release_dev(struct kref *ref)
++static void ib_umad_release_dev(struct kobject *kobj)
+ {
+ 	struct ib_umad_device *dev =
+-		container_of(ref, struct ib_umad_device, ref);
++		container_of(kobj, struct ib_umad_device, kobj);
+ 
+ 	kfree(dev);
+ }
+ 
++static struct kobj_type ib_umad_dev_ktype = {
++	.release = ib_umad_release_dev,
++};
++
+ static int hdr_size(struct ib_umad_file *file)
+ {
+ 	return file->use_pkey_index ? sizeof (struct ib_user_mad_hdr) :
+@@ -780,27 +784,19 @@ static int ib_umad_open(struct inode *inode, struct file *filp)
+ {
+ 	struct ib_umad_port *port;
+ 	struct ib_umad_file *file;
+-	int ret;
++	int ret = -ENXIO;
+ 
+ 	port = container_of(inode->i_cdev, struct ib_umad_port, cdev);
+-	if (port)
+-		kref_get(&port->umad_dev->ref);
+-	else
+-		return -ENXIO;
+ 
+ 	mutex_lock(&port->file_mutex);
+ 
+-	if (!port->ib_dev) {
+-		ret = -ENXIO;
++	if (!port->ib_dev)
+ 		goto out;
+-	}
+ 
++	ret = -ENOMEM;
+ 	file = kzalloc(sizeof *file, GFP_KERNEL);
+-	if (!file) {
+-		kref_put(&port->umad_dev->ref, ib_umad_release_dev);
+-		ret = -ENOMEM;
++	if (!file)
+ 		goto out;
+-	}
+ 
+ 	mutex_init(&file->mutex);
+ 	spin_lock_init(&file->send_lock);
+@@ -814,6 +810,13 @@ static int ib_umad_open(struct inode *inode, struct file *filp)
+ 	list_add_tail(&file->port_list, &port->file_list);
+ 
+ 	ret = nonseekable_open(inode, filp);
++	if (ret) {
++		list_del(&file->port_list);
++		kfree(file);
++		goto out;
++	}
++
++	kobject_get(&port->umad_dev->kobj);
+ 
+ out:
+ 	mutex_unlock(&port->file_mutex);
+@@ -852,7 +855,7 @@ static int ib_umad_close(struct inode *inode, struct file *filp)
+ 	mutex_unlock(&file->port->file_mutex);
+ 
+ 	kfree(file);
+-	kref_put(&dev->ref, ib_umad_release_dev);
++	kobject_put(&dev->kobj);
+ 
+ 	return 0;
+ }
+@@ -880,10 +883,6 @@ static int ib_umad_sm_open(struct inode *inode, struct file *filp)
+ 	int ret;
+ 
+ 	port = container_of(inode->i_cdev, struct ib_umad_port, sm_cdev);
+-	if (port)
+-		kref_get(&port->umad_dev->ref);
+-	else
+-		return -ENXIO;
+ 
+ 	if (filp->f_flags & O_NONBLOCK) {
+ 		if (down_trylock(&port->sm_sem)) {
+@@ -898,17 +897,27 @@ static int ib_umad_sm_open(struct inode *inode, struct file *filp)
+ 	}
+ 
+ 	ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
+-	if (ret) {
+-		up(&port->sm_sem);
+-		goto fail;
+-	}
++	if (ret)
++		goto err_up_sem;
+ 
+ 	filp->private_data = port;
+ 
+-	return nonseekable_open(inode, filp);
++	ret = nonseekable_open(inode, filp);
++	if (ret)
++		goto err_clr_sm_cap;
++
++	kobject_get(&port->umad_dev->kobj);
++
++	return 0;
++
++err_clr_sm_cap:
++	swap(props.set_port_cap_mask, props.clr_port_cap_mask);
++	ib_modify_port(port->ib_dev, port->port_num, 0, &props);
++
++err_up_sem:
++	up(&port->sm_sem);
+ 
+ fail:
+-	kref_put(&port->umad_dev->ref, ib_umad_release_dev);
+ 	return ret;
+ }
+ 
+@@ -927,7 +936,7 @@ static int ib_umad_sm_close(struct inode *inode, struct file *filp)
+ 
+ 	up(&port->sm_sem);
+ 
+-	kref_put(&port->umad_dev->ref, ib_umad_release_dev);
++	kobject_put(&port->umad_dev->kobj);
+ 
+ 	return ret;
+ }
+@@ -995,6 +1004,7 @@ static int find_overflow_devnum(void)
+ }
+ 
+ static int ib_umad_init_port(struct ib_device *device, int port_num,
++			     struct ib_umad_device *umad_dev,
+ 			     struct ib_umad_port *port)
+ {
+ 	int devnum;
+@@ -1027,6 +1037,7 @@ static int ib_umad_init_port(struct ib_device *device, int port_num,
+ 
+ 	cdev_init(&port->cdev, &umad_fops);
+ 	port->cdev.owner = THIS_MODULE;
++	port->cdev.kobj.parent = &umad_dev->kobj;
+ 	kobject_set_name(&port->cdev.kobj, "umad%d", port->dev_num);
+ 	if (cdev_add(&port->cdev, base, 1))
+ 		goto err_cdev;
+@@ -1045,6 +1056,7 @@ static int ib_umad_init_port(struct ib_device *device, int port_num,
+ 	base += IB_UMAD_MAX_PORTS;
+ 	cdev_init(&port->sm_cdev, &umad_sm_fops);
+ 	port->sm_cdev.owner = THIS_MODULE;
++	port->sm_cdev.kobj.parent = &umad_dev->kobj;
+ 	kobject_set_name(&port->sm_cdev.kobj, "issm%d", port->dev_num);
+ 	if (cdev_add(&port->sm_cdev, base, 1))
+ 		goto err_sm_cdev;
+@@ -1138,7 +1150,7 @@ static void ib_umad_add_one(struct ib_device *device)
+ 	if (!umad_dev)
+ 		return;
+ 
+-	kref_init(&umad_dev->ref);
++	kobject_init(&umad_dev->kobj, &ib_umad_dev_ktype);
+ 
+ 	umad_dev->start_port = s;
+ 	umad_dev->end_port   = e;
+@@ -1146,7 +1158,8 @@ static void ib_umad_add_one(struct ib_device *device)
+ 	for (i = s; i <= e; ++i) {
+ 		umad_dev->port[i - s].umad_dev = umad_dev;
+ 
+-		if (ib_umad_init_port(device, i, &umad_dev->port[i - s]))
++		if (ib_umad_init_port(device, i, umad_dev,
++				      &umad_dev->port[i - s]))
+ 			goto err;
+ 	}
+ 
+@@ -1158,7 +1171,7 @@ err:
+ 	while (--i >= s)
+ 		ib_umad_kill_port(&umad_dev->port[i - s]);
+ 
+-	kref_put(&umad_dev->ref, ib_umad_release_dev);
++	kobject_put(&umad_dev->kobj);
+ }
+ 
+ static void ib_umad_remove_one(struct ib_device *device)
+@@ -1172,7 +1185,7 @@ static void ib_umad_remove_one(struct ib_device *device)
+ 	for (i = 0; i <= umad_dev->end_port - umad_dev->start_port; ++i)
+ 		ib_umad_kill_port(&umad_dev->port[i]);
+ 
+-	kref_put(&umad_dev->ref, ib_umad_release_dev);
++	kobject_put(&umad_dev->kobj);
+ }
+ 
+ static char *umad_devnode(struct device *dev, umode_t *mode)
+diff --git a/drivers/infiniband/hw/cxgb4/cq.c b/drivers/infiniband/hw/cxgb4/cq.c
+index cfaa56ada189..7151a02b4ebb 100644
+--- a/drivers/infiniband/hw/cxgb4/cq.c
++++ b/drivers/infiniband/hw/cxgb4/cq.c
+@@ -940,7 +940,6 @@ struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
+ 		if (!mm2)
+ 			goto err4;
+ 
+-		memset(&uresp, 0, sizeof(uresp));
+ 		uresp.qid_mask = rhp->rdev.cqmask;
+ 		uresp.cqid = chp->cq.cqid;
+ 		uresp.size = chp->cq.size;
+@@ -951,7 +950,8 @@ struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
+ 		uresp.gts_key = ucontext->key;
+ 		ucontext->key += PAGE_SIZE;
+ 		spin_unlock(&ucontext->mmap_lock);
+-		ret = ib_copy_to_udata(udata, &uresp, sizeof uresp);
++		ret = ib_copy_to_udata(udata, &uresp,
++				       sizeof(uresp) - sizeof(uresp.reserved));
+ 		if (ret)
+ 			goto err5;
+ 
+diff --git a/drivers/infiniband/hw/cxgb4/device.c b/drivers/infiniband/hw/cxgb4/device.c
+index f4fa50a609e2..8914ea90ddd9 100644
+--- a/drivers/infiniband/hw/cxgb4/device.c
++++ b/drivers/infiniband/hw/cxgb4/device.c
+@@ -736,6 +736,7 @@ static struct c4iw_dev *c4iw_alloc(const struct cxgb4_lld_info *infop)
+ 			pci_resource_len(devp->rdev.lldi.pdev, 2));
+ 		if (!devp->rdev.bar2_kva) {
+ 			pr_err(MOD "Unable to ioremap BAR2\n");
++			ib_dealloc_device(&devp->ibdev);
+ 			return ERR_PTR(-EINVAL);
+ 		}
+ 	} else if (ocqp_supported(infop)) {
+@@ -747,6 +748,7 @@ static struct c4iw_dev *c4iw_alloc(const struct cxgb4_lld_info *infop)
+ 			devp->rdev.lldi.vr->ocq.size);
+ 		if (!devp->rdev.oc_mw_kva) {
+ 			pr_err(MOD "Unable to ioremap onchip mem\n");
++			ib_dealloc_device(&devp->ibdev);
+ 			return ERR_PTR(-EINVAL);
+ 		}
+ 	}
+diff --git a/drivers/infiniband/hw/cxgb4/provider.c b/drivers/infiniband/hw/cxgb4/provider.c
+index a94a3e12c349..c777e22bd8d5 100644
+--- a/drivers/infiniband/hw/cxgb4/provider.c
++++ b/drivers/infiniband/hw/cxgb4/provider.c
+@@ -122,7 +122,7 @@ static struct ib_ucontext *c4iw_alloc_ucontext(struct ib_device *ibdev,
+ 	INIT_LIST_HEAD(&context->mmaps);
+ 	spin_lock_init(&context->mmap_lock);
+ 
+-	if (udata->outlen < sizeof(uresp)) {
++	if (udata->outlen < sizeof(uresp) - sizeof(uresp.reserved)) {
+ 		if (!warned++)
+ 			pr_err(MOD "Warning - downlevel libcxgb4 (non-fatal), device status page disabled.");
+ 		rhp->rdev.flags |= T4_STATUS_PAGE_DISABLED;
+@@ -140,7 +140,8 @@ static struct ib_ucontext *c4iw_alloc_ucontext(struct ib_device *ibdev,
+ 		context->key += PAGE_SIZE;
+ 		spin_unlock(&context->mmap_lock);
+ 
+-		ret = ib_copy_to_udata(udata, &uresp, sizeof(uresp));
++		ret = ib_copy_to_udata(udata, &uresp,
++				       sizeof(uresp) - sizeof(uresp.reserved));
+ 		if (ret)
+ 			goto err_mm;
+ 
+diff --git a/drivers/infiniband/hw/cxgb4/user.h b/drivers/infiniband/hw/cxgb4/user.h
+index 11ccd276e5d9..cbd0ce170728 100644
+--- a/drivers/infiniband/hw/cxgb4/user.h
++++ b/drivers/infiniband/hw/cxgb4/user.h
+@@ -48,6 +48,7 @@ struct c4iw_create_cq_resp {
+ 	__u32 cqid;
+ 	__u32 size;
+ 	__u32 qid_mask;
++	__u32 reserved; /* explicit padding (optional for i386) */
+ };
+ 
+ 
+@@ -74,5 +75,6 @@ struct c4iw_create_qp_resp {
+ struct c4iw_alloc_ucontext_resp {
+ 	__u64 status_page_key;
+ 	__u32 status_page_size;
++	__u32 reserved; /* explicit padding (optional for i386) */
+ };
+ #endif
+diff --git a/drivers/infiniband/hw/ipath/ipath_diag.c b/drivers/infiniband/hw/ipath/ipath_diag.c
+index e2f9a51f4a38..45802e97332e 100644
+--- a/drivers/infiniband/hw/ipath/ipath_diag.c
++++ b/drivers/infiniband/hw/ipath/ipath_diag.c
+@@ -346,6 +346,10 @@ static ssize_t ipath_diagpkt_write(struct file *fp,
+ 			ret = -EFAULT;
+ 			goto bail;
+ 		}
++		dp.len = odp.len;
++		dp.unit = odp.unit;
++		dp.data = odp.data;
++		dp.pbc_wd = 0;
+ 	} else {
+ 		ret = -EINVAL;
+ 		goto bail;
+diff --git a/drivers/infiniband/hw/mlx5/cq.c b/drivers/infiniband/hw/mlx5/cq.c
+index 62bb6b49dc1d..8ae4f896cb41 100644
+--- a/drivers/infiniband/hw/mlx5/cq.c
++++ b/drivers/infiniband/hw/mlx5/cq.c
+@@ -32,6 +32,7 @@
+ 
+ #include <linux/kref.h>
+ #include <rdma/ib_umem.h>
++#include <rdma/ib_user_verbs.h>
+ #include "mlx5_ib.h"
+ #include "user.h"
+ 
+@@ -602,14 +603,24 @@ static int create_cq_user(struct mlx5_ib_dev *dev, struct ib_udata *udata,
+ 			  int *cqe_size, int *index, int *inlen)
+ {
+ 	struct mlx5_ib_create_cq ucmd;
++	size_t ucmdlen;
+ 	int page_shift;
+ 	int npages;
+ 	int ncont;
+ 	int err;
+ 
+-	if (ib_copy_from_udata(&ucmd, udata, sizeof(ucmd)))
++	ucmdlen =
++		(udata->inlen - sizeof(struct ib_uverbs_cmd_hdr) <
++		 sizeof(ucmd)) ? (sizeof(ucmd) -
++				  sizeof(ucmd.reserved)) : sizeof(ucmd);
++
++	if (ib_copy_from_udata(&ucmd, udata, ucmdlen))
+ 		return -EFAULT;
+ 
++	if (ucmdlen == sizeof(ucmd) &&
++	    ucmd.reserved != 0)
++		return -EINVAL;
++
+ 	if (ucmd.cqe_size != 64 && ucmd.cqe_size != 128)
+ 		return -EINVAL;
+ 
+diff --git a/drivers/infiniband/hw/mlx5/srq.c b/drivers/infiniband/hw/mlx5/srq.c
+index 210b3eaf188a..384af6dec5eb 100644
+--- a/drivers/infiniband/hw/mlx5/srq.c
++++ b/drivers/infiniband/hw/mlx5/srq.c
+@@ -35,6 +35,7 @@
+ #include <linux/mlx5/srq.h>
+ #include <linux/slab.h>
+ #include <rdma/ib_umem.h>
++#include <rdma/ib_user_verbs.h>
+ 
+ #include "mlx5_ib.h"
+ #include "user.h"
+@@ -78,16 +79,27 @@ static int create_srq_user(struct ib_pd *pd, struct mlx5_ib_srq *srq,
+ {
+ 	struct mlx5_ib_dev *dev = to_mdev(pd->device);
+ 	struct mlx5_ib_create_srq ucmd;
++	size_t ucmdlen;
+ 	int err;
+ 	int npages;
+ 	int page_shift;
+ 	int ncont;
+ 	u32 offset;
+ 
+-	if (ib_copy_from_udata(&ucmd, udata, sizeof(ucmd))) {
++	ucmdlen =
++		(udata->inlen - sizeof(struct ib_uverbs_cmd_hdr) <
++		 sizeof(ucmd)) ? (sizeof(ucmd) -
++				  sizeof(ucmd.reserved)) : sizeof(ucmd);
++
++	if (ib_copy_from_udata(&ucmd, udata, ucmdlen)) {
+ 		mlx5_ib_dbg(dev, "failed copy udata\n");
+ 		return -EFAULT;
+ 	}
++
++	if (ucmdlen == sizeof(ucmd) &&
++	    ucmd.reserved != 0)
++		return -EINVAL;
++
+ 	srq->wq_sig = !!(ucmd.flags & MLX5_SRQ_FLAG_SIGNATURE);
+ 
+ 	srq->umem = ib_umem_get(pd->uobject->context, ucmd.buf_addr, buf_size,
+diff --git a/drivers/infiniband/hw/mlx5/user.h b/drivers/infiniband/hw/mlx5/user.h
+index 0f4f8e42a17f..d0ba264ac1ed 100644
+--- a/drivers/infiniband/hw/mlx5/user.h
++++ b/drivers/infiniband/hw/mlx5/user.h
+@@ -91,6 +91,7 @@ struct mlx5_ib_create_cq {
+ 	__u64	buf_addr;
+ 	__u64	db_addr;
+ 	__u32	cqe_size;
++	__u32	reserved; /* explicit padding (optional on i386) */
+ };
+ 
+ struct mlx5_ib_create_cq_resp {
+@@ -109,6 +110,7 @@ struct mlx5_ib_create_srq {
+ 	__u64	buf_addr;
+ 	__u64	db_addr;
+ 	__u32	flags;
++	__u32	reserved; /* explicit padding (optional on i386) */
+ };
+ 
+ struct mlx5_ib_create_srq_resp {
+diff --git a/drivers/infiniband/hw/qib/qib_mad.c b/drivers/infiniband/hw/qib/qib_mad.c
+index edad991d60ed..22c720e5740d 100644
+--- a/drivers/infiniband/hw/qib/qib_mad.c
++++ b/drivers/infiniband/hw/qib/qib_mad.c
+@@ -1028,7 +1028,7 @@ static int set_pkeys(struct qib_devdata *dd, u8 port, u16 *pkeys)
+ 
+ 		event.event = IB_EVENT_PKEY_CHANGE;
+ 		event.device = &dd->verbs_dev.ibdev;
+-		event.element.port_num = 1;
++		event.element.port_num = port;
+ 		ib_dispatch_event(&event);
+ 	}
+ 	return 0;
+diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
+index 66a908bf3fb9..5b2bed8fc493 100644
+--- a/drivers/infiniband/ulp/srp/ib_srp.c
++++ b/drivers/infiniband/ulp/srp/ib_srp.c
+@@ -1594,6 +1594,12 @@ err_unmap:
+ err_iu:
+ 	srp_put_tx_iu(target, iu, SRP_IU_CMD);
+ 
++	/*
++	 * Avoid that the loops that iterate over the request ring can
++	 * encounter a dangling SCSI command pointer.
++	 */
++	req->scmnd = NULL;
++
+ 	spin_lock_irqsave(&target->lock, flags);
+ 	list_add(&req->list, &target->free_reqs);
+ 
+diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c
+index b96e978a37b7..ee2a04d90d20 100644
+--- a/drivers/input/mouse/elantech.c
++++ b/drivers/input/mouse/elantech.c
+@@ -473,8 +473,15 @@ static void elantech_report_absolute_v3(struct psmouse *psmouse,
+ 	input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
+ 	input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
+ 	input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
+-	input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
+-	input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
++
++	/* For clickpads map both buttons to BTN_LEFT */
++	if (etd->fw_version & 0x001000) {
++		input_report_key(dev, BTN_LEFT, packet[0] & 0x03);
++	} else {
++		input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
++		input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
++	}
++
+ 	input_report_abs(dev, ABS_PRESSURE, pres);
+ 	input_report_abs(dev, ABS_TOOL_WIDTH, width);
+ 
+@@ -484,10 +491,17 @@ static void elantech_report_absolute_v3(struct psmouse *psmouse,
+ static void elantech_input_sync_v4(struct psmouse *psmouse)
+ {
+ 	struct input_dev *dev = psmouse->dev;
++	struct elantech_data *etd = psmouse->private;
+ 	unsigned char *packet = psmouse->packet;
+ 
+-	input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
+-	input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
++	/* For clickpads map both buttons to BTN_LEFT */
++	if (etd->fw_version & 0x001000) {
++		input_report_key(dev, BTN_LEFT, packet[0] & 0x03);
++	} else {
++		input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
++		input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
++	}
++
+ 	input_mt_report_pointer_emulation(dev, true);
+ 	input_sync(dev);
+ }
+@@ -835,7 +849,7 @@ static int elantech_set_absolute_mode(struct psmouse *psmouse)
+ 		if (etd->set_hw_resolution)
+ 			etd->reg_10 = 0x0b;
+ 		else
+-			etd->reg_10 = 0x03;
++			etd->reg_10 = 0x01;
+ 
+ 		if (elantech_write_reg(psmouse, 0x10, etd->reg_10))
+ 			rc = -1;
+@@ -1336,7 +1350,8 @@ static int elantech_reconnect(struct psmouse *psmouse)
+ }
+ 
+ /*
+- * Some hw_version 3 models go into error state when we try to set bit 3 of r10
++ * Some hw_version 3 models go into error state when we try to set
++ * bit 3 and/or bit 1 of r10.
+  */
+ static const struct dmi_system_id no_hw_res_dmi_table[] = {
+ #if defined(CONFIG_DMI) && defined(CONFIG_X86)
+diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c
+index c5ec703c727e..ec772d962f06 100644
+--- a/drivers/input/mouse/synaptics.c
++++ b/drivers/input/mouse/synaptics.c
+@@ -347,15 +347,6 @@ static int synaptics_resolution(struct psmouse *psmouse)
+ 	unsigned char resp[3];
+ 	int i;
+ 
+-	for (i = 0; min_max_pnpid_table[i].pnp_ids; i++)
+-		if (matches_pnp_id(psmouse, min_max_pnpid_table[i].pnp_ids)) {
+-			priv->x_min = min_max_pnpid_table[i].x_min;
+-			priv->x_max = min_max_pnpid_table[i].x_max;
+-			priv->y_min = min_max_pnpid_table[i].y_min;
+-			priv->y_max = min_max_pnpid_table[i].y_max;
+-			return 0;
+-		}
+-
+ 	if (SYN_ID_MAJOR(priv->identity) < 4)
+ 		return 0;
+ 
+@@ -366,6 +357,16 @@ static int synaptics_resolution(struct psmouse *psmouse)
+ 		}
+ 	}
+ 
++	for (i = 0; min_max_pnpid_table[i].pnp_ids; i++) {
++		if (matches_pnp_id(psmouse, min_max_pnpid_table[i].pnp_ids)) {
++			priv->x_min = min_max_pnpid_table[i].x_min;
++			priv->x_max = min_max_pnpid_table[i].x_max;
++			priv->y_min = min_max_pnpid_table[i].y_min;
++			priv->y_max = min_max_pnpid_table[i].y_max;
++			return 0;
++		}
++	}
++
+ 	if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 5 &&
+ 	    SYN_CAP_MAX_DIMENSIONS(priv->ext_cap_0c)) {
+ 		if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_MAX_COORDS, resp)) {
+diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
+index 759475ef6ff3..83b01fa02400 100644
+--- a/drivers/pci/pci.c
++++ b/drivers/pci/pci.c
+@@ -4126,7 +4126,7 @@ int pci_set_vga_state(struct pci_dev *dev, bool decode,
+ 	u16 cmd;
+ 	int rc;
+ 
+-	WARN_ON((flags & PCI_VGA_STATE_CHANGE_DECODES) & (command_bits & ~(PCI_COMMAND_IO|PCI_COMMAND_MEMORY)));
++	WARN_ON((flags & PCI_VGA_STATE_CHANGE_DECODES) && (command_bits & ~(PCI_COMMAND_IO|PCI_COMMAND_MEMORY)));
+ 
+ 	/* ARCH specific VGA enables */
+ 	rc = pci_set_vga_state_arch(dev, decode, command_bits, flags);
+diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
+index e7292065a1b1..0feb4a32a941 100644
+--- a/drivers/pci/quirks.c
++++ b/drivers/pci/quirks.c
+@@ -2954,6 +2954,7 @@ static void disable_igfx_irq(struct pci_dev *dev)
+ }
+ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0102, disable_igfx_irq);
+ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x010a, disable_igfx_irq);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0152, disable_igfx_irq);
+ 
+ /*
+  * PCI devices which are on Intel chips can skip the 10ms delay
+diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
+index 9a6e4a2cd072..fda6cf19fafe 100644
+--- a/drivers/scsi/hpsa.c
++++ b/drivers/scsi/hpsa.c
+@@ -115,9 +115,15 @@ static const struct pci_device_id hpsa_pci_device_id[] = {
+ 	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21C3},
+ 	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21C4},
+ 	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21C5},
++	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21C6},
+ 	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21C7},
+ 	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21C8},
+ 	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21C9},
++	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21CA},
++	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21CB},
++	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21CC},
++	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21CD},
++	{PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSI,     0x103C, 0x21CE},
+ 	{PCI_VENDOR_ID_HP_3PAR, 0x0075, 0x1590, 0x0076},
+ 	{PCI_VENDOR_ID_HP_3PAR, 0x0075, 0x1590, 0x0087},
+ 	{PCI_VENDOR_ID_HP_3PAR, 0x0075, 0x1590, 0x007D},
+@@ -165,9 +171,15 @@ static struct board_type products[] = {
+ 	{0x21C3103C, "Smart Array", &SA5_access},
+ 	{0x21C4103C, "Smart Array", &SA5_access},
+ 	{0x21C5103C, "Smart Array", &SA5_access},
++	{0x21C6103C, "Smart Array", &SA5_access},
+ 	{0x21C7103C, "Smart Array", &SA5_access},
+ 	{0x21C8103C, "Smart Array", &SA5_access},
+ 	{0x21C9103C, "Smart Array", &SA5_access},
++	{0x21CA103C, "Smart Array", &SA5_access},
++	{0x21CB103C, "Smart Array", &SA5_access},
++	{0x21CC103C, "Smart Array", &SA5_access},
++	{0x21CD103C, "Smart Array", &SA5_access},
++	{0x21CE103C, "Smart Array", &SA5_access},
+ 	{0x00761590, "HP Storage P1224 Array Controller", &SA5_access},
+ 	{0x00871590, "HP Storage P1224e Array Controller", &SA5_access},
+ 	{0x007D1590, "HP Storage P1228 Array Controller", &SA5_access},
+diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
+index ca2bc348ef5b..e71e1840ac02 100644
+--- a/drivers/target/iscsi/iscsi_target.c
++++ b/drivers/target/iscsi/iscsi_target.c
+@@ -1309,7 +1309,7 @@ iscsit_check_dataout_hdr(struct iscsi_conn *conn, unsigned char *buf,
+ 	if (cmd->data_direction != DMA_TO_DEVICE) {
+ 		pr_err("Command ITT: 0x%08x received DataOUT for a"
+ 			" NON-WRITE command.\n", cmd->init_task_tag);
+-		return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, buf);
++		return iscsit_dump_data_payload(conn, payload_length, 1);
+ 	}
+ 	se_cmd = &cmd->se_cmd;
+ 	iscsit_mod_dataout_timer(cmd);
+diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
+index d9b1d88e1ad3..621b56fcb877 100644
+--- a/drivers/target/iscsi/iscsi_target_login.c
++++ b/drivers/target/iscsi/iscsi_target_login.c
+@@ -1216,7 +1216,7 @@ old_sess_out:
+ static int __iscsi_target_login_thread(struct iscsi_np *np)
+ {
+ 	u8 *buffer, zero_tsih = 0;
+-	int ret = 0, rc, stop;
++	int ret = 0, rc;
+ 	struct iscsi_conn *conn = NULL;
+ 	struct iscsi_login *login;
+ 	struct iscsi_portal_group *tpg = NULL;
+@@ -1230,6 +1230,9 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
+ 	if (np->np_thread_state == ISCSI_NP_THREAD_RESET) {
+ 		np->np_thread_state = ISCSI_NP_THREAD_ACTIVE;
+ 		complete(&np->np_restart_comp);
++	} else if (np->np_thread_state == ISCSI_NP_THREAD_SHUTDOWN) {
++		spin_unlock_bh(&np->np_thread_lock);
++		goto exit;
+ 	} else {
+ 		np->np_thread_state = ISCSI_NP_THREAD_ACTIVE;
+ 	}
+@@ -1422,10 +1425,8 @@ old_sess_out:
+ 	}
+ 
+ out:
+-	stop = kthread_should_stop();
+-	/* Wait for another socket.. */
+-	if (!stop)
+-		return 1;
++	return 1;
++
+ exit:
+ 	iscsi_stop_login_thread_timer(np);
+ 	spin_lock_bh(&np->np_thread_lock);
+@@ -1442,7 +1443,7 @@ int iscsi_target_login_thread(void *arg)
+ 
+ 	allow_signal(SIGINT);
+ 
+-	while (!kthread_should_stop()) {
++	while (1) {
+ 		ret = __iscsi_target_login_thread(np);
+ 		/*
+ 		 * We break and exit here unless another sock_accept() call
+diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
+index 53e157cb8c54..fd90b28f1d94 100644
+--- a/drivers/target/iscsi/iscsi_target_util.c
++++ b/drivers/target/iscsi/iscsi_target_util.c
+@@ -1295,6 +1295,8 @@ int iscsit_tx_login_rsp(struct iscsi_conn *conn, u8 status_class, u8 status_deta
+ 	login->login_failed = 1;
+ 	iscsit_collect_login_stats(conn, status_class, status_detail);
+ 
++	memset(&login->rsp[0], 0, ISCSI_HDR_LEN);
++
+ 	hdr	= (struct iscsi_login_rsp *)&login->rsp[0];
+ 	hdr->opcode		= ISCSI_OP_LOGIN_RSP;
+ 	hdr->status_class	= status_class;
+diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
+index 26416c15d65c..6ea95d216eb8 100644
+--- a/drivers/target/target_core_device.c
++++ b/drivers/target/target_core_device.c
+@@ -616,6 +616,7 @@ void core_dev_unexport(
+ 	dev->export_count--;
+ 	spin_unlock(&hba->device_lock);
+ 
++	lun->lun_sep = NULL;
+ 	lun->lun_se_dev = NULL;
+ }
+ 
+diff --git a/drivers/watchdog/ath79_wdt.c b/drivers/watchdog/ath79_wdt.c
+index 399c3fddecf6..0e67d96b3ebd 100644
+--- a/drivers/watchdog/ath79_wdt.c
++++ b/drivers/watchdog/ath79_wdt.c
+@@ -20,6 +20,7 @@
+ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+ 
+ #include <linux/bitops.h>
++#include <linux/delay.h>
+ #include <linux/errno.h>
+ #include <linux/fs.h>
+ #include <linux/io.h>
+@@ -90,6 +91,15 @@ static inline void ath79_wdt_keepalive(void)
+ static inline void ath79_wdt_enable(void)
+ {
+ 	ath79_wdt_keepalive();
++
++	/*
++	 * Updating the TIMER register requires a few microseconds
++	 * on the AR934x SoCs at least. Use a small delay to ensure
++	 * that the TIMER register is updated within the hardware
++	 * before enabling the watchdog.
++	 */
++	udelay(2);
++
+ 	ath79_wdt_wr(WDOG_REG_CTRL, WDOG_CTRL_ACTION_FCR);
+ 	/* flush write */
+ 	ath79_wdt_rr(WDOG_REG_CTRL);
+diff --git a/drivers/watchdog/kempld_wdt.c b/drivers/watchdog/kempld_wdt.c
+index 20dc73844737..d9c1a1601926 100644
+--- a/drivers/watchdog/kempld_wdt.c
++++ b/drivers/watchdog/kempld_wdt.c
+@@ -162,7 +162,7 @@ static int kempld_wdt_set_stage_timeout(struct kempld_wdt_data *wdt_data,
+ 	kempld_get_mutex(pld);
+ 	stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id));
+ 	stage_cfg &= ~STAGE_CFG_PRESCALER_MASK;
+-	stage_cfg |= STAGE_CFG_SET_PRESCALER(prescaler);
++	stage_cfg |= STAGE_CFG_SET_PRESCALER(PRESCALER_21);
+ 	kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->id), stage_cfg);
+ 	kempld_write32(pld, KEMPLD_WDT_STAGE_TIMEOUT(stage->id),
+ 			stage_timeout);
+diff --git a/drivers/watchdog/sp805_wdt.c b/drivers/watchdog/sp805_wdt.c
+index 47629d268e0a..c1b03f4235b9 100644
+--- a/drivers/watchdog/sp805_wdt.c
++++ b/drivers/watchdog/sp805_wdt.c
+@@ -59,7 +59,6 @@
+  * @adev: amba device structure of wdt
+  * @status: current status of wdt
+  * @load_val: load value to be set for current timeout
+- * @timeout: current programmed timeout
+  */
+ struct sp805_wdt {
+ 	struct watchdog_device		wdd;
+@@ -68,7 +67,6 @@ struct sp805_wdt {
+ 	struct clk			*clk;
+ 	struct amba_device		*adev;
+ 	unsigned int			load_val;
+-	unsigned int			timeout;
+ };
+ 
+ static bool nowayout = WATCHDOG_NOWAYOUT;
+@@ -98,7 +96,7 @@ static int wdt_setload(struct watchdog_device *wdd, unsigned int timeout)
+ 	spin_lock(&wdt->lock);
+ 	wdt->load_val = load;
+ 	/* roundup timeout to closest positive integer value */
+-	wdt->timeout = div_u64((load + 1) * 2 + (rate / 2), rate);
++	wdd->timeout = div_u64((load + 1) * 2 + (rate / 2), rate);
+ 	spin_unlock(&wdt->lock);
+ 
+ 	return 0;
+diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
+index 0c438973f3c8..c79f3e767c8c 100644
+--- a/fs/nfs/inode.c
++++ b/fs/nfs/inode.c
+@@ -1575,18 +1575,20 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
+ 			inode->i_version = fattr->change_attr;
+ 		}
+ 	} else if (server->caps & NFS_CAP_CHANGE_ATTR)
+-		invalid |= save_cache_validity;
++		nfsi->cache_validity |= save_cache_validity;
+ 
+ 	if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
+ 		memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
+ 	} else if (server->caps & NFS_CAP_MTIME)
+-		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
++		nfsi->cache_validity |= save_cache_validity &
++				(NFS_INO_INVALID_ATTR
+ 				| NFS_INO_REVAL_FORCED);
+ 
+ 	if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
+ 		memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
+ 	} else if (server->caps & NFS_CAP_CTIME)
+-		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
++		nfsi->cache_validity |= save_cache_validity &
++				(NFS_INO_INVALID_ATTR
+ 				| NFS_INO_REVAL_FORCED);
+ 
+ 	/* Check if our cached file size is stale */
+@@ -1608,7 +1610,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
+ 					(long long)new_isize);
+ 		}
+ 	} else
+-		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
++		nfsi->cache_validity |= save_cache_validity &
++				(NFS_INO_INVALID_ATTR
+ 				| NFS_INO_REVAL_PAGECACHE
+ 				| NFS_INO_REVAL_FORCED);
+ 
+@@ -1616,7 +1619,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
+ 	if (fattr->valid & NFS_ATTR_FATTR_ATIME)
+ 		memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
+ 	else if (server->caps & NFS_CAP_ATIME)
+-		invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME
++		nfsi->cache_validity |= save_cache_validity &
++				(NFS_INO_INVALID_ATIME
+ 				| NFS_INO_REVAL_FORCED);
+ 
+ 	if (fattr->valid & NFS_ATTR_FATTR_MODE) {
+@@ -1627,7 +1631,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
+ 			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
+ 		}
+ 	} else if (server->caps & NFS_CAP_MODE)
+-		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
++		nfsi->cache_validity |= save_cache_validity &
++				(NFS_INO_INVALID_ATTR
+ 				| NFS_INO_INVALID_ACCESS
+ 				| NFS_INO_INVALID_ACL
+ 				| NFS_INO_REVAL_FORCED);
+@@ -1638,7 +1643,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
+ 			inode->i_uid = fattr->uid;
+ 		}
+ 	} else if (server->caps & NFS_CAP_OWNER)
+-		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
++		nfsi->cache_validity |= save_cache_validity &
++				(NFS_INO_INVALID_ATTR
+ 				| NFS_INO_INVALID_ACCESS
+ 				| NFS_INO_INVALID_ACL
+ 				| NFS_INO_REVAL_FORCED);
+@@ -1649,7 +1655,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
+ 			inode->i_gid = fattr->gid;
+ 		}
+ 	} else if (server->caps & NFS_CAP_OWNER_GROUP)
+-		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
++		nfsi->cache_validity |= save_cache_validity &
++				(NFS_INO_INVALID_ATTR
+ 				| NFS_INO_INVALID_ACCESS
+ 				| NFS_INO_INVALID_ACL
+ 				| NFS_INO_REVAL_FORCED);
+@@ -1662,7 +1669,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
+ 			set_nlink(inode, fattr->nlink);
+ 		}
+ 	} else if (server->caps & NFS_CAP_NLINK)
+-		invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
++		nfsi->cache_validity |= save_cache_validity &
++				(NFS_INO_INVALID_ATTR
+ 				| NFS_INO_REVAL_FORCED);
+ 
+ 	if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
+diff --git a/fs/nfs/nfs4filelayout.c b/fs/nfs/nfs4filelayout.c
+index b9a35c05b60f..5e992fc51e61 100644
+--- a/fs/nfs/nfs4filelayout.c
++++ b/fs/nfs/nfs4filelayout.c
+@@ -1330,7 +1330,7 @@ filelayout_alloc_layout_hdr(struct inode *inode, gfp_t gfp_flags)
+ 	struct nfs4_filelayout *flo;
+ 
+ 	flo = kzalloc(sizeof(*flo), gfp_flags);
+-	return &flo->generic_hdr;
++	return flo != NULL ? &flo->generic_hdr : NULL;
+ }
+ 
+ static void
+diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
+index 2349518eef2c..21275148fc13 100644
+--- a/fs/nfs/nfs4state.c
++++ b/fs/nfs/nfs4state.c
+@@ -1456,7 +1456,7 @@ static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs
+ 	 * server that doesn't support a grace period.
+ 	 */
+ 	spin_lock(&sp->so_lock);
+-	write_seqcount_begin(&sp->so_reclaim_seqcount);
++	raw_write_seqcount_begin(&sp->so_reclaim_seqcount);
+ restart:
+ 	list_for_each_entry(state, &sp->so_states, open_states) {
+ 		if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
+@@ -1519,13 +1519,13 @@ restart:
+ 		spin_lock(&sp->so_lock);
+ 		goto restart;
+ 	}
+-	write_seqcount_end(&sp->so_reclaim_seqcount);
++	raw_write_seqcount_end(&sp->so_reclaim_seqcount);
+ 	spin_unlock(&sp->so_lock);
+ 	return 0;
+ out_err:
+ 	nfs4_put_open_state(state);
+ 	spin_lock(&sp->so_lock);
+-	write_seqcount_end(&sp->so_reclaim_seqcount);
++	raw_write_seqcount_end(&sp->so_reclaim_seqcount);
+ 	spin_unlock(&sp->so_lock);
+ 	return status;
+ }
+diff --git a/fs/nfs/super.c b/fs/nfs/super.c
+index 2cb56943e232..104ef01d694d 100644
+--- a/fs/nfs/super.c
++++ b/fs/nfs/super.c
+@@ -2248,6 +2248,7 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
+ 	data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
+ 	data->version = nfsvers;
+ 	data->minorversion = nfss->nfs_client->cl_minorversion;
++	data->net = current->nsproxy->net_ns;
+ 	memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
+ 		data->nfs_server.addrlen);
+ 
+diff --git a/fs/nfs/write.c b/fs/nfs/write.c
+index 9a3b6a4cd6b9..aaa16b31e21e 100644
+--- a/fs/nfs/write.c
++++ b/fs/nfs/write.c
+@@ -913,12 +913,14 @@ static bool nfs_write_pageuptodate(struct page *page, struct inode *inode)
+ 
+ 	if (nfs_have_delegated_attributes(inode))
+ 		goto out;
+-	if (nfsi->cache_validity & (NFS_INO_INVALID_DATA|NFS_INO_REVAL_PAGECACHE))
++	if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
+ 		return false;
+ 	smp_rmb();
+ 	if (test_bit(NFS_INO_INVALIDATING, &nfsi->flags))
+ 		return false;
+ out:
++	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
++		return false;
+ 	return PageUptodate(page) != 0;
+ }
+ 
+diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
+index 9a77a5a21557..6134ee283798 100644
+--- a/fs/nfsd/nfs4state.c
++++ b/fs/nfsd/nfs4state.c
+@@ -3726,7 +3726,7 @@ nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp)
+ 	 * correspondance, and we have to delete the lockowner when we
+ 	 * delete the lock stateid:
+ 	 */
+-	unhash_lockowner(lo);
++	release_lockowner(lo);
+ 	return nfs_ok;
+ }
+ 
+diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
+index 18881f34737a..b4c49588eada 100644
+--- a/fs/nfsd/nfs4xdr.c
++++ b/fs/nfsd/nfs4xdr.c
+@@ -2095,8 +2095,8 @@ nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
+ 	err = vfs_getattr(&path, &stat);
+ 	if (err)
+ 		goto out_nfserr;
+-	if ((bmval0 & (FATTR4_WORD0_FILES_FREE | FATTR4_WORD0_FILES_TOTAL |
+-			FATTR4_WORD0_MAXNAME)) ||
++	if ((bmval0 & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE |
++			FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) ||
+ 	    (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
+ 		       FATTR4_WORD1_SPACE_TOTAL))) {
+ 		err = vfs_statfs(&path, &statfs);
+diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
+index bc8b8009897d..6e48eb0ff61d 100644
+--- a/fs/reiserfs/inode.c
++++ b/fs/reiserfs/inode.c
+@@ -3220,8 +3220,14 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
+ 	    attr->ia_size != i_size_read(inode)) {
+ 		error = inode_newsize_ok(inode, attr->ia_size);
+ 		if (!error) {
++			/*
++			 * Could race against reiserfs_file_release
++			 * if called from NFS, so take tailpack mutex.
++			 */
++			mutex_lock(&REISERFS_I(inode)->tailpack);
+ 			truncate_setsize(inode, attr->ia_size);
+-			reiserfs_vfs_truncate_file(inode);
++			reiserfs_truncate_file(inode, 1);
++			mutex_unlock(&REISERFS_I(inode)->tailpack);
+ 		}
+ 	}
+ 
+diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
+index 4f34dbae823d..f7d48a08f443 100644
+--- a/fs/ubifs/file.c
++++ b/fs/ubifs/file.c
+@@ -1525,8 +1525,7 @@ static int ubifs_vm_page_mkwrite(struct vm_area_struct *vma,
+ 	}
+ 
+ 	wait_for_stable_page(page);
+-	unlock_page(page);
+-	return 0;
++	return VM_FAULT_LOCKED;
+ 
+ out_unlock:
+ 	unlock_page(page);
+diff --git a/fs/ubifs/shrinker.c b/fs/ubifs/shrinker.c
+index f35135e28e96..9a9fb94a41c6 100644
+--- a/fs/ubifs/shrinker.c
++++ b/fs/ubifs/shrinker.c
+@@ -128,7 +128,6 @@ static int shrink_tnc(struct ubifs_info *c, int nr, int age, int *contention)
+ 			freed = ubifs_destroy_tnc_subtree(znode);
+ 			atomic_long_sub(freed, &ubifs_clean_zn_cnt);
+ 			atomic_long_sub(freed, &c->clean_zn_cnt);
+-			ubifs_assert(atomic_long_read(&c->clean_zn_cnt) >= 0);
+ 			total_freed += freed;
+ 			znode = zprev;
+ 		}
+diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
+index 944f3d9456a8..a9e29ea37620 100644
+--- a/fs/xfs/xfs_mount.c
++++ b/fs/xfs/xfs_mount.c
+@@ -323,8 +323,19 @@ reread:
+ 	/*
+ 	 * Initialize the mount structure from the superblock.
+ 	 */
+-	xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp));
+-	xfs_sb_quota_from_disk(&mp->m_sb);
++	xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
++	xfs_sb_quota_from_disk(sbp);
++
++	/*
++	 * If we haven't validated the superblock, do so now before we try
++	 * to check the sector size and reread the superblock appropriately.
++	 */
++	if (sbp->sb_magicnum != XFS_SB_MAGIC) {
++		if (loud)
++			xfs_warn(mp, "Invalid superblock magic number");
++		error = EINVAL;
++		goto release_buf;
++	}
+ 
+ 	/*
+ 	 * We must be able to do sector-sized and sector-aligned IO.
+@@ -337,11 +348,11 @@ reread:
+ 		goto release_buf;
+ 	}
+ 
+-	/*
+-	 * Re-read the superblock so the buffer is correctly sized,
+-	 * and properly verified.
+-	 */
+ 	if (buf_ops == NULL) {
++		/*
++		 * Re-read the superblock so the buffer is correctly sized,
++		 * and properly verified.
++		 */
+ 		xfs_buf_relse(bp);
+ 		sector_size = sbp->sb_sectsize;
+ 		buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
+diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
+index 077904c8b70d..cc79eff4a1ad 100644
+--- a/include/linux/ptrace.h
++++ b/include/linux/ptrace.h
+@@ -334,6 +334,9 @@ static inline void user_single_step_siginfo(struct task_struct *tsk,
+  * calling arch_ptrace_stop() when it would be superfluous.  For example,
+  * if the thread has not been back to user mode since the last stop, the
+  * thread state might indicate that nothing needs to be done.
++ *
++ * This is guaranteed to be invoked once before a task stops for ptrace and
++ * may include arch-specific operations necessary prior to a ptrace stop.
+  */
+ #define arch_ptrace_stop_needed(code, info)	(0)
+ #endif
+diff --git a/include/trace/syscall.h b/include/trace/syscall.h
+index fed853f3d7aa..9674145e2f6a 100644
+--- a/include/trace/syscall.h
++++ b/include/trace/syscall.h
+@@ -4,6 +4,7 @@
+ #include <linux/tracepoint.h>
+ #include <linux/unistd.h>
+ #include <linux/ftrace_event.h>
++#include <linux/thread_info.h>
+ 
+ #include <asm/ptrace.h>
+ 
+@@ -32,4 +33,18 @@ struct syscall_metadata {
+ 	struct ftrace_event_call *exit_event;
+ };
+ 
++#if defined(CONFIG_TRACEPOINTS) && defined(CONFIG_HAVE_SYSCALL_TRACEPOINTS)
++static inline void syscall_tracepoint_update(struct task_struct *p)
++{
++	if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
++		set_tsk_thread_flag(p, TIF_SYSCALL_TRACEPOINT);
++	else
++		clear_tsk_thread_flag(p, TIF_SYSCALL_TRACEPOINT);
++}
++#else
++static inline void syscall_tracepoint_update(struct task_struct *p)
++{
++}
++#endif
++
+ #endif /* _TRACE_SYSCALL_H */
+diff --git a/kernel/fork.c b/kernel/fork.c
+index 142904349fb5..68b92262dc45 100644
+--- a/kernel/fork.c
++++ b/kernel/fork.c
+@@ -1487,7 +1487,9 @@ static struct task_struct *copy_process(unsigned long clone_flags,
+ 
+ 	total_forks++;
+ 	spin_unlock(&current->sighand->siglock);
++	syscall_tracepoint_update(p);
+ 	write_unlock_irq(&tasklist_lock);
++
+ 	proc_fork_connector(p);
+ 	cgroup_post_fork(p);
+ 	if (clone_flags & CLONE_THREAD)
+diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
+index 737b0efa1a62..e916972c6d87 100644
+--- a/kernel/trace/trace.c
++++ b/kernel/trace/trace.c
+@@ -1461,12 +1461,12 @@ static void tracing_stop_tr(struct trace_array *tr)
+ 
+ void trace_stop_cmdline_recording(void);
+ 
+-static void trace_save_cmdline(struct task_struct *tsk)
++static int trace_save_cmdline(struct task_struct *tsk)
+ {
+ 	unsigned pid, idx;
+ 
+ 	if (!tsk->pid || unlikely(tsk->pid > PID_MAX_DEFAULT))
+-		return;
++		return 0;
+ 
+ 	/*
+ 	 * It's not the end of the world if we don't get
+@@ -1475,7 +1475,7 @@ static void trace_save_cmdline(struct task_struct *tsk)
+ 	 * so if we miss here, then better luck next time.
+ 	 */
+ 	if (!arch_spin_trylock(&trace_cmdline_lock))
+-		return;
++		return 0;
+ 
+ 	idx = map_pid_to_cmdline[tsk->pid];
+ 	if (idx == NO_CMDLINE_MAP) {
+@@ -1500,6 +1500,8 @@ static void trace_save_cmdline(struct task_struct *tsk)
+ 	memcpy(&saved_cmdlines[idx], tsk->comm, TASK_COMM_LEN);
+ 
+ 	arch_spin_unlock(&trace_cmdline_lock);
++
++	return 1;
+ }
+ 
+ void trace_find_cmdline(int pid, char comm[])
+@@ -1541,9 +1543,8 @@ void tracing_record_cmdline(struct task_struct *tsk)
+ 	if (!__this_cpu_read(trace_cmdline_save))
+ 		return;
+ 
+-	__this_cpu_write(trace_cmdline_save, false);
+-
+-	trace_save_cmdline(tsk);
++	if (trace_save_cmdline(tsk))
++		__this_cpu_write(trace_cmdline_save, false);
+ }
+ 
+ void
+diff --git a/kernel/watchdog.c b/kernel/watchdog.c
+index 516203e665fc..30e482240dae 100644
+--- a/kernel/watchdog.c
++++ b/kernel/watchdog.c
+@@ -527,10 +527,8 @@ static void update_timers_all_cpus(void)
+ 	int cpu;
+ 
+ 	get_online_cpus();
+-	preempt_disable();
+ 	for_each_online_cpu(cpu)
+ 		update_timers(cpu);
+-	preempt_enable();
+ 	put_online_cpus();
+ }
+ 
+diff --git a/lib/lz4/lz4_decompress.c b/lib/lz4/lz4_decompress.c
+index b74da447e81e..7a85967060a5 100644
+--- a/lib/lz4/lz4_decompress.c
++++ b/lib/lz4/lz4_decompress.c
+@@ -192,6 +192,8 @@ static int lz4_uncompress_unknownoutputsize(const char *source, char *dest,
+ 			int s = 255;
+ 			while ((ip < iend) && (s == 255)) {
+ 				s = *ip++;
++				if (unlikely(length > (size_t)(length + s)))
++					goto _output_error;
+ 				length += s;
+ 			}
+ 		}
+@@ -232,6 +234,8 @@ static int lz4_uncompress_unknownoutputsize(const char *source, char *dest,
+ 		if (length == ML_MASK) {
+ 			while (ip < iend) {
+ 				int s = *ip++;
++				if (unlikely(length > (size_t)(length + s)))
++					goto _output_error;
+ 				length += s;
+ 				if (s == 255)
+ 					continue;
+@@ -284,7 +288,7 @@ static int lz4_uncompress_unknownoutputsize(const char *source, char *dest,
+ 
+ 	/* write overflow error detected */
+ _output_error:
+-	return (int) (-(((char *) ip) - source));
++	return -1;
+ }
+ 
+ int lz4_decompress(const unsigned char *src, size_t *src_len,
+diff --git a/net/sunrpc/svc_xprt.c b/net/sunrpc/svc_xprt.c
+index 06c6ff0cb911..a4acaf2bcf18 100644
+--- a/net/sunrpc/svc_xprt.c
++++ b/net/sunrpc/svc_xprt.c
+@@ -730,6 +730,8 @@ static int svc_handle_xprt(struct svc_rqst *rqstp, struct svc_xprt *xprt)
+ 		newxpt = xprt->xpt_ops->xpo_accept(xprt);
+ 		if (newxpt)
+ 			svc_add_new_temp_xprt(serv, newxpt);
++		else
++			module_put(xprt->xpt_class->xcl_owner);
+ 	} else if (xprt->xpt_ops->xpo_has_wspace(xprt)) {
+ 		/* XPT_DATA|XPT_DEFERRED case: */
+ 		dprintk("svc: server %p, pool %u, transport %p, inuse=%d\n",
+diff --git a/scripts/recordmcount.h b/scripts/recordmcount.h
+index 9d1421e63ff8..49b582a225b0 100644
+--- a/scripts/recordmcount.h
++++ b/scripts/recordmcount.h
+@@ -163,11 +163,11 @@ static int mcount_adjust = 0;
+ 
+ static int MIPS_is_fake_mcount(Elf_Rel const *rp)
+ {
+-	static Elf_Addr old_r_offset;
++	static Elf_Addr old_r_offset = ~(Elf_Addr)0;
+ 	Elf_Addr current_r_offset = _w(rp->r_offset);
+ 	int is_fake;
+ 
+-	is_fake = old_r_offset &&
++	is_fake = (old_r_offset != ~(Elf_Addr)0) &&
+ 		(current_r_offset - old_r_offset == MIPS_FAKEMCOUNT_OFFSET);
+ 	old_r_offset = current_r_offset;
+ 
+diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
+index 6cc3cf285558..0176cf0e01d9 100644
+--- a/sound/pci/hda/hda_intel.c
++++ b/sound/pci/hda/hda_intel.c
+@@ -282,6 +282,24 @@ static char *driver_short_names[] = {
+ 	[AZX_DRIVER_GENERIC] = "HD-Audio Generic",
+ };
+ 
++
++/* Intel HSW/BDW display HDA controller Extended Mode registers.
++ * EM4 (M value) and EM5 (N Value) are used to convert CDClk (Core Display
++ * Clock) to 24MHz BCLK: BCLK = CDCLK * M / N
++ * The values will be lost when the display power well is disabled.
++ */
++#define ICH6_REG_EM4			0x100c
++#define ICH6_REG_EM5			0x1010
++
++struct hda_intel {
++	struct azx chip;
++
++	/* HSW/BDW display HDA controller to restore BCLK from CDCLK */
++	unsigned int bclk_m;
++	unsigned int bclk_n;
++};
++
++
+ #ifdef CONFIG_X86
+ static void __mark_pages_wc(struct azx *chip, struct snd_dma_buffer *dmab, bool on)
+ {
+@@ -574,6 +592,22 @@ static int param_set_xint(const char *val, const struct kernel_param *kp)
+ #define azx_del_card_list(chip) /* NOP */
+ #endif /* CONFIG_PM */
+ 
++static void haswell_save_bclk(struct azx *chip)
++{
++	struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
++
++	hda->bclk_m = azx_readw(chip, EM4);
++	hda->bclk_n = azx_readw(chip, EM5);
++}
++
++static void haswell_restore_bclk(struct azx *chip)
++{
++	struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
++
++	azx_writew(chip, EM4, hda->bclk_m);
++	azx_writew(chip, EM5, hda->bclk_n);
++}
++
+ #if defined(CONFIG_PM_SLEEP) || defined(SUPPORT_VGA_SWITCHEROO)
+ /*
+  * power management
+@@ -600,6 +634,13 @@ static int azx_suspend(struct device *dev)
+ 		free_irq(chip->irq, chip);
+ 		chip->irq = -1;
+ 	}
++
++	/* Save BCLK M/N values before they become invalid in D3.
++	 * Will test if display power well can be released now.
++	 */
++	if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
++		haswell_save_bclk(chip);
++
+ 	if (chip->msi)
+ 		pci_disable_msi(chip->pci);
+ 	pci_disable_device(pci);
+@@ -619,8 +660,10 @@ static int azx_resume(struct device *dev)
+ 	if (chip->disabled)
+ 		return 0;
+ 
+-	if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
++	if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
+ 		hda_display_power(true);
++		haswell_restore_bclk(chip);
++	}
+ 	pci_set_power_state(pci, PCI_D0);
+ 	pci_restore_state(pci);
+ 	if (pci_enable_device(pci) < 0) {
+@@ -664,8 +707,10 @@ static int azx_runtime_suspend(struct device *dev)
+ 	azx_stop_chip(chip);
+ 	azx_enter_link_reset(chip);
+ 	azx_clear_irq_pending(chip);
+-	if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
++	if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
++		haswell_save_bclk(chip);
+ 		hda_display_power(false);
++	}
+ 	return 0;
+ }
+ 
+@@ -683,8 +728,10 @@ static int azx_runtime_resume(struct device *dev)
+ 	if (!(chip->driver_caps & AZX_DCAPS_PM_RUNTIME))
+ 		return 0;
+ 
+-	if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
++	if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
+ 		hda_display_power(true);
++		haswell_restore_bclk(chip);
++	}
+ 
+ 	/* Read STATESTS before controller reset */
+ 	status = azx_readw(chip, STATESTS);
+@@ -877,6 +924,8 @@ static int register_vga_switcheroo(struct azx *chip)
+ static int azx_free(struct azx *chip)
+ {
+ 	struct pci_dev *pci = chip->pci;
++	struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
++
+ 	int i;
+ 
+ 	if ((chip->driver_caps & AZX_DCAPS_PM_RUNTIME)
+@@ -924,7 +973,7 @@ static int azx_free(struct azx *chip)
+ 		hda_display_power(false);
+ 		hda_i915_exit();
+ 	}
+-	kfree(chip);
++	kfree(hda);
+ 
+ 	return 0;
+ }
+@@ -1168,6 +1217,7 @@ static int azx_create(struct snd_card *card, struct pci_dev *pci,
+ 	static struct snd_device_ops ops = {
+ 		.dev_free = azx_dev_free,
+ 	};
++	struct hda_intel *hda;
+ 	struct azx *chip;
+ 	int err;
+ 
+@@ -1177,13 +1227,14 @@ static int azx_create(struct snd_card *card, struct pci_dev *pci,
+ 	if (err < 0)
+ 		return err;
+ 
+-	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+-	if (!chip) {
+-		dev_err(card->dev, "Cannot allocate chip\n");
++	hda = kzalloc(sizeof(*hda), GFP_KERNEL);
++	if (!hda) {
++		dev_err(card->dev, "Cannot allocate hda\n");
+ 		pci_disable_device(pci);
+ 		return -ENOMEM;
+ 	}
+ 
++	chip = &hda->chip;
+ 	spin_lock_init(&chip->reg_lock);
+ 	mutex_init(&chip->open_mutex);
+ 	chip->card = card;
+diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
+index 8867ab3a71d4..bce551293e2a 100644
+--- a/sound/pci/hda/patch_hdmi.c
++++ b/sound/pci/hda/patch_hdmi.c
+@@ -2208,7 +2208,7 @@ static int generic_hdmi_resume(struct hda_codec *codec)
+ 	struct hdmi_spec *spec = codec->spec;
+ 	int pin_idx;
+ 
+-	generic_hdmi_init(codec);
++	codec->patch_ops.init(codec);
+ 	snd_hda_codec_resume_amp(codec);
+ 	snd_hda_codec_resume_cache(codec);
+ 
+diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
+index 75515b494034..37710495fa0a 100644
+--- a/sound/pci/hda/patch_sigmatel.c
++++ b/sound/pci/hda/patch_sigmatel.c
+@@ -122,6 +122,12 @@ enum {
+ };
+ 
+ enum {
++	STAC_92HD95_HP_LED,
++	STAC_92HD95_HP_BASS,
++	STAC_92HD95_MODELS
++};
++
++enum {
+ 	STAC_925x_REF,
+ 	STAC_M1,
+ 	STAC_M1_2,
+@@ -4128,6 +4134,48 @@ static const struct snd_pci_quirk stac9205_fixup_tbl[] = {
+ 	{} /* terminator */
+ };
+ 
++static void stac92hd95_fixup_hp_led(struct hda_codec *codec,
++				    const struct hda_fixup *fix, int action)
++{
++	struct sigmatel_spec *spec = codec->spec;
++
++	if (action != HDA_FIXUP_ACT_PRE_PROBE)
++		return;
++
++	if (find_mute_led_cfg(codec, spec->default_polarity))
++		codec_dbg(codec, "mute LED gpio %d polarity %d\n",
++				spec->gpio_led,
++				spec->gpio_led_polarity);
++}
++
++static const struct hda_fixup stac92hd95_fixups[] = {
++	[STAC_92HD95_HP_LED] = {
++		.type = HDA_FIXUP_FUNC,
++		.v.func = stac92hd95_fixup_hp_led,
++	},
++	[STAC_92HD95_HP_BASS] = {
++		.type = HDA_FIXUP_VERBS,
++		.v.verbs = (const struct hda_verb[]) {
++			{0x1a, 0x795, 0x00}, /* HPF to 100Hz */
++			{}
++		},
++		.chained = true,
++		.chain_id = STAC_92HD95_HP_LED,
++	},
++};
++
++static const struct snd_pci_quirk stac92hd95_fixup_tbl[] = {
++	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1911, "HP Spectre 13", STAC_92HD95_HP_BASS),
++	{} /* terminator */
++};
++
++static const struct hda_model_fixup stac92hd95_models[] = {
++	{ .id = STAC_92HD95_HP_LED, .name = "hp-led" },
++	{ .id = STAC_92HD95_HP_BASS, .name = "hp-bass" },
++	{}
++};
++
++
+ static int stac_parse_auto_config(struct hda_codec *codec)
+ {
+ 	struct sigmatel_spec *spec = codec->spec;
+@@ -4580,10 +4628,16 @@ static int patch_stac92hd95(struct hda_codec *codec)
+ 	spec->gen.beep_nid = 0x19; /* digital beep */
+ 	spec->pwr_nids = stac92hd95_pwr_nids;
+ 	spec->num_pwrs = ARRAY_SIZE(stac92hd95_pwr_nids);
+-	spec->default_polarity = -1; /* no default cfg */
++	spec->default_polarity = 0;
+ 
+ 	codec->patch_ops = stac_patch_ops;
+ 
++	snd_hda_pick_fixup(codec, stac92hd95_models, stac92hd95_fixup_tbl,
++			   stac92hd95_fixups);
++	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
++
++	stac_setup_gpio(codec);
++
+ 	err = stac_parse_auto_config(codec);
+ 	if (err < 0) {
+ 		stac_free(codec);
+@@ -4592,6 +4646,8 @@ static int patch_stac92hd95(struct hda_codec *codec)
+ 
+ 	codec->proc_widget_hook = stac92hd_proc_hook;
+ 
++	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
++
+ 	return 0;
+ }
+ 
+diff --git a/sound/usb/card.c b/sound/usb/card.c
+index c3b5b7dca1c3..a09e5f3519e3 100644
+--- a/sound/usb/card.c
++++ b/sound/usb/card.c
+@@ -307,6 +307,11 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
+ 
+ static int snd_usb_audio_free(struct snd_usb_audio *chip)
+ {
++	struct list_head *p, *n;
++
++	list_for_each_safe(p, n, &chip->ep_list)
++		snd_usb_endpoint_free(p);
++
+ 	mutex_destroy(&chip->mutex);
+ 	kfree(chip);
+ 	return 0;
+@@ -585,7 +590,7 @@ static void snd_usb_audio_disconnect(struct usb_device *dev,
+ 				     struct snd_usb_audio *chip)
+ {
+ 	struct snd_card *card;
+-	struct list_head *p, *n;
++	struct list_head *p;
+ 
+ 	if (chip == (void *)-1L)
+ 		return;
+@@ -598,14 +603,16 @@ static void snd_usb_audio_disconnect(struct usb_device *dev,
+ 	mutex_lock(&register_mutex);
+ 	chip->num_interfaces--;
+ 	if (chip->num_interfaces <= 0) {
++		struct snd_usb_endpoint *ep;
++
+ 		snd_card_disconnect(card);
+ 		/* release the pcm resources */
+ 		list_for_each(p, &chip->pcm_list) {
+ 			snd_usb_stream_disconnect(p);
+ 		}
+ 		/* release the endpoint resources */
+-		list_for_each_safe(p, n, &chip->ep_list) {
+-			snd_usb_endpoint_free(p);
++		list_for_each_entry(ep, &chip->ep_list, list) {
++			snd_usb_endpoint_release(ep);
+ 		}
+ 		/* release the midi resources */
+ 		list_for_each(p, &chip->midi_list) {
+diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c
+index 289f582c9130..114e3e7ff511 100644
+--- a/sound/usb/endpoint.c
++++ b/sound/usb/endpoint.c
+@@ -987,19 +987,30 @@ void snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep)
+ }
+ 
+ /**
++ * snd_usb_endpoint_release: Tear down an snd_usb_endpoint
++ *
++ * @ep: the endpoint to release
++ *
++ * This function does not care for the endpoint's use count but will tear
++ * down all the streaming URBs immediately.
++ */
++void snd_usb_endpoint_release(struct snd_usb_endpoint *ep)
++{
++	release_urbs(ep, 1);
++}
++
++/**
+  * snd_usb_endpoint_free: Free the resources of an snd_usb_endpoint
+  *
+  * @ep: the list header of the endpoint to free
+  *
+- * This function does not care for the endpoint's use count but will tear
+- * down all the streaming URBs immediately and free all resources.
++ * This free all resources of the given ep.
+  */
+ void snd_usb_endpoint_free(struct list_head *head)
+ {
+ 	struct snd_usb_endpoint *ep;
+ 
+ 	ep = list_entry(head, struct snd_usb_endpoint, list);
+-	release_urbs(ep, 1);
+ 	kfree(ep);
+ }
+ 
+diff --git a/sound/usb/endpoint.h b/sound/usb/endpoint.h
+index 1c7e8ee48abc..e61ee5c356a3 100644
+--- a/sound/usb/endpoint.h
++++ b/sound/usb/endpoint.h
+@@ -23,6 +23,7 @@ void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep);
+ void snd_usb_endpoint_sync_pending_stop(struct snd_usb_endpoint *ep);
+ int  snd_usb_endpoint_activate(struct snd_usb_endpoint *ep);
+ void snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep);
++void snd_usb_endpoint_release(struct snd_usb_endpoint *ep);
+ void snd_usb_endpoint_free(struct list_head *head);
+ 
+ int snd_usb_endpoint_implicit_feedback_sink(struct snd_usb_endpoint *ep);