diff options
author | Mike Pagano <mpagano@gentoo.org> | 2014-07-08 14:30:47 -0400 |
---|---|---|
committer | Mike Pagano <mpagano@gentoo.org> | 2014-07-08 14:30:47 -0400 |
commit | 1d92f75ee86e750cd47eb0715ba6ba4d2b6d68ee (patch) | |
tree | 63a9289b2a6462f6735364d894137f1ec06e499b | |
parent | Patch to fix frequency reported on G-PHY with /new/ firmware. See bug #516392 (diff) | |
download | linux-patches-1d92f75ee86e750cd47eb0715ba6ba4d2b6d68ee.tar.gz linux-patches-1d92f75ee86e750cd47eb0715ba6ba4d2b6d68ee.tar.bz2 linux-patches-1d92f75ee86e750cd47eb0715ba6ba4d2b6d68ee.zip |
Linux patch 3.15.43.15-6
-rw-r--r-- | 0000_README | 4 | ||||
-rw-r--r-- | 1003_linux-3.15.4.patch | 2843 |
2 files changed, 2847 insertions, 0 deletions
diff --git a/0000_README b/0000_README index 236fcc94..be759844 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 00000000..2d3f2db7 --- /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(¤t->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(¤t->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(¤t->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(¤t->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(¤t->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(®ister_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); |