diff options
| author |   Mike Pagano <mpagano@gentoo.org> | 2016-06-08 07:17:42 -0400 |
|---|---|---|
| committer | Mike Pagano <mpagano@gentoo.org> | 2016-06-08 07:17:42 -0400 |
| commit | d8670f4c5aadaf0577ffb7e424f6bfd145d5ed2f (patch) | |
| tree | af8674afa5d5be3512783d4026b52cb1a118f1ae | |
| parent | Linux patch 4.1.25 (diff) | |
| download | linux-patches-d8670f4c5aadaf0577ffb7e424f6bfd145d5ed2f.tar.gz linux-patches-d8670f4c5aadaf0577ffb7e424f6bfd145d5ed2f.tar.bz2 linux-patches-d8670f4c5aadaf0577ffb7e424f6bfd145d5ed2f.zip | |
Linux patch 4.1.264.1-31
| -rw-r--r-- | 0000_README | 4 | ||||
| -rw-r--r-- | 1025_linux-4.1.26.patch | 6090 |
2 files changed, 6094 insertions, 0 deletions
diff --git a/0000_README b/0000_README index fcfa2881..783092f3 100644 --- a/0000_README +++ b/0000_README @@ -143,6 +143,10 @@ Patch: 1024_linux-4.1.25.patch From: http://www.kernel.org Desc: Linux 4.1.25 +Patch: 1025_linux-4.1.26.patch +From: http://www.kernel.org +Desc: Linux 4.1.26 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1025_linux-4.1.26.patch b/1025_linux-4.1.26.patch new file mode 100644 index 00000000..573cabfc --- /dev/null +++ b/1025_linux-4.1.26.patch @@ -0,0 +1,6090 @@ +diff --git a/Documentation/devicetree/bindings/crypto/samsung-sss.txt b/Documentation/devicetree/bindings/crypto/samsung-sss.txt +index a6dafa83c6df..7a5ca56683cc 100644 +--- a/Documentation/devicetree/bindings/crypto/samsung-sss.txt ++++ b/Documentation/devicetree/bindings/crypto/samsung-sss.txt +@@ -23,10 +23,8 @@ Required properties: + - "samsung,exynos4210-secss" for Exynos4210, Exynos4212, Exynos4412, Exynos5250, + Exynos5260 and Exynos5420 SoCs. + - reg : Offset and length of the register set for the module +-- interrupts : interrupt specifiers of SSS module interrupts, should contain +- following entries: +- - first : feed control interrupt (required for all variants), +- - second : hash interrupt (required only for samsung,s5pv210-secss). ++- interrupts : interrupt specifiers of SSS module interrupts (one feed ++ control interrupt). + + - clocks : list of clock phandle and specifier pairs for all clocks listed in + clock-names property. +diff --git a/Documentation/serial/tty.txt b/Documentation/serial/tty.txt +index dbe6623fed1c..1e52d67d0abf 100644 +--- a/Documentation/serial/tty.txt ++++ b/Documentation/serial/tty.txt +@@ -198,9 +198,6 @@ TTY_IO_ERROR If set, causes all subsequent userspace read/write + + TTY_OTHER_CLOSED Device is a pty and the other side has closed. + +-TTY_OTHER_DONE Device is a pty and the other side has closed and +- all pending input processing has been completed. +- + TTY_NO_WRITE_SPLIT Prevent driver from splitting up writes into + smaller chunks. + +diff --git a/Makefile b/Makefile +index c2f929d78726..080a87e290b9 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 1 +-SUBLEVEL = 25 ++SUBLEVEL = 26 + EXTRAVERSION = + NAME = Series 4800 + +@@ -374,7 +374,7 @@ AFLAGS_MODULE = + LDFLAGS_MODULE = + CFLAGS_KERNEL = + AFLAGS_KERNEL = +-CFLAGS_GCOV = -fprofile-arcs -ftest-coverage ++CFLAGS_GCOV = -fprofile-arcs -ftest-coverage -fno-tree-loop-im + + + # Use USERINCLUDE when you must reference the UAPI directories only. +@@ -686,9 +686,10 @@ KBUILD_CFLAGS += $(call cc-option, -mno-global-merge,) + KBUILD_CFLAGS += $(call cc-option, -fcatch-undefined-behavior) + else + +-# This warning generated too much noise in a regular build. +-# Use make W=1 to enable this warning (see scripts/Makefile.build) ++# These warnings generated too much noise in a regular build. ++# Use make W=1 to enable them (see scripts/Makefile.build) + KBUILD_CFLAGS += $(call cc-disable-warning, unused-but-set-variable) ++KBUILD_CFLAGS += $(call cc-disable-warning, unused-const-variable) + endif + + ifdef CONFIG_FRAME_POINTER +diff --git a/arch/arm/kvm/mmu.c b/arch/arm/kvm/mmu.c +index da09ddcfcc00..691ea94897fd 100644 +--- a/arch/arm/kvm/mmu.c ++++ b/arch/arm/kvm/mmu.c +@@ -886,11 +886,14 @@ static int stage2_set_pmd_huge(struct kvm *kvm, struct kvm_mmu_memory_cache + VM_BUG_ON(pmd_present(*pmd) && pmd_pfn(*pmd) != pmd_pfn(*new_pmd)); + + old_pmd = *pmd; +- kvm_set_pmd(pmd, *new_pmd); +- if (pmd_present(old_pmd)) ++ if (pmd_present(old_pmd)) { ++ pmd_clear(pmd); + kvm_tlb_flush_vmid_ipa(kvm, addr); +- else ++ } else { + get_page(virt_to_page(pmd)); ++ } ++ ++ kvm_set_pmd(pmd, *new_pmd); + return 0; + } + +@@ -939,12 +942,14 @@ static int stage2_set_pte(struct kvm *kvm, struct kvm_mmu_memory_cache *cache, + + /* Create 2nd stage page table mapping - Level 3 */ + old_pte = *pte; +- kvm_set_pte(pte, *new_pte); +- if (pte_present(old_pte)) ++ if (pte_present(old_pte)) { ++ kvm_set_pte(pte, __pte(0)); + kvm_tlb_flush_vmid_ipa(kvm, addr); +- else ++ } else { + get_page(virt_to_page(pte)); ++ } + ++ kvm_set_pte(pte, *new_pte); + return 0; + } + +diff --git a/arch/arm64/include/asm/pgtable-hwdef.h b/arch/arm64/include/asm/pgtable-hwdef.h +index 59bfae75dc98..d007a7b5015a 100644 +--- a/arch/arm64/include/asm/pgtable-hwdef.h ++++ b/arch/arm64/include/asm/pgtable-hwdef.h +@@ -77,7 +77,6 @@ + * Section + */ + #define PMD_SECT_VALID (_AT(pmdval_t, 1) << 0) +-#define PMD_SECT_PROT_NONE (_AT(pmdval_t, 1) << 58) + #define PMD_SECT_USER (_AT(pmdval_t, 1) << 6) /* AP[1] */ + #define PMD_SECT_RDONLY (_AT(pmdval_t, 1) << 7) /* AP[2] */ + #define PMD_SECT_S (_AT(pmdval_t, 3) << 8) +diff --git a/arch/arm64/include/asm/pgtable.h b/arch/arm64/include/asm/pgtable.h +index 526a9cb218d3..f1fc3140dedb 100644 +--- a/arch/arm64/include/asm/pgtable.h ++++ b/arch/arm64/include/asm/pgtable.h +@@ -285,6 +285,7 @@ void pmdp_splitting_flush(struct vm_area_struct *vma, unsigned long address, + #endif /* CONFIG_HAVE_RCU_TABLE_FREE */ + #endif /* CONFIG_TRANSPARENT_HUGEPAGE */ + ++#define pmd_present(pmd) pte_present(pmd_pte(pmd)) + #define pmd_dirty(pmd) pte_dirty(pmd_pte(pmd)) + #define pmd_young(pmd) pte_young(pmd_pte(pmd)) + #define pmd_wrprotect(pmd) pte_pmd(pte_wrprotect(pmd_pte(pmd))) +@@ -293,7 +294,7 @@ void pmdp_splitting_flush(struct vm_area_struct *vma, unsigned long address, + #define pmd_mkwrite(pmd) pte_pmd(pte_mkwrite(pmd_pte(pmd))) + #define pmd_mkdirty(pmd) pte_pmd(pte_mkdirty(pmd_pte(pmd))) + #define pmd_mkyoung(pmd) pte_pmd(pte_mkyoung(pmd_pte(pmd))) +-#define pmd_mknotpresent(pmd) (__pmd(pmd_val(pmd) & ~PMD_TYPE_MASK)) ++#define pmd_mknotpresent(pmd) (__pmd(pmd_val(pmd) & ~PMD_SECT_VALID)) + + #define __HAVE_ARCH_PMD_WRITE + #define pmd_write(pmd) pte_write(pmd_pte(pmd)) +@@ -332,7 +333,6 @@ extern pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn, + unsigned long size, pgprot_t vma_prot); + + #define pmd_none(pmd) (!pmd_val(pmd)) +-#define pmd_present(pmd) (pmd_val(pmd)) + + #define pmd_bad(pmd) (!(pmd_val(pmd) & 2)) + +diff --git a/arch/arm64/kvm/inject_fault.c b/arch/arm64/kvm/inject_fault.c +index 648112e90ed5..3972e65fbd5a 100644 +--- a/arch/arm64/kvm/inject_fault.c ++++ b/arch/arm64/kvm/inject_fault.c +@@ -130,7 +130,7 @@ static void inject_abt64(struct kvm_vcpu *vcpu, bool is_iabt, unsigned long addr + esr |= (ESR_ELx_EC_IABT_CUR << ESR_ELx_EC_SHIFT); + + if (!is_iabt) +- esr |= ESR_ELx_EC_DABT_LOW; ++ esr |= ESR_ELx_EC_DABT_LOW << ESR_ELx_EC_SHIFT; + + vcpu_sys_reg(vcpu, ESR_EL1) = esr | ESR_ELx_FSC_EXTABT; + } +diff --git a/arch/mips/ath79/early_printk.c b/arch/mips/ath79/early_printk.c +index b955fafc58ba..d1adc59af5bf 100644 +--- a/arch/mips/ath79/early_printk.c ++++ b/arch/mips/ath79/early_printk.c +@@ -31,13 +31,15 @@ static inline void prom_putchar_wait(void __iomem *reg, u32 mask, u32 val) + } while (1); + } + ++#define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE) ++ + static void prom_putchar_ar71xx(unsigned char ch) + { + void __iomem *base = (void __iomem *)(KSEG1ADDR(AR71XX_UART_BASE)); + +- prom_putchar_wait(base + UART_LSR * 4, UART_LSR_THRE, UART_LSR_THRE); ++ prom_putchar_wait(base + UART_LSR * 4, BOTH_EMPTY, BOTH_EMPTY); + __raw_writel(ch, base + UART_TX * 4); +- prom_putchar_wait(base + UART_LSR * 4, UART_LSR_THRE, UART_LSR_THRE); ++ prom_putchar_wait(base + UART_LSR * 4, BOTH_EMPTY, BOTH_EMPTY); + } + + static void prom_putchar_ar933x(unsigned char ch) +diff --git a/arch/mips/include/asm/cacheflush.h b/arch/mips/include/asm/cacheflush.h +index 723229f4cf27..176de586a71a 100644 +--- a/arch/mips/include/asm/cacheflush.h ++++ b/arch/mips/include/asm/cacheflush.h +@@ -51,7 +51,6 @@ extern void (*flush_cache_range)(struct vm_area_struct *vma, + unsigned long start, unsigned long end); + extern void (*flush_cache_page)(struct vm_area_struct *vma, unsigned long page, unsigned long pfn); + extern void __flush_dcache_page(struct page *page); +-extern void __flush_icache_page(struct vm_area_struct *vma, struct page *page); + + #define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 1 + static inline void flush_dcache_page(struct page *page) +@@ -77,11 +76,6 @@ static inline void flush_anon_page(struct vm_area_struct *vma, + static inline void flush_icache_page(struct vm_area_struct *vma, + struct page *page) + { +- if (!cpu_has_ic_fills_f_dc && (vma->vm_flags & VM_EXEC) && +- Page_dcache_dirty(page)) { +- __flush_icache_page(vma, page); +- ClearPageDcacheDirty(page); +- } + } + + extern void (*flush_icache_range)(unsigned long start, unsigned long end); +diff --git a/arch/mips/include/asm/kvm_host.h b/arch/mips/include/asm/kvm_host.h +index 4c25823563fe..3585af093576 100644 +--- a/arch/mips/include/asm/kvm_host.h ++++ b/arch/mips/include/asm/kvm_host.h +@@ -782,7 +782,7 @@ extern enum emulation_result kvm_mips_complete_mmio_load(struct kvm_vcpu *vcpu, + + uint32_t kvm_mips_read_count(struct kvm_vcpu *vcpu); + void kvm_mips_write_count(struct kvm_vcpu *vcpu, uint32_t count); +-void kvm_mips_write_compare(struct kvm_vcpu *vcpu, uint32_t compare); ++void kvm_mips_write_compare(struct kvm_vcpu *vcpu, uint32_t compare, bool ack); + void kvm_mips_init_count(struct kvm_vcpu *vcpu); + int kvm_mips_set_count_ctl(struct kvm_vcpu *vcpu, s64 count_ctl); + int kvm_mips_set_count_resume(struct kvm_vcpu *vcpu, s64 count_resume); +diff --git a/arch/mips/include/asm/msa.h b/arch/mips/include/asm/msa.h +index af5638b12c75..38bbeda8644c 100644 +--- a/arch/mips/include/asm/msa.h ++++ b/arch/mips/include/asm/msa.h +@@ -67,6 +67,19 @@ static inline void restore_msa(struct task_struct *t) + _restore_msa(t); + } + ++static inline void init_msa_upper(void) ++{ ++ /* ++ * Check cpu_has_msa only if it's a constant. This will allow the ++ * compiler to optimise out code for CPUs without MSA without adding ++ * an extra redundant check for CPUs with MSA. ++ */ ++ if (__builtin_constant_p(cpu_has_msa) && !cpu_has_msa) ++ return; ++ ++ _init_msa_upper(); ++} ++ + #ifdef TOOLCHAIN_SUPPORTS_MSA + + #define __BUILD_MSA_CTL_REG(name, cs) \ +diff --git a/arch/mips/include/asm/pgtable.h b/arch/mips/include/asm/pgtable.h +index 7fe24aef7fdc..f33206e27d8d 100644 +--- a/arch/mips/include/asm/pgtable.h ++++ b/arch/mips/include/asm/pgtable.h +@@ -127,10 +127,14 @@ do { \ + } \ + } while(0) + ++static inline void set_pte_at(struct mm_struct *mm, unsigned long addr, ++ pte_t *ptep, pte_t pteval); ++ + #if defined(CONFIG_PHYS_ADDR_T_64BIT) && defined(CONFIG_CPU_MIPS32) + + #define pte_none(pte) (!(((pte).pte_high) & ~_PAGE_GLOBAL)) + #define pte_present(pte) ((pte).pte_low & _PAGE_PRESENT) ++#define pte_no_exec(pte) ((pte).pte_low & _PAGE_NO_EXEC) + + static inline void set_pte(pte_t *ptep, pte_t pte) + { +@@ -148,7 +152,6 @@ static inline void set_pte(pte_t *ptep, pte_t pte) + buddy->pte_high |= _PAGE_GLOBAL; + } + } +-#define set_pte_at(mm, addr, ptep, pteval) set_pte(ptep, pteval) + + static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep) + { +@@ -166,6 +169,7 @@ static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *pt + + #define pte_none(pte) (!(pte_val(pte) & ~_PAGE_GLOBAL)) + #define pte_present(pte) (pte_val(pte) & _PAGE_PRESENT) ++#define pte_no_exec(pte) (pte_val(pte) & _PAGE_NO_EXEC) + + /* + * Certain architectures need to do special things when pte's +@@ -218,7 +222,6 @@ static inline void set_pte(pte_t *ptep, pte_t pteval) + } + #endif + } +-#define set_pte_at(mm, addr, ptep, pteval) set_pte(ptep, pteval) + + static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep) + { +@@ -234,6 +237,22 @@ static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *pt + } + #endif + ++static inline void set_pte_at(struct mm_struct *mm, unsigned long addr, ++ pte_t *ptep, pte_t pteval) ++{ ++ extern void __update_cache(unsigned long address, pte_t pte); ++ ++ if (!pte_present(pteval)) ++ goto cache_sync_done; ++ ++ if (pte_present(*ptep) && (pte_pfn(*ptep) == pte_pfn(pteval))) ++ goto cache_sync_done; ++ ++ __update_cache(addr, pteval); ++cache_sync_done: ++ set_pte(ptep, pteval); ++} ++ + /* + * (pmds are folded into puds so this doesn't get actually called, + * but the define is needed for a generic inline function.) +@@ -428,15 +447,12 @@ static inline pte_t pte_modify(pte_t pte, pgprot_t newprot) + + extern void __update_tlb(struct vm_area_struct *vma, unsigned long address, + pte_t pte); +-extern void __update_cache(struct vm_area_struct *vma, unsigned long address, +- pte_t pte); + + static inline void update_mmu_cache(struct vm_area_struct *vma, + unsigned long address, pte_t *ptep) + { + pte_t pte = *ptep; + __update_tlb(vma, address, pte); +- __update_cache(vma, address, pte); + } + + static inline void update_mmu_cache_pmd(struct vm_area_struct *vma, +diff --git a/arch/mips/include/uapi/asm/siginfo.h b/arch/mips/include/uapi/asm/siginfo.h +index 2cb7fdead570..e2b5337e840f 100644 +--- a/arch/mips/include/uapi/asm/siginfo.h ++++ b/arch/mips/include/uapi/asm/siginfo.h +@@ -28,7 +28,7 @@ + + #define __ARCH_SIGSYS + +-#include <uapi/asm-generic/siginfo.h> ++#include <asm-generic/siginfo.h> + + /* We can't use generic siginfo_t, because our si_code and si_errno are swapped */ + typedef struct siginfo { +@@ -42,13 +42,13 @@ typedef struct siginfo { + + /* kill() */ + struct { +- pid_t _pid; /* sender's pid */ ++ __kernel_pid_t _pid; /* sender's pid */ + __ARCH_SI_UID_T _uid; /* sender's uid */ + } _kill; + + /* POSIX.1b timers */ + struct { +- timer_t _tid; /* timer id */ ++ __kernel_timer_t _tid; /* timer id */ + int _overrun; /* overrun count */ + char _pad[sizeof( __ARCH_SI_UID_T) - sizeof(int)]; + sigval_t _sigval; /* same as below */ +@@ -57,26 +57,26 @@ typedef struct siginfo { + + /* POSIX.1b signals */ + struct { +- pid_t _pid; /* sender's pid */ ++ __kernel_pid_t _pid; /* sender's pid */ + __ARCH_SI_UID_T _uid; /* sender's uid */ + sigval_t _sigval; + } _rt; + + /* SIGCHLD */ + struct { +- pid_t _pid; /* which child */ ++ __kernel_pid_t _pid; /* which child */ + __ARCH_SI_UID_T _uid; /* sender's uid */ + int _status; /* exit code */ +- clock_t _utime; +- clock_t _stime; ++ __kernel_clock_t _utime; ++ __kernel_clock_t _stime; + } _sigchld; + + /* IRIX SIGCHLD */ + struct { +- pid_t _pid; /* which child */ +- clock_t _utime; ++ __kernel_pid_t _pid; /* which child */ ++ __kernel_clock_t _utime; + int _status; /* exit code */ +- clock_t _stime; ++ __kernel_clock_t _stime; + } _irix_sigchld; + + /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */ +@@ -118,6 +118,4 @@ typedef struct siginfo { + #define SI_TIMER __SI_CODE(__SI_TIMER, -3) /* sent by timer expiration */ + #define SI_MESGQ __SI_CODE(__SI_MESGQ, -4) /* sent by real time mesq state change */ + +-#include <asm-generic/siginfo.h> +- + #endif /* _UAPI_ASM_SIGINFO_H */ +diff --git a/arch/mips/kernel/mips-r2-to-r6-emul.c b/arch/mips/kernel/mips-r2-to-r6-emul.c +index f2977f00911b..e19fa363c8fe 100644 +--- a/arch/mips/kernel/mips-r2-to-r6-emul.c ++++ b/arch/mips/kernel/mips-r2-to-r6-emul.c +@@ -27,6 +27,7 @@ + #include <asm/inst.h> + #include <asm/mips-r2-to-r6-emul.h> + #include <asm/local.h> ++#include <asm/mipsregs.h> + #include <asm/ptrace.h> + #include <asm/uaccess.h> + +@@ -1250,10 +1251,10 @@ fpu_emul: + " j 10b\n" + " .previous\n" + " .section __ex_table,\"a\"\n" +- " .word 1b,8b\n" +- " .word 2b,8b\n" +- " .word 3b,8b\n" +- " .word 4b,8b\n" ++ STR(PTR) " 1b,8b\n" ++ STR(PTR) " 2b,8b\n" ++ STR(PTR) " 3b,8b\n" ++ STR(PTR) " 4b,8b\n" + " .previous\n" + " .set pop\n" + : "+&r"(rt), "=&r"(rs), +@@ -1325,10 +1326,10 @@ fpu_emul: + " j 10b\n" + " .previous\n" + " .section __ex_table,\"a\"\n" +- " .word 1b,8b\n" +- " .word 2b,8b\n" +- " .word 3b,8b\n" +- " .word 4b,8b\n" ++ STR(PTR) " 1b,8b\n" ++ STR(PTR) " 2b,8b\n" ++ STR(PTR) " 3b,8b\n" ++ STR(PTR) " 4b,8b\n" + " .previous\n" + " .set pop\n" + : "+&r"(rt), "=&r"(rs), +@@ -1396,10 +1397,10 @@ fpu_emul: + " j 9b\n" + " .previous\n" + " .section __ex_table,\"a\"\n" +- " .word 1b,8b\n" +- " .word 2b,8b\n" +- " .word 3b,8b\n" +- " .word 4b,8b\n" ++ STR(PTR) " 1b,8b\n" ++ STR(PTR) " 2b,8b\n" ++ STR(PTR) " 3b,8b\n" ++ STR(PTR) " 4b,8b\n" + " .previous\n" + " .set pop\n" + : "+&r"(rt), "=&r"(rs), +@@ -1466,10 +1467,10 @@ fpu_emul: + " j 9b\n" + " .previous\n" + " .section __ex_table,\"a\"\n" +- " .word 1b,8b\n" +- " .word 2b,8b\n" +- " .word 3b,8b\n" +- " .word 4b,8b\n" ++ STR(PTR) " 1b,8b\n" ++ STR(PTR) " 2b,8b\n" ++ STR(PTR) " 3b,8b\n" ++ STR(PTR) " 4b,8b\n" + " .previous\n" + " .set pop\n" + : "+&r"(rt), "=&r"(rs), +@@ -1581,14 +1582,14 @@ fpu_emul: + " j 9b\n" + " .previous\n" + " .section __ex_table,\"a\"\n" +- " .word 1b,8b\n" +- " .word 2b,8b\n" +- " .word 3b,8b\n" +- " .word 4b,8b\n" +- " .word 5b,8b\n" +- " .word 6b,8b\n" +- " .word 7b,8b\n" +- " .word 0b,8b\n" ++ STR(PTR) " 1b,8b\n" ++ STR(PTR) " 2b,8b\n" ++ STR(PTR) " 3b,8b\n" ++ STR(PTR) " 4b,8b\n" ++ STR(PTR) " 5b,8b\n" ++ STR(PTR) " 6b,8b\n" ++ STR(PTR) " 7b,8b\n" ++ STR(PTR) " 0b,8b\n" + " .previous\n" + " .set pop\n" + : "+&r"(rt), "=&r"(rs), +@@ -1700,14 +1701,14 @@ fpu_emul: + " j 9b\n" + " .previous\n" + " .section __ex_table,\"a\"\n" +- " .word 1b,8b\n" +- " .word 2b,8b\n" +- " .word 3b,8b\n" +- " .word 4b,8b\n" +- " .word 5b,8b\n" +- " .word 6b,8b\n" +- " .word 7b,8b\n" +- " .word 0b,8b\n" ++ STR(PTR) " 1b,8b\n" ++ STR(PTR) " 2b,8b\n" ++ STR(PTR) " 3b,8b\n" ++ STR(PTR) " 4b,8b\n" ++ STR(PTR) " 5b,8b\n" ++ STR(PTR) " 6b,8b\n" ++ STR(PTR) " 7b,8b\n" ++ STR(PTR) " 0b,8b\n" + " .previous\n" + " .set pop\n" + : "+&r"(rt), "=&r"(rs), +@@ -1819,14 +1820,14 @@ fpu_emul: + " j 9b\n" + " .previous\n" + " .section __ex_table,\"a\"\n" +- " .word 1b,8b\n" +- " .word 2b,8b\n" +- " .word 3b,8b\n" +- " .word 4b,8b\n" +- " .word 5b,8b\n" +- " .word 6b,8b\n" +- " .word 7b,8b\n" +- " .word 0b,8b\n" ++ STR(PTR) " 1b,8b\n" ++ STR(PTR) " 2b,8b\n" ++ STR(PTR) " 3b,8b\n" ++ STR(PTR) " 4b,8b\n" ++ STR(PTR) " 5b,8b\n" ++ STR(PTR) " 6b,8b\n" ++ STR(PTR) " 7b,8b\n" ++ STR(PTR) " 0b,8b\n" + " .previous\n" + " .set pop\n" + : "+&r"(rt), "=&r"(rs), +@@ -1937,14 +1938,14 @@ fpu_emul: + " j 9b\n" + " .previous\n" + " .section __ex_table,\"a\"\n" +- " .word 1b,8b\n" +- " .word 2b,8b\n" +- " .word 3b,8b\n" +- " .word 4b,8b\n" +- " .word 5b,8b\n" +- " .word 6b,8b\n" +- " .word 7b,8b\n" +- " .word 0b,8b\n" ++ STR(PTR) " 1b,8b\n" ++ STR(PTR) " 2b,8b\n" ++ STR(PTR) " 3b,8b\n" ++ STR(PTR) " 4b,8b\n" ++ STR(PTR) " 5b,8b\n" ++ STR(PTR) " 6b,8b\n" ++ STR(PTR) " 7b,8b\n" ++ STR(PTR) " 0b,8b\n" + " .previous\n" + " .set pop\n" + : "+&r"(rt), "=&r"(rs), +@@ -1999,7 +2000,7 @@ fpu_emul: + "j 2b\n" + ".previous\n" + ".section __ex_table,\"a\"\n" +- ".word 1b, 3b\n" ++ STR(PTR) " 1b,3b\n" + ".previous\n" + : "=&r"(res), "+&r"(err) + : "r"(vaddr), "i"(SIGSEGV) +@@ -2057,7 +2058,7 @@ fpu_emul: + "j 2b\n" + ".previous\n" + ".section __ex_table,\"a\"\n" +- ".word 1b, 3b\n" ++ STR(PTR) " 1b,3b\n" + ".previous\n" + : "+&r"(res), "+&r"(err) + : "r"(vaddr), "i"(SIGSEGV)); +@@ -2118,7 +2119,7 @@ fpu_emul: + "j 2b\n" + ".previous\n" + ".section __ex_table,\"a\"\n" +- ".word 1b, 3b\n" ++ STR(PTR) " 1b,3b\n" + ".previous\n" + : "=&r"(res), "+&r"(err) + : "r"(vaddr), "i"(SIGSEGV) +@@ -2181,7 +2182,7 @@ fpu_emul: + "j 2b\n" + ".previous\n" + ".section __ex_table,\"a\"\n" +- ".word 1b, 3b\n" ++ STR(PTR) " 1b,3b\n" + ".previous\n" + : "+&r"(res), "+&r"(err) + : "r"(vaddr), "i"(SIGSEGV)); +diff --git a/arch/mips/kernel/process.c b/arch/mips/kernel/process.c +index f2975d4d1e44..89847bee2b53 100644 +--- a/arch/mips/kernel/process.c ++++ b/arch/mips/kernel/process.c +@@ -457,7 +457,7 @@ unsigned long notrace unwind_stack_by_address(unsigned long stack_page, + *sp + sizeof(*regs) <= stack_page + THREAD_SIZE - 32) { + regs = (struct pt_regs *)*sp; + pc = regs->cp0_epc; +- if (__kernel_text_address(pc)) { ++ if (!user_mode(regs) && __kernel_text_address(pc)) { + *sp = regs->regs[29]; + *ra = regs->regs[31]; + return pc; +@@ -603,6 +603,9 @@ int mips_set_process_fp_mode(struct task_struct *task, unsigned int value) + if (!(value & PR_FP_MODE_FR) && cpu_has_fpu && cpu_has_mips_r6) + return -EOPNOTSUPP; + ++ /* Proceed with the mode switch */ ++ preempt_disable(); ++ + /* Save FP & vector context, then disable FPU & MSA */ + if (task->signal == current->signal) + lose_fpu(1); +@@ -661,6 +664,7 @@ int mips_set_process_fp_mode(struct task_struct *task, unsigned int value) + + /* Allow threads to use FP again */ + atomic_set(&task->mm->context.fp_mode_switching, 0); ++ preempt_enable(); + + return 0; + } +diff --git a/arch/mips/kernel/ptrace.c b/arch/mips/kernel/ptrace.c +index e933a309f2ea..f7968b5149b0 100644 +--- a/arch/mips/kernel/ptrace.c ++++ b/arch/mips/kernel/ptrace.c +@@ -56,8 +56,7 @@ static void init_fp_ctx(struct task_struct *target) + /* Begin with data registers set to all 1s... */ + memset(&target->thread.fpu.fpr, ~0, sizeof(target->thread.fpu.fpr)); + +- /* ...and FCSR zeroed */ +- target->thread.fpu.fcr31 = 0; ++ /* FCSR has been preset by `mips_set_personality_nan'. */ + + /* + * Record that the target has "used" math, such that the context +@@ -79,6 +78,22 @@ void ptrace_disable(struct task_struct *child) + } + + /* ++ * Poke at FCSR according to its mask. Don't set the cause bits as ++ * this is currently not handled correctly in FP context restoration ++ * and will cause an oops if a corresponding enable bit is set. ++ */ ++static void ptrace_setfcr31(struct task_struct *child, u32 value) ++{ ++ u32 fcr31; ++ u32 mask; ++ ++ value &= ~FPU_CSR_ALL_X; ++ fcr31 = child->thread.fpu.fcr31; ++ mask = boot_cpu_data.fpu_msk31; ++ child->thread.fpu.fcr31 = (value & ~mask) | (fcr31 & mask); ++} ++ ++/* + * Read a general register set. We always use the 64-bit format, even + * for 32-bit kernels and for 32-bit processes on a 64-bit kernel. + * Registers are sign extended to fill the available space. +@@ -158,9 +173,7 @@ int ptrace_setfpregs(struct task_struct *child, __u32 __user *data) + { + union fpureg *fregs; + u64 fpr_val; +- u32 fcr31; + u32 value; +- u32 mask; + int i; + + if (!access_ok(VERIFY_READ, data, 33 * 8)) +@@ -175,9 +188,7 @@ int ptrace_setfpregs(struct task_struct *child, __u32 __user *data) + } + + __get_user(value, data + 64); +- fcr31 = child->thread.fpu.fcr31; +- mask = boot_cpu_data.fpu_msk31; +- child->thread.fpu.fcr31 = (value & ~mask) | (fcr31 & mask); ++ ptrace_setfcr31(child, value); + + /* FIR may not be written. */ + +@@ -720,7 +731,7 @@ long arch_ptrace(struct task_struct *child, long request, + break; + #endif + case FPC_CSR: +- child->thread.fpu.fcr31 = data & ~FPU_CSR_ALL_X; ++ ptrace_setfcr31(child, data); + break; + case DSP_BASE ... DSP_BASE + 5: { + dspreg_t *dregs; +diff --git a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c +index 54923d6b7e16..74403953e407 100644 +--- a/arch/mips/kernel/traps.c ++++ b/arch/mips/kernel/traps.c +@@ -143,7 +143,7 @@ static void show_backtrace(struct task_struct *task, const struct pt_regs *regs) + if (!task) + task = current; + +- if (raw_show_trace || !__kernel_text_address(pc)) { ++ if (raw_show_trace || user_mode(regs) || !__kernel_text_address(pc)) { + show_raw_backtrace(sp); + return; + } +@@ -1228,7 +1228,7 @@ static int enable_restore_fp_context(int msa) + err = init_fpu(); + if (msa && !err) { + enable_msa(); +- _init_msa_upper(); ++ init_msa_upper(); + set_thread_flag(TIF_USEDMSA); + set_thread_flag(TIF_MSA_CTX_LIVE); + } +@@ -1291,7 +1291,7 @@ static int enable_restore_fp_context(int msa) + */ + prior_msa = test_and_set_thread_flag(TIF_MSA_CTX_LIVE); + if (!prior_msa && was_fpu_owner) { +- _init_msa_upper(); ++ init_msa_upper(); + + goto out; + } +@@ -1308,7 +1308,7 @@ static int enable_restore_fp_context(int msa) + * of each vector register such that it cannot see data left + * behind by another task. + */ +- _init_msa_upper(); ++ init_msa_upper(); + } else { + /* We need to restore the vector context. */ + restore_msa(current); +diff --git a/arch/mips/kvm/emulate.c b/arch/mips/kvm/emulate.c +index 41b1b090f56f..dc10c77b7500 100644 +--- a/arch/mips/kvm/emulate.c ++++ b/arch/mips/kvm/emulate.c +@@ -302,12 +302,31 @@ static inline ktime_t kvm_mips_count_time(struct kvm_vcpu *vcpu) + */ + static uint32_t kvm_mips_read_count_running(struct kvm_vcpu *vcpu, ktime_t now) + { +- ktime_t expires; ++ struct mips_coproc *cop0 = vcpu->arch.cop0; ++ ktime_t expires, threshold; ++ uint32_t count, compare; + int running; + +- /* Is the hrtimer pending? */ ++ /* Calculate the biased and scaled guest CP0_Count */ ++ count = vcpu->arch.count_bias + kvm_mips_ktime_to_count(vcpu, now); ++ compare = kvm_read_c0_guest_compare(cop0); ++ ++ /* ++ * Find whether CP0_Count has reached the closest timer interrupt. If ++ * not, we shouldn't inject it. ++ */ ++ if ((int32_t)(count - compare) < 0) ++ return count; ++ ++ /* ++ * The CP0_Count we're going to return has already reached the closest ++ * timer interrupt. Quickly check if it really is a new interrupt by ++ * looking at whether the interval until the hrtimer expiry time is ++ * less than 1/4 of the timer period. ++ */ + expires = hrtimer_get_expires(&vcpu->arch.comparecount_timer); +- if (ktime_compare(now, expires) >= 0) { ++ threshold = ktime_add_ns(now, vcpu->arch.count_period / 4); ++ if (ktime_before(expires, threshold)) { + /* + * Cancel it while we handle it so there's no chance of + * interference with the timeout handler. +@@ -329,8 +348,7 @@ static uint32_t kvm_mips_read_count_running(struct kvm_vcpu *vcpu, ktime_t now) + } + } + +- /* Return the biased and scaled guest CP0_Count */ +- return vcpu->arch.count_bias + kvm_mips_ktime_to_count(vcpu, now); ++ return count; + } + + /** +@@ -420,32 +438,6 @@ static void kvm_mips_resume_hrtimer(struct kvm_vcpu *vcpu, + } + + /** +- * kvm_mips_update_hrtimer() - Update next expiry time of hrtimer. +- * @vcpu: Virtual CPU. +- * +- * Recalculates and updates the expiry time of the hrtimer. This can be used +- * after timer parameters have been altered which do not depend on the time that +- * the change occurs (in those cases kvm_mips_freeze_hrtimer() and +- * kvm_mips_resume_hrtimer() are used directly). +- * +- * It is guaranteed that no timer interrupts will be lost in the process. +- * +- * Assumes !kvm_mips_count_disabled(@vcpu) (guest CP0_Count timer is running). +- */ +-static void kvm_mips_update_hrtimer(struct kvm_vcpu *vcpu) +-{ +- ktime_t now; +- uint32_t count; +- +- /* +- * freeze_hrtimer takes care of a timer interrupts <= count, and +- * resume_hrtimer the hrtimer takes care of a timer interrupts > count. +- */ +- now = kvm_mips_freeze_hrtimer(vcpu, &count); +- kvm_mips_resume_hrtimer(vcpu, now, count); +-} +- +-/** + * kvm_mips_write_count() - Modify the count and update timer. + * @vcpu: Virtual CPU. + * @count: Guest CP0_Count value to set. +@@ -540,23 +532,42 @@ int kvm_mips_set_count_hz(struct kvm_vcpu *vcpu, s64 count_hz) + * kvm_mips_write_compare() - Modify compare and update timer. + * @vcpu: Virtual CPU. + * @compare: New CP0_Compare value. ++ * @ack: Whether to acknowledge timer interrupt. + * + * Update CP0_Compare to a new value and update the timeout. ++ * If @ack, atomically acknowledge any pending timer interrupt, otherwise ensure ++ * any pending timer interrupt is preserved. + */ +-void kvm_mips_write_compare(struct kvm_vcpu *vcpu, uint32_t compare) ++void kvm_mips_write_compare(struct kvm_vcpu *vcpu, uint32_t compare, bool ack) + { + struct mips_coproc *cop0 = vcpu->arch.cop0; ++ int dc; ++ u32 old_compare = kvm_read_c0_guest_compare(cop0); ++ ktime_t now; ++ uint32_t count; + + /* if unchanged, must just be an ack */ +- if (kvm_read_c0_guest_compare(cop0) == compare) ++ if (old_compare == compare) { ++ if (!ack) ++ return; ++ kvm_mips_callbacks->dequeue_timer_int(vcpu); ++ kvm_write_c0_guest_compare(cop0, compare); + return; ++ } ++ ++ /* freeze_hrtimer() takes care of timer interrupts <= count */ ++ dc = kvm_mips_count_disabled(vcpu); ++ if (!dc) ++ now = kvm_mips_freeze_hrtimer(vcpu, &count); ++ ++ if (ack) ++ kvm_mips_callbacks->dequeue_timer_int(vcpu); + +- /* Update compare */ + kvm_write_c0_guest_compare(cop0, compare); + +- /* Update timeout if count enabled */ +- if (!kvm_mips_count_disabled(vcpu)) +- kvm_mips_update_hrtimer(vcpu); ++ /* resume_hrtimer() takes care of timer interrupts > count */ ++ if (!dc) ++ kvm_mips_resume_hrtimer(vcpu, now, count); + } + + /** +@@ -1095,9 +1106,9 @@ enum emulation_result kvm_mips_emulate_CP0(uint32_t inst, uint32_t *opc, + + /* If we are writing to COMPARE */ + /* Clear pending timer interrupt, if any */ +- kvm_mips_callbacks->dequeue_timer_int(vcpu); + kvm_mips_write_compare(vcpu, +- vcpu->arch.gprs[rt]); ++ vcpu->arch.gprs[rt], ++ true); + } else if ((rd == MIPS_CP0_STATUS) && (sel == 0)) { + unsigned int old_val, val, change; + +diff --git a/arch/mips/kvm/trap_emul.c b/arch/mips/kvm/trap_emul.c +index d836ed5b0bc7..307cc4c98bdd 100644 +--- a/arch/mips/kvm/trap_emul.c ++++ b/arch/mips/kvm/trap_emul.c +@@ -547,7 +547,7 @@ static int kvm_trap_emul_set_one_reg(struct kvm_vcpu *vcpu, + kvm_mips_write_count(vcpu, v); + break; + case KVM_REG_MIPS_CP0_COMPARE: +- kvm_mips_write_compare(vcpu, v); ++ kvm_mips_write_compare(vcpu, v, false); + break; + case KVM_REG_MIPS_CP0_CAUSE: + /* +diff --git a/arch/mips/math-emu/cp1emu.c b/arch/mips/math-emu/cp1emu.c +index 2b95e34fa9e8..81f645973eb3 100644 +--- a/arch/mips/math-emu/cp1emu.c ++++ b/arch/mips/math-emu/cp1emu.c +@@ -445,9 +445,11 @@ static int isBranchInstr(struct pt_regs *regs, struct mm_decoded_insn dec_insn, + case spec_op: + switch (insn.r_format.func) { + case jalr_op: +- regs->regs[insn.r_format.rd] = +- regs->cp0_epc + dec_insn.pc_inc + +- dec_insn.next_pc_inc; ++ if (insn.r_format.rd != 0) { ++ regs->regs[insn.r_format.rd] = ++ regs->cp0_epc + dec_insn.pc_inc + ++ dec_insn.next_pc_inc; ++ } + /* Fall through */ + case jr_op: + /* For R6, JR already emulated in jalr_op */ +diff --git a/arch/mips/mm/cache.c b/arch/mips/mm/cache.c +index 77d96db8253c..8a648e20b521 100644 +--- a/arch/mips/mm/cache.c ++++ b/arch/mips/mm/cache.c +@@ -16,6 +16,7 @@ + #include <linux/mm.h> + + #include <asm/cacheflush.h> ++#include <asm/highmem.h> + #include <asm/processor.h> + #include <asm/cpu.h> + #include <asm/cpu-features.h> +@@ -83,8 +84,6 @@ void __flush_dcache_page(struct page *page) + struct address_space *mapping = page_mapping(page); + unsigned long addr; + +- if (PageHighMem(page)) +- return; + if (mapping && !mapping_mapped(mapping)) { + SetPageDcacheDirty(page); + return; +@@ -95,8 +94,15 @@ void __flush_dcache_page(struct page *page) + * case is for exec env/arg pages and those are %99 certainly going to + * get faulted into the tlb (and thus flushed) anyways. + */ +- addr = (unsigned long) page_address(page); ++ if (PageHighMem(page)) ++ addr = (unsigned long)kmap_atomic(page); ++ else ++ addr = (unsigned long)page_address(page); ++ + flush_data_cache_page(addr); ++ ++ if (PageHighMem(page)) ++ __kunmap_atomic((void *)addr); + } + + EXPORT_SYMBOL(__flush_dcache_page); +@@ -119,33 +125,28 @@ void __flush_anon_page(struct page *page, unsigned long vmaddr) + + EXPORT_SYMBOL(__flush_anon_page); + +-void __flush_icache_page(struct vm_area_struct *vma, struct page *page) +-{ +- unsigned long addr; +- +- if (PageHighMem(page)) +- return; +- +- addr = (unsigned long) page_address(page); +- flush_data_cache_page(addr); +-} +-EXPORT_SYMBOL_GPL(__flush_icache_page); +- +-void __update_cache(struct vm_area_struct *vma, unsigned long address, +- pte_t pte) ++void __update_cache(unsigned long address, pte_t pte) + { + struct page *page; + unsigned long pfn, addr; +- int exec = (vma->vm_flags & VM_EXEC) && !cpu_has_ic_fills_f_dc; ++ int exec = !pte_no_exec(pte) && !cpu_has_ic_fills_f_dc; + + pfn = pte_pfn(pte); + if (unlikely(!pfn_valid(pfn))) + return; + page = pfn_to_page(pfn); +- if (page_mapping(page) && Page_dcache_dirty(page)) { +- addr = (unsigned long) page_address(page); ++ if (Page_dcache_dirty(page)) { ++ if (PageHighMem(page)) ++ addr = (unsigned long)kmap_atomic(page); ++ else ++ addr = (unsigned long)page_address(page); ++ + if (exec || pages_do_alias(addr, address & PAGE_MASK)) + flush_data_cache_page(addr); ++ ++ if (PageHighMem(page)) ++ __kunmap_atomic((void *)addr); ++ + ClearPageDcacheDirty(page); + } + } +diff --git a/arch/powerpc/kernel/eeh.c b/arch/powerpc/kernel/eeh.c +index cb565ad0a5b6..9a4e71261fca 100644 +--- a/arch/powerpc/kernel/eeh.c ++++ b/arch/powerpc/kernel/eeh.c +@@ -1073,7 +1073,7 @@ void eeh_add_device_early(struct pci_dn *pdn) + struct pci_controller *phb; + struct eeh_dev *edev = pdn_to_eeh_dev(pdn); + +- if (!edev || !eeh_enabled()) ++ if (!edev) + return; + + if (!eeh_has_flag(EEH_PROBE_MODE_DEVTREE)) +diff --git a/arch/powerpc/kernel/eeh_driver.c b/arch/powerpc/kernel/eeh_driver.c +index 90cc67904dc6..6d04c9efb496 100644 +--- a/arch/powerpc/kernel/eeh_driver.c ++++ b/arch/powerpc/kernel/eeh_driver.c +@@ -166,6 +166,16 @@ static void *eeh_dev_save_state(void *data, void *userdata) + if (!edev) + return NULL; + ++ /* ++ * We cannot access the config space on some adapters. ++ * Otherwise, it will cause fenced PHB. We don't save ++ * the content in their config space and will restore ++ * from the initial config space saved when the EEH ++ * device is created. ++ */ ++ if (edev->pe && (edev->pe->state & EEH_PE_CFG_RESTRICTED)) ++ return NULL; ++ + pdev = eeh_dev_to_pci_dev(edev); + if (!pdev) + return NULL; +@@ -305,6 +315,19 @@ static void *eeh_dev_restore_state(void *data, void *userdata) + if (!edev) + return NULL; + ++ /* ++ * The content in the config space isn't saved because ++ * the blocked config space on some adapters. We have ++ * to restore the initial saved config space when the ++ * EEH device is created. ++ */ ++ if (edev->pe && (edev->pe->state & EEH_PE_CFG_RESTRICTED)) { ++ if (list_is_last(&edev->list, &edev->pe->edevs)) ++ eeh_pe_restore_bars(edev->pe); ++ ++ return NULL; ++ } ++ + pdev = eeh_dev_to_pci_dev(edev); + if (!pdev) + return NULL; +@@ -502,9 +525,6 @@ int eeh_pe_reset_and_recover(struct eeh_pe *pe) + /* Save states */ + eeh_pe_dev_traverse(pe, eeh_dev_save_state, NULL); + +- /* Report error */ +- eeh_pe_dev_traverse(pe, eeh_report_error, &result); +- + /* Issue reset */ + ret = eeh_reset_pe(pe); + if (ret) { +diff --git a/arch/powerpc/kernel/exceptions-64s.S b/arch/powerpc/kernel/exceptions-64s.S +index 9519e6bdc6d7..7662bfae0493 100644 +--- a/arch/powerpc/kernel/exceptions-64s.S ++++ b/arch/powerpc/kernel/exceptions-64s.S +@@ -963,11 +963,6 @@ hv_facility_unavailable_relon_trampoline: + #endif + STD_RELON_EXCEPTION_PSERIES(0x5700, 0x1700, altivec_assist) + +- /* Other future vectors */ +- .align 7 +- .globl __end_interrupts +-__end_interrupts: +- + .align 7 + system_call_entry_direct: + #if defined(CONFIG_RELOCATABLE) +@@ -1261,6 +1256,17 @@ __end_handlers: + STD_RELON_EXCEPTION_PSERIES_OOL(0xf60, facility_unavailable) + STD_RELON_EXCEPTION_HV_OOL(0xf80, hv_facility_unavailable) + ++ /* ++ * The __end_interrupts marker must be past the out-of-line (OOL) ++ * handlers, so that they are copied to real address 0x100 when running ++ * a relocatable kernel. This ensures they can be reached from the short ++ * trampoline handlers (like 0x4f00, 0x4f20, etc.) which branch ++ * directly, without using LOAD_HANDLER(). ++ */ ++ .align 7 ++ .globl __end_interrupts ++__end_interrupts: ++ + #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) + /* + * Data area reserved for FWNMI option. +diff --git a/arch/x86/kernel/cpu/perf_event_intel_pt.c b/arch/x86/kernel/cpu/perf_event_intel_pt.c +index 123ff1bb2f60..cb6baa2252b7 100644 +--- a/arch/x86/kernel/cpu/perf_event_intel_pt.c ++++ b/arch/x86/kernel/cpu/perf_event_intel_pt.c +@@ -633,6 +633,7 @@ static int pt_buffer_reset_markers(struct pt_buffer *buf, + + /* clear STOP and INT from current entry */ + buf->topa_index[buf->stop_pos]->stop = 0; ++ buf->topa_index[buf->stop_pos]->intr = 0; + buf->topa_index[buf->intr_pos]->intr = 0; + + /* how many pages till the STOP marker */ +@@ -657,6 +658,7 @@ static int pt_buffer_reset_markers(struct pt_buffer *buf, + buf->intr_pos = idx; + + buf->topa_index[buf->stop_pos]->stop = 1; ++ buf->topa_index[buf->stop_pos]->intr = 1; + buf->topa_index[buf->intr_pos]->intr = 1; + + return 0; +diff --git a/arch/x86/pci/xen.c b/arch/x86/pci/xen.c +index d22f4b5bbc04..6b8b1073d9ec 100644 +--- a/arch/x86/pci/xen.c ++++ b/arch/x86/pci/xen.c +@@ -488,8 +488,11 @@ int __init pci_xen_initial_domain(void) + #endif + __acpi_register_gsi = acpi_register_gsi_xen; + __acpi_unregister_gsi = NULL; +- /* Pre-allocate legacy irqs */ +- for (irq = 0; irq < nr_legacy_irqs(); irq++) { ++ /* ++ * Pre-allocate the legacy IRQs. Use NR_LEGACY_IRQS here ++ * because we don't have a PIC and thus nr_legacy_irqs() is zero. ++ */ ++ for (irq = 0; irq < NR_IRQS_LEGACY; irq++) { + int trigger, polarity; + + if (acpi_get_override_irq(irq, &trigger, &polarity) == -1) +diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c +index 98f5316aad72..de039384ae7e 100644 +--- a/drivers/acpi/osl.c ++++ b/drivers/acpi/osl.c +@@ -138,7 +138,7 @@ static struct osi_linux { + unsigned int enable:1; + unsigned int dmi:1; + unsigned int cmdline:1; +- unsigned int default_disabling:1; ++ u8 default_disabling; + } osi_linux = {0, 0, 0, 0}; + + static u32 acpi_osi_handler(acpi_string interface, u32 supported) +@@ -1452,10 +1452,13 @@ void __init acpi_osi_setup(char *str) + if (*str == '!') { + str++; + if (*str == '\0') { +- osi_linux.default_disabling = 1; ++ /* Do not override acpi_osi=!* */ ++ if (!osi_linux.default_disabling) ++ osi_linux.default_disabling = ++ ACPI_DISABLE_ALL_VENDOR_STRINGS; + return; + } else if (*str == '*') { +- acpi_update_interfaces(ACPI_DISABLE_ALL_STRINGS); ++ osi_linux.default_disabling = ACPI_DISABLE_ALL_STRINGS; + for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) { + osi = &osi_setup_entries[i]; + osi->enable = false; +@@ -1528,10 +1531,13 @@ static void __init acpi_osi_setup_late(void) + acpi_status status; + + if (osi_linux.default_disabling) { +- status = acpi_update_interfaces(ACPI_DISABLE_ALL_VENDOR_STRINGS); ++ status = acpi_update_interfaces(osi_linux.default_disabling); + + if (ACPI_SUCCESS(status)) +- printk(KERN_INFO PREFIX "Disabled all _OSI OS vendors\n"); ++ printk(KERN_INFO PREFIX "Disabled all _OSI OS vendors%s\n", ++ osi_linux.default_disabling == ++ ACPI_DISABLE_ALL_STRINGS ? ++ " and feature groups" : ""); + } + + for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) { +diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c +index 3d874eca7104..9f198da6b19f 100644 +--- a/drivers/base/power/main.c ++++ b/drivers/base/power/main.c +@@ -1259,14 +1259,15 @@ int dpm_suspend_late(pm_message_t state) + error = device_suspend_late(dev); + + mutex_lock(&dpm_list_mtx); ++ if (!list_empty(&dev->power.entry)) ++ list_move(&dev->power.entry, &dpm_late_early_list); ++ + if (error) { + pm_dev_err(dev, state, " late", error); + dpm_save_failed_dev(dev_name(dev)); + put_device(dev); + break; + } +- if (!list_empty(&dev->power.entry)) +- list_move(&dev->power.entry, &dpm_late_early_list); + put_device(dev); + + if (async_error) +diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c +index 5070c4fe8542..5b06452e2af2 100644 +--- a/drivers/base/power/runtime.c ++++ b/drivers/base/power/runtime.c +@@ -1462,11 +1462,16 @@ int pm_runtime_force_resume(struct device *dev) + goto out; + } + +- ret = callback(dev); ++ ret = pm_runtime_set_active(dev); + if (ret) + goto out; + +- pm_runtime_set_active(dev); ++ ret = callback(dev); ++ if (ret) { ++ pm_runtime_set_suspended(dev); ++ goto out; ++ } ++ + pm_runtime_mark_last_busy(dev); + out: + pm_runtime_enable(dev); +diff --git a/drivers/bluetooth/hci_vhci.c b/drivers/bluetooth/hci_vhci.c +index 6653473f2757..eaa646dfa783 100644 +--- a/drivers/bluetooth/hci_vhci.c ++++ b/drivers/bluetooth/hci_vhci.c +@@ -50,6 +50,7 @@ struct vhci_data { + wait_queue_head_t read_wait; + struct sk_buff_head readq; + ++ struct mutex open_mutex; + struct delayed_work open_timeout; + }; + +@@ -95,12 +96,15 @@ static int vhci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) + return 0; + } + +-static int vhci_create_device(struct vhci_data *data, __u8 opcode) ++static int __vhci_create_device(struct vhci_data *data, __u8 opcode) + { + struct hci_dev *hdev; + struct sk_buff *skb; + __u8 dev_type; + ++ if (data->hdev) ++ return -EBADFD; ++ + /* bits 0-1 are dev_type (BR/EDR or AMP) */ + dev_type = opcode & 0x03; + +@@ -159,6 +163,17 @@ static int vhci_create_device(struct vhci_data *data, __u8 opcode) + return 0; + } + ++static int vhci_create_device(struct vhci_data *data, __u8 opcode) ++{ ++ int err; ++ ++ mutex_lock(&data->open_mutex); ++ err = __vhci_create_device(data, opcode); ++ mutex_unlock(&data->open_mutex); ++ ++ return err; ++} ++ + static inline ssize_t vhci_get_user(struct vhci_data *data, + struct iov_iter *from) + { +@@ -197,11 +212,6 @@ static inline ssize_t vhci_get_user(struct vhci_data *data, + break; + + case HCI_VENDOR_PKT: +- if (data->hdev) { +- kfree_skb(skb); +- return -EBADFD; +- } +- + cancel_delayed_work_sync(&data->open_timeout); + + opcode = *((__u8 *) skb->data); +@@ -328,6 +338,7 @@ static int vhci_open(struct inode *inode, struct file *file) + skb_queue_head_init(&data->readq); + init_waitqueue_head(&data->read_wait); + ++ mutex_init(&data->open_mutex); + INIT_DELAYED_WORK(&data->open_timeout, vhci_open_timeout); + + file->private_data = data; +@@ -341,15 +352,18 @@ static int vhci_open(struct inode *inode, struct file *file) + static int vhci_release(struct inode *inode, struct file *file) + { + struct vhci_data *data = file->private_data; +- struct hci_dev *hdev = data->hdev; ++ struct hci_dev *hdev; + + cancel_delayed_work_sync(&data->open_timeout); + ++ hdev = data->hdev; ++ + if (hdev) { + hci_unregister_dev(hdev); + hci_free_dev(hdev); + } + ++ skb_queue_purge(&data->readq); + file->private_data = NULL; + kfree(data); + +diff --git a/drivers/cpuidle/coupled.c b/drivers/cpuidle/coupled.c +index 7936dce4b878..8a31e17d0ee9 100644 +--- a/drivers/cpuidle/coupled.c ++++ b/drivers/cpuidle/coupled.c +@@ -176,14 +176,12 @@ void cpuidle_coupled_parallel_barrier(struct cpuidle_device *dev, atomic_t *a) + + /** + * cpuidle_state_is_coupled - check if a state is part of a coupled set +- * @dev: struct cpuidle_device for the current cpu + * @drv: struct cpuidle_driver for the platform + * @state: index of the target state in drv->states + * + * Returns true if the target state is coupled with cpus besides this one + */ +-bool cpuidle_state_is_coupled(struct cpuidle_device *dev, +- struct cpuidle_driver *drv, int state) ++bool cpuidle_state_is_coupled(struct cpuidle_driver *drv, int state) + { + return drv->states[state].flags & CPUIDLE_FLAG_COUPLED; + } +diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c +index 61c417b9e53f..81f60351aaf3 100644 +--- a/drivers/cpuidle/cpuidle.c ++++ b/drivers/cpuidle/cpuidle.c +@@ -185,7 +185,7 @@ int cpuidle_enter_state(struct cpuidle_device *dev, struct cpuidle_driver *drv, + tick_broadcast_exit(); + } + +- if (!cpuidle_state_is_coupled(dev, drv, entered_state)) ++ if (!cpuidle_state_is_coupled(drv, index)) + local_irq_enable(); + + diff = ktime_to_us(ktime_sub(time_end, time_start)); +@@ -234,7 +234,7 @@ int cpuidle_select(struct cpuidle_driver *drv, struct cpuidle_device *dev) + int cpuidle_enter(struct cpuidle_driver *drv, struct cpuidle_device *dev, + int index) + { +- if (cpuidle_state_is_coupled(dev, drv, index)) ++ if (cpuidle_state_is_coupled(drv, index)) + return cpuidle_enter_state_coupled(dev, drv, index); + return cpuidle_enter_state(dev, drv, index); + } +@@ -404,6 +404,8 @@ static void __cpuidle_unregister_device(struct cpuidle_device *dev) + list_del(&dev->device_list); + per_cpu(cpuidle_devices, dev->cpu) = NULL; + module_put(drv->owner); ++ ++ dev->registered = 0; + } + + static void __cpuidle_device_init(struct cpuidle_device *dev) +diff --git a/drivers/cpuidle/cpuidle.h b/drivers/cpuidle/cpuidle.h +index ee97e9672ecf..178c5ad3d568 100644 +--- a/drivers/cpuidle/cpuidle.h ++++ b/drivers/cpuidle/cpuidle.h +@@ -34,15 +34,14 @@ extern int cpuidle_add_sysfs(struct cpuidle_device *dev); + extern void cpuidle_remove_sysfs(struct cpuidle_device *dev); + + #ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED +-bool cpuidle_state_is_coupled(struct cpuidle_device *dev, +- struct cpuidle_driver *drv, int state); ++bool cpuidle_state_is_coupled(struct cpuidle_driver *drv, int state); + int cpuidle_enter_state_coupled(struct cpuidle_device *dev, + struct cpuidle_driver *drv, int next_state); + int cpuidle_coupled_register_device(struct cpuidle_device *dev); + void cpuidle_coupled_unregister_device(struct cpuidle_device *dev); + #else +-static inline bool cpuidle_state_is_coupled(struct cpuidle_device *dev, +- struct cpuidle_driver *drv, int state) ++static inline ++bool cpuidle_state_is_coupled(struct cpuidle_driver *drv, int state) + { + return false; + } +diff --git a/drivers/crypto/caam/jr.c b/drivers/crypto/caam/jr.c +index b8b5d47acd7a..9bfd4100baa8 100644 +--- a/drivers/crypto/caam/jr.c ++++ b/drivers/crypto/caam/jr.c +@@ -241,7 +241,7 @@ static void caam_jr_dequeue(unsigned long devarg) + struct device *caam_jr_alloc(void) + { + struct caam_drv_private_jr *jrpriv, *min_jrpriv = NULL; +- struct device *dev = NULL; ++ struct device *dev = ERR_PTR(-ENODEV); + int min_tfm_cnt = INT_MAX; + int tfm_cnt; + +diff --git a/drivers/crypto/s5p-sss.c b/drivers/crypto/s5p-sss.c +index f214a8755827..36d936fb259e 100644 +--- a/drivers/crypto/s5p-sss.c ++++ b/drivers/crypto/s5p-sss.c +@@ -149,7 +149,6 @@ + + /** + * struct samsung_aes_variant - platform specific SSS driver data +- * @has_hash_irq: true if SSS module uses hash interrupt, false otherwise + * @aes_offset: AES register offset from SSS module's base. + * + * Specifies platform specific configuration of SSS module. +@@ -157,7 +156,6 @@ + * expansion of its usage. + */ + struct samsung_aes_variant { +- bool has_hash_irq; + unsigned int aes_offset; + }; + +@@ -178,7 +176,6 @@ struct s5p_aes_dev { + struct clk *clk; + void __iomem *ioaddr; + void __iomem *aes_ioaddr; +- int irq_hash; + int irq_fc; + + struct ablkcipher_request *req; +@@ -197,12 +194,10 @@ struct s5p_aes_dev { + static struct s5p_aes_dev *s5p_dev; + + static const struct samsung_aes_variant s5p_aes_data = { +- .has_hash_irq = true, + .aes_offset = 0x4000, + }; + + static const struct samsung_aes_variant exynos_aes_data = { +- .has_hash_irq = false, + .aes_offset = 0x200, + }; + +@@ -313,43 +308,55 @@ static int s5p_set_indata(struct s5p_aes_dev *dev, struct scatterlist *sg) + return err; + } + +-static void s5p_aes_tx(struct s5p_aes_dev *dev) ++/* ++ * Returns true if new transmitting (output) data is ready and its ++ * address+length have to be written to device (by calling ++ * s5p_set_dma_outdata()). False otherwise. ++ */ ++static bool s5p_aes_tx(struct s5p_aes_dev *dev) + { + int err = 0; ++ bool ret = false; + + s5p_unset_outdata(dev); + + if (!sg_is_last(dev->sg_dst)) { + err = s5p_set_outdata(dev, sg_next(dev->sg_dst)); +- if (err) { ++ if (err) + s5p_aes_complete(dev, err); +- return; +- } +- +- s5p_set_dma_outdata(dev, dev->sg_dst); ++ else ++ ret = true; + } else { + s5p_aes_complete(dev, err); + + dev->busy = true; + tasklet_schedule(&dev->tasklet); + } ++ ++ return ret; + } + +-static void s5p_aes_rx(struct s5p_aes_dev *dev) ++/* ++ * Returns true if new receiving (input) data is ready and its ++ * address+length have to be written to device (by calling ++ * s5p_set_dma_indata()). False otherwise. ++ */ ++static bool s5p_aes_rx(struct s5p_aes_dev *dev) + { + int err; ++ bool ret = false; + + s5p_unset_indata(dev); + + if (!sg_is_last(dev->sg_src)) { + err = s5p_set_indata(dev, sg_next(dev->sg_src)); +- if (err) { ++ if (err) + s5p_aes_complete(dev, err); +- return; +- } +- +- s5p_set_dma_indata(dev, dev->sg_src); ++ else ++ ret = true; + } ++ ++ return ret; + } + + static irqreturn_t s5p_aes_interrupt(int irq, void *dev_id) +@@ -358,18 +365,29 @@ static irqreturn_t s5p_aes_interrupt(int irq, void *dev_id) + struct s5p_aes_dev *dev = platform_get_drvdata(pdev); + uint32_t status; + unsigned long flags; ++ bool set_dma_tx = false; ++ bool set_dma_rx = false; + + spin_lock_irqsave(&dev->lock, flags); + +- if (irq == dev->irq_fc) { +- status = SSS_READ(dev, FCINTSTAT); +- if (status & SSS_FCINTSTAT_BRDMAINT) +- s5p_aes_rx(dev); +- if (status & SSS_FCINTSTAT_BTDMAINT) +- s5p_aes_tx(dev); +- +- SSS_WRITE(dev, FCINTPEND, status); +- } ++ status = SSS_READ(dev, FCINTSTAT); ++ if (status & SSS_FCINTSTAT_BRDMAINT) ++ set_dma_rx = s5p_aes_rx(dev); ++ if (status & SSS_FCINTSTAT_BTDMAINT) ++ set_dma_tx = s5p_aes_tx(dev); ++ ++ SSS_WRITE(dev, FCINTPEND, status); ++ ++ /* ++ * Writing length of DMA block (either receiving or transmitting) ++ * will start the operation immediately, so this should be done ++ * at the end (even after clearing pending interrupts to not miss the ++ * interrupt). ++ */ ++ if (set_dma_tx) ++ s5p_set_dma_outdata(dev, dev->sg_dst); ++ if (set_dma_rx) ++ s5p_set_dma_indata(dev, dev->sg_src); + + spin_unlock_irqrestore(&dev->lock, flags); + +@@ -671,21 +689,6 @@ static int s5p_aes_probe(struct platform_device *pdev) + goto err_irq; + } + +- if (variant->has_hash_irq) { +- pdata->irq_hash = platform_get_irq(pdev, 1); +- if (pdata->irq_hash < 0) { +- err = pdata->irq_hash; +- dev_warn(dev, "hash interrupt is not available.\n"); +- goto err_irq; +- } +- err = devm_request_irq(dev, pdata->irq_hash, s5p_aes_interrupt, +- IRQF_SHARED, pdev->name, pdev); +- if (err < 0) { +- dev_warn(dev, "hash interrupt is not available.\n"); +- goto err_irq; +- } +- } +- + pdata->busy = false; + pdata->variant = variant; + pdata->dev = dev; +diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c +index cac422916c7a..c8b90b3be349 100644 +--- a/drivers/gpu/drm/drm_fb_helper.c ++++ b/drivers/gpu/drm/drm_fb_helper.c +@@ -1549,7 +1549,6 @@ static int drm_pick_crtcs(struct drm_fb_helper *fb_helper, + int n, int width, int height) + { + int c, o; +- struct drm_device *dev = fb_helper->dev; + struct drm_connector *connector; + const struct drm_connector_helper_funcs *connector_funcs; + struct drm_encoder *encoder; +@@ -1568,7 +1567,7 @@ static int drm_pick_crtcs(struct drm_fb_helper *fb_helper, + if (modes[n] == NULL) + return best_score; + +- crtcs = kzalloc(dev->mode_config.num_connector * ++ crtcs = kzalloc(fb_helper->connector_count * + sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL); + if (!crtcs) + return best_score; +@@ -1614,7 +1613,7 @@ static int drm_pick_crtcs(struct drm_fb_helper *fb_helper, + if (score > best_score) { + best_score = score; + memcpy(best_crtcs, crtcs, +- dev->mode_config.num_connector * ++ fb_helper->connector_count * + sizeof(struct drm_fb_helper_crtc *)); + } + } +diff --git a/drivers/gpu/drm/gma500/mdfld_dsi_pkg_sender.c b/drivers/gpu/drm/gma500/mdfld_dsi_pkg_sender.c +index 6b43ae3ffd73..1616af209bfc 100644 +--- a/drivers/gpu/drm/gma500/mdfld_dsi_pkg_sender.c ++++ b/drivers/gpu/drm/gma500/mdfld_dsi_pkg_sender.c +@@ -72,7 +72,7 @@ static const char *const dsi_errors[] = { + "RX Prot Violation", + "HS Generic Write FIFO Full", + "LP Generic Write FIFO Full", +- "Generic Read Data Avail" ++ "Generic Read Data Avail", + "Special Packet Sent", + "Tearing Effect", + }; +diff --git a/drivers/gpu/drm/i915/intel_fbdev.c b/drivers/gpu/drm/i915/intel_fbdev.c +index 4e7e7da2e03b..64783985e392 100644 +--- a/drivers/gpu/drm/i915/intel_fbdev.c ++++ b/drivers/gpu/drm/i915/intel_fbdev.c +@@ -361,12 +361,12 @@ static bool intel_fb_initial_config(struct drm_fb_helper *fb_helper, + uint64_t conn_configured = 0, mask; + int pass = 0; + +- save_enabled = kcalloc(dev->mode_config.num_connector, sizeof(bool), ++ save_enabled = kcalloc(fb_helper->connector_count, sizeof(bool), + GFP_KERNEL); + if (!save_enabled) + return false; + +- memcpy(save_enabled, enabled, dev->mode_config.num_connector); ++ memcpy(save_enabled, enabled, fb_helper->connector_count); + mask = (1 << fb_helper->connector_count) - 1; + retry: + for (i = 0; i < fb_helper->connector_count; i++) { +@@ -505,7 +505,7 @@ retry: + if (fallback) { + bail: + DRM_DEBUG_KMS("Not using firmware configuration\n"); +- memcpy(enabled, save_enabled, dev->mode_config.num_connector); ++ memcpy(enabled, save_enabled, fb_helper->connector_count); + kfree(save_enabled); + return false; + } +diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c +index 555b896d2bda..00bc49835e09 100644 +--- a/drivers/gpu/drm/i915/intel_pm.c ++++ b/drivers/gpu/drm/i915/intel_pm.c +@@ -3574,6 +3574,8 @@ static void ilk_pipe_wm_get_hw_state(struct drm_crtc *crtc) + if (IS_HASWELL(dev) || IS_BROADWELL(dev)) + hw->wm_linetime[pipe] = I915_READ(PIPE_WM_LINETIME(pipe)); + ++ memset(active, 0, sizeof(*active)); ++ + active->pipe_enabled = intel_crtc->active; + + if (active->pipe_enabled) { +diff --git a/drivers/hwmon/ads7828.c b/drivers/hwmon/ads7828.c +index 6c99ee7bafa3..ee396ff167d9 100644 +--- a/drivers/hwmon/ads7828.c ++++ b/drivers/hwmon/ads7828.c +@@ -120,6 +120,7 @@ static int ads7828_probe(struct i2c_client *client, + unsigned int vref_mv = ADS7828_INT_VREF_MV; + bool diff_input = false; + bool ext_vref = false; ++ unsigned int regval; + + data = devm_kzalloc(dev, sizeof(struct ads7828_data), GFP_KERNEL); + if (!data) +@@ -154,6 +155,15 @@ static int ads7828_probe(struct i2c_client *client, + if (!diff_input) + data->cmd_byte |= ADS7828_CMD_SD_SE; + ++ /* ++ * Datasheet specifies internal reference voltage is disabled by ++ * default. The internal reference voltage needs to be enabled and ++ * voltage needs to settle before getting valid ADC data. So perform a ++ * dummy read to enable the internal reference voltage. ++ */ ++ if (!ext_vref) ++ regmap_read(data->regmap, data->cmd_byte, ®val); ++ + hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, + data, + ads7828_groups); +diff --git a/drivers/input/misc/pwm-beeper.c b/drivers/input/misc/pwm-beeper.c +index e82edf810d1f..9021725e25e4 100644 +--- a/drivers/input/misc/pwm-beeper.c ++++ b/drivers/input/misc/pwm-beeper.c +@@ -20,21 +20,40 @@ + #include <linux/platform_device.h> + #include <linux/pwm.h> + #include <linux/slab.h> ++#include <linux/workqueue.h> + + struct pwm_beeper { + struct input_dev *input; + struct pwm_device *pwm; ++ struct work_struct work; + unsigned long period; + }; + + #define HZ_TO_NANOSECONDS(x) (1000000000UL/(x)) + ++static void __pwm_beeper_set(struct pwm_beeper *beeper) ++{ ++ unsigned long period = beeper->period; ++ ++ if (period) { ++ pwm_config(beeper->pwm, period / 2, period); ++ pwm_enable(beeper->pwm); ++ } else ++ pwm_disable(beeper->pwm); ++} ++ ++static void pwm_beeper_work(struct work_struct *work) ++{ ++ struct pwm_beeper *beeper = ++ container_of(work, struct pwm_beeper, work); ++ ++ __pwm_beeper_set(beeper); ++} ++ + static int pwm_beeper_event(struct input_dev *input, + unsigned int type, unsigned int code, int value) + { +- int ret = 0; + struct pwm_beeper *beeper = input_get_drvdata(input); +- unsigned long period; + + if (type != EV_SND || value < 0) + return -EINVAL; +@@ -49,22 +68,31 @@ static int pwm_beeper_event(struct input_dev *input, + return -EINVAL; + } + +- if (value == 0) { +- pwm_disable(beeper->pwm); +- } else { +- period = HZ_TO_NANOSECONDS(value); +- ret = pwm_config(beeper->pwm, period / 2, period); +- if (ret) +- return ret; +- ret = pwm_enable(beeper->pwm); +- if (ret) +- return ret; +- beeper->period = period; +- } ++ if (value == 0) ++ beeper->period = 0; ++ else ++ beeper->period = HZ_TO_NANOSECONDS(value); ++ ++ schedule_work(&beeper->work); + + return 0; + } + ++static void pwm_beeper_stop(struct pwm_beeper *beeper) ++{ ++ cancel_work_sync(&beeper->work); ++ ++ if (beeper->period) ++ pwm_disable(beeper->pwm); ++} ++ ++static void pwm_beeper_close(struct input_dev *input) ++{ ++ struct pwm_beeper *beeper = input_get_drvdata(input); ++ ++ pwm_beeper_stop(beeper); ++} ++ + static int pwm_beeper_probe(struct platform_device *pdev) + { + unsigned long pwm_id = (unsigned long)dev_get_platdata(&pdev->dev); +@@ -87,6 +115,8 @@ static int pwm_beeper_probe(struct platform_device *pdev) + goto err_free; + } + ++ INIT_WORK(&beeper->work, pwm_beeper_work); ++ + beeper->input = input_allocate_device(); + if (!beeper->input) { + dev_err(&pdev->dev, "Failed to allocate input device\n"); +@@ -106,6 +136,7 @@ static int pwm_beeper_probe(struct platform_device *pdev) + beeper->input->sndbit[0] = BIT(SND_TONE) | BIT(SND_BELL); + + beeper->input->event = pwm_beeper_event; ++ beeper->input->close = pwm_beeper_close; + + input_set_drvdata(beeper->input, beeper); + +@@ -135,7 +166,6 @@ static int pwm_beeper_remove(struct platform_device *pdev) + + input_unregister_device(beeper->input); + +- pwm_disable(beeper->pwm); + pwm_free(beeper->pwm); + + kfree(beeper); +@@ -147,8 +177,7 @@ static int __maybe_unused pwm_beeper_suspend(struct device *dev) + { + struct pwm_beeper *beeper = dev_get_drvdata(dev); + +- if (beeper->period) +- pwm_disable(beeper->pwm); ++ pwm_beeper_stop(beeper); + + return 0; + } +@@ -157,10 +186,8 @@ static int __maybe_unused pwm_beeper_resume(struct device *dev) + { + struct pwm_beeper *beeper = dev_get_drvdata(dev); + +- if (beeper->period) { +- pwm_config(beeper->pwm, beeper->period / 2, beeper->period); +- pwm_enable(beeper->pwm); +- } ++ if (beeper->period) ++ __pwm_beeper_set(beeper); + + return 0; + } +diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c +index 421e29e4cd81..5221450f9b57 100644 +--- a/drivers/input/misc/uinput.c ++++ b/drivers/input/misc/uinput.c +@@ -895,9 +895,15 @@ static long uinput_ioctl(struct file *file, unsigned int cmd, unsigned long arg) + } + + #ifdef CONFIG_COMPAT ++ ++#define UI_SET_PHYS_COMPAT _IOW(UINPUT_IOCTL_BASE, 108, compat_uptr_t) ++ + static long uinput_compat_ioctl(struct file *file, + unsigned int cmd, unsigned long arg) + { ++ if (cmd == UI_SET_PHYS_COMPAT) ++ cmd = UI_SET_PHYS; ++ + return uinput_ioctl_handler(file, cmd, arg, compat_ptr(arg)); + } + #endif +diff --git a/drivers/irqchip/irq-gic-v3.c b/drivers/irqchip/irq-gic-v3.c +index 49875adb6b44..1dbae580e8ca 100644 +--- a/drivers/irqchip/irq-gic-v3.c ++++ b/drivers/irqchip/irq-gic-v3.c +@@ -353,6 +353,13 @@ static asmlinkage void __exception_irq_entry gic_handle_irq(struct pt_regs *regs + if (irqnr < 16) { + gic_write_eoir(irqnr); + #ifdef CONFIG_SMP ++ /* ++ * Unlike GICv2, we don't need an smp_rmb() here. ++ * The control dependency from gic_read_iar to ++ * the ISB in gic_write_eoir is enough to ensure ++ * that any shared data read by handle_IPI will ++ * be read after the ACK. ++ */ + handle_IPI(irqnr, regs); + #else + WARN_ONCE(true, "Unexpected SGI received!\n"); +@@ -372,6 +379,15 @@ static void __init gic_dist_init(void) + writel_relaxed(0, base + GICD_CTLR); + gic_dist_wait_for_rwp(); + ++ /* ++ * Configure SPIs as non-secure Group-1. This will only matter ++ * if the GIC only has a single security state. This will not ++ * do the right thing if the kernel is running in secure mode, ++ * but that's not the intended use case anyway. ++ */ ++ for (i = 32; i < gic_data.irq_nr; i += 32) ++ writel_relaxed(~0, base + GICD_IGROUPR + i / 8); ++ + gic_dist_config(base, gic_data.irq_nr, gic_dist_wait_for_rwp); + + /* Enable distributor with ARE, Group1 */ +@@ -475,6 +491,9 @@ static void gic_cpu_init(void) + + rbase = gic_data_rdist_sgi_base(); + ++ /* Configure SGIs/PPIs as non-secure Group-1 */ ++ writel_relaxed(~0, rbase + GICR_IGROUPR0); ++ + gic_cpu_config(rbase, gic_redist_wait_for_rwp); + + /* Give LPIs a spin */ +diff --git a/drivers/irqchip/irq-gic.c b/drivers/irqchip/irq-gic.c +index 01999d74bd3a..eb9fb9299ec5 100644 +--- a/drivers/irqchip/irq-gic.c ++++ b/drivers/irqchip/irq-gic.c +@@ -278,6 +278,14 @@ static void __exception_irq_entry gic_handle_irq(struct pt_regs *regs) + if (irqnr < 16) { + writel_relaxed(irqstat, cpu_base + GIC_CPU_EOI); + #ifdef CONFIG_SMP ++ /* ++ * Ensure any shared data written by the CPU sending ++ * the IPI is read after we've read the ACK register ++ * on the GIC. ++ * ++ * Pairs with the write barrier in gic_raise_softirq ++ */ ++ smp_rmb(); + handle_IPI(irqnr, regs); + #endif + continue; +diff --git a/drivers/mcb/mcb-parse.c b/drivers/mcb/mcb-parse.c +index 004926955263..b0155b05cddb 100644 +--- a/drivers/mcb/mcb-parse.c ++++ b/drivers/mcb/mcb-parse.c +@@ -57,7 +57,7 @@ static int chameleon_parse_gdd(struct mcb_bus *bus, + mdev->id = GDD_DEV(reg1); + mdev->rev = GDD_REV(reg1); + mdev->var = GDD_VAR(reg1); +- mdev->bar = GDD_BAR(reg1); ++ mdev->bar = GDD_BAR(reg2); + mdev->group = GDD_GRP(reg2); + mdev->inst = GDD_INS(reg2); + +diff --git a/drivers/media/v4l2-core/v4l2-compat-ioctl32.c b/drivers/media/v4l2-core/v4l2-compat-ioctl32.c +index 8085059ce925..4b777be714a4 100644 +--- a/drivers/media/v4l2-core/v4l2-compat-ioctl32.c ++++ b/drivers/media/v4l2-core/v4l2-compat-ioctl32.c +@@ -259,7 +259,8 @@ static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user + static int put_v4l2_create32(struct v4l2_create_buffers *kp, struct v4l2_create_buffers32 __user *up) + { + if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_create_buffers32)) || +- copy_to_user(up, kp, offsetof(struct v4l2_create_buffers32, format))) ++ copy_to_user(up, kp, offsetof(struct v4l2_create_buffers32, format)) || ++ copy_to_user(up->reserved, kp->reserved, sizeof(kp->reserved))) + return -EFAULT; + return __put_v4l2_format32(&kp->format, &up->format); + } +diff --git a/drivers/mfd/intel_quark_i2c_gpio.c b/drivers/mfd/intel_quark_i2c_gpio.c +index 1ce16037d043..958c13473e8c 100644 +--- a/drivers/mfd/intel_quark_i2c_gpio.c ++++ b/drivers/mfd/intel_quark_i2c_gpio.c +@@ -90,19 +90,19 @@ static struct resource intel_quark_gpio_res[] = { + + static struct mfd_cell intel_quark_mfd_cells[] = { + { +- .id = MFD_I2C_BAR, +- .name = "i2c_designware", +- .num_resources = ARRAY_SIZE(intel_quark_i2c_res), +- .resources = intel_quark_i2c_res, +- .ignore_resource_conflicts = true, +- }, +- { + .id = MFD_GPIO_BAR, + .name = "gpio-dwapb", + .num_resources = ARRAY_SIZE(intel_quark_gpio_res), + .resources = intel_quark_gpio_res, + .ignore_resource_conflicts = true, + }, ++ { ++ .id = MFD_I2C_BAR, ++ .name = "i2c_designware", ++ .num_resources = ARRAY_SIZE(intel_quark_i2c_res), ++ .resources = intel_quark_i2c_res, ++ .ignore_resource_conflicts = true, ++ }, + }; + + static const struct pci_device_id intel_quark_mfd_ids[] = { +@@ -248,12 +248,11 @@ static int intel_quark_mfd_probe(struct pci_dev *pdev, + + dev_set_drvdata(&pdev->dev, quark_mfd); + +- ret = intel_quark_i2c_setup(pdev, &intel_quark_mfd_cells[MFD_I2C_BAR]); ++ ret = intel_quark_i2c_setup(pdev, &intel_quark_mfd_cells[1]); + if (ret) + return ret; + +- ret = intel_quark_gpio_setup(pdev, +- &intel_quark_mfd_cells[MFD_GPIO_BAR]); ++ ret = intel_quark_gpio_setup(pdev, &intel_quark_mfd_cells[0]); + if (ret) + return ret; + +diff --git a/drivers/mfd/omap-usb-tll.c b/drivers/mfd/omap-usb-tll.c +index b7b3e8ee64f2..c30290f33430 100644 +--- a/drivers/mfd/omap-usb-tll.c ++++ b/drivers/mfd/omap-usb-tll.c +@@ -269,6 +269,8 @@ static int usbtll_omap_probe(struct platform_device *pdev) + + if (IS_ERR(tll->ch_clk[i])) + dev_dbg(dev, "can't get clock : %s\n", clkname); ++ else ++ clk_prepare(tll->ch_clk[i]); + } + + pm_runtime_put_sync(dev); +@@ -301,9 +303,12 @@ static int usbtll_omap_remove(struct platform_device *pdev) + tll_dev = NULL; + spin_unlock(&tll_lock); + +- for (i = 0; i < tll->nch; i++) +- if (!IS_ERR(tll->ch_clk[i])) ++ for (i = 0; i < tll->nch; i++) { ++ if (!IS_ERR(tll->ch_clk[i])) { ++ clk_unprepare(tll->ch_clk[i]); + clk_put(tll->ch_clk[i]); ++ } ++ } + + pm_runtime_disable(&pdev->dev); + return 0; +@@ -420,7 +425,7 @@ int omap_tll_enable(struct usbhs_omap_platform_data *pdata) + if (IS_ERR(tll->ch_clk[i])) + continue; + +- r = clk_prepare_enable(tll->ch_clk[i]); ++ r = clk_enable(tll->ch_clk[i]); + if (r) { + dev_err(tll_dev, + "Error enabling ch %d clock: %d\n", i, r); +@@ -448,7 +453,7 @@ int omap_tll_disable(struct usbhs_omap_platform_data *pdata) + for (i = 0; i < tll->nch; i++) { + if (omap_usb_mode_needs_tll(pdata->port_mode[i])) { + if (!IS_ERR(tll->ch_clk[i])) +- clk_disable_unprepare(tll->ch_clk[i]); ++ clk_disable(tll->ch_clk[i]); + } + } + +diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c +index 31d2627d9d4d..3705c7e63521 100644 +--- a/drivers/mmc/card/block.c ++++ b/drivers/mmc/card/block.c +@@ -2403,11 +2403,12 @@ static const struct mmc_fixup blk_fixups[] = + MMC_QUIRK_BLK_NO_CMD23), + + /* +- * Some Micron MMC cards needs longer data read timeout than +- * indicated in CSD. ++ * Some MMC cards need longer data read timeout than indicated in CSD. + */ + MMC_FIXUP(CID_NAME_ANY, CID_MANFID_MICRON, 0x200, add_quirk_mmc, + MMC_QUIRK_LONG_READ_TIME), ++ MMC_FIXUP("008GE0", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc, ++ MMC_QUIRK_LONG_READ_TIME), + + /* + * On these Samsung MoviNAND parts, performing secure erase or +diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c +index 588fb7908642..b5d8906ac34f 100644 +--- a/drivers/mmc/core/core.c ++++ b/drivers/mmc/core/core.c +@@ -831,11 +831,11 @@ void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card) + /* + * Some cards require longer data read timeout than indicated in CSD. + * Address this by setting the read timeout to a "reasonably high" +- * value. For the cards tested, 300ms has proven enough. If necessary, ++ * value. For the cards tested, 600ms has proven enough. If necessary, + * this value can be increased if other problematic cards require this. + */ + if (mmc_card_long_read_time(card) && data->flags & MMC_DATA_READ) { +- data->timeout_ns = 300000000; ++ data->timeout_ns = 600000000; + data->timeout_clks = 0; + } + +diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c +index f36c76f8b232..3ccc89d4c473 100644 +--- a/drivers/mmc/core/mmc.c ++++ b/drivers/mmc/core/mmc.c +@@ -330,6 +330,9 @@ static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd) + } + } + ++/* Minimum partition switch timeout in milliseconds */ ++#define MMC_MIN_PART_SWITCH_TIME 300 ++ + /* + * Decode extended CSD. + */ +@@ -394,6 +397,10 @@ static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd) + + /* EXT_CSD value is in units of 10ms, but we store in ms */ + card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME]; ++ /* Some eMMC set the value too low so set a minimum */ ++ if (card->ext_csd.part_time && ++ card->ext_csd.part_time < MMC_MIN_PART_SWITCH_TIME) ++ card->ext_csd.part_time = MMC_MIN_PART_SWITCH_TIME; + + /* Sleep / awake timeout in 100ns units */ + if (sa_shift > 0 && sa_shift <= 0x17) +diff --git a/drivers/mmc/host/sdhci-acpi.c b/drivers/mmc/host/sdhci-acpi.c +index 22d929fa3371..5d4b8a623a12 100644 +--- a/drivers/mmc/host/sdhci-acpi.c ++++ b/drivers/mmc/host/sdhci-acpi.c +@@ -203,7 +203,7 @@ static const struct sdhci_acpi_slot sdhci_acpi_slot_int_emmc = { + .chip = &sdhci_acpi_chip_int, + .caps = MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE | + MMC_CAP_HW_RESET | MMC_CAP_1_8V_DDR | +- MMC_CAP_BUS_WIDTH_TEST | MMC_CAP_WAIT_WHILE_BUSY, ++ MMC_CAP_WAIT_WHILE_BUSY, + .caps2 = MMC_CAP2_HC_ERASE_SZ, + .flags = SDHCI_ACPI_RUNTIME_PM, + .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, +@@ -216,7 +216,7 @@ static const struct sdhci_acpi_slot sdhci_acpi_slot_int_sdio = { + SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, + .quirks2 = SDHCI_QUIRK2_HOST_OFF_CARD_ON, + .caps = MMC_CAP_NONREMOVABLE | MMC_CAP_POWER_OFF_CARD | +- MMC_CAP_BUS_WIDTH_TEST | MMC_CAP_WAIT_WHILE_BUSY, ++ MMC_CAP_WAIT_WHILE_BUSY, + .flags = SDHCI_ACPI_RUNTIME_PM, + .pm_caps = MMC_PM_KEEP_POWER, + .probe_slot = sdhci_acpi_sdio_probe_slot, +@@ -228,7 +228,7 @@ static const struct sdhci_acpi_slot sdhci_acpi_slot_int_sd = { + .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, + .quirks2 = SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON | + SDHCI_QUIRK2_STOP_WITH_TC, +- .caps = MMC_CAP_BUS_WIDTH_TEST | MMC_CAP_WAIT_WHILE_BUSY, ++ .caps = MMC_CAP_WAIT_WHILE_BUSY, + .probe_slot = sdhci_acpi_sd_probe_slot, + }; + +diff --git a/drivers/mtd/ubi/eba.c b/drivers/mtd/ubi/eba.c +index 51bca035cd83..1c73ba6efdbd 100644 +--- a/drivers/mtd/ubi/eba.c ++++ b/drivers/mtd/ubi/eba.c +@@ -426,8 +426,25 @@ retry: + pnum, vol_id, lnum); + err = -EBADMSG; + } else { +- err = -EINVAL; +- ubi_ro_mode(ubi); ++ /* ++ * Ending up here in the non-Fastmap case ++ * is a clear bug as the VID header had to ++ * be present at scan time to have it referenced. ++ * With fastmap the story is more complicated. ++ * Fastmap has the mapping info without the need ++ * of a full scan. So the LEB could have been ++ * unmapped, Fastmap cannot know this and keeps ++ * the LEB referenced. ++ * This is valid and works as the layer above UBI ++ * has to do bookkeeping about used/referenced ++ * LEBs in any case. ++ */ ++ if (ubi->fast_attach) { ++ err = -EBADMSG; ++ } else { ++ err = -EINVAL; ++ ubi_ro_mode(ubi); ++ } + } + } + goto out_free; +diff --git a/drivers/mtd/ubi/fastmap.c b/drivers/mtd/ubi/fastmap.c +index 02a6de2f53ee..9f505b0dd292 100644 +--- a/drivers/mtd/ubi/fastmap.c ++++ b/drivers/mtd/ubi/fastmap.c +@@ -1051,6 +1051,7 @@ int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai, + ubi_msg(ubi, "fastmap WL pool size: %d", + ubi->fm_wl_pool.max_size); + ubi->fm_disabled = 0; ++ ubi->fast_attach = 1; + + ubi_free_vid_hdr(ubi, vh); + kfree(ech); +diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h +index c998212fc680..292a286ba489 100644 +--- a/drivers/mtd/ubi/ubi.h ++++ b/drivers/mtd/ubi/ubi.h +@@ -462,6 +462,7 @@ struct ubi_debug_info { + * @fm_eba_sem: allows ubi_update_fastmap() to block EBA table changes + * @fm_work: fastmap work queue + * @fm_work_scheduled: non-zero if fastmap work was scheduled ++ * @fast_attach: non-zero if UBI was attached by fastmap + * + * @used: RB-tree of used physical eraseblocks + * @erroneous: RB-tree of erroneous used physical eraseblocks +@@ -570,6 +571,7 @@ struct ubi_device { + size_t fm_size; + struct work_struct fm_work; + int fm_work_scheduled; ++ int fast_attach; + + /* Wear-leveling sub-system's stuff */ + struct rb_root used; +diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c +index 141c2a42d7ed..910c12e2638e 100644 +--- a/drivers/net/can/dev.c ++++ b/drivers/net/can/dev.c +@@ -696,11 +696,17 @@ int can_change_mtu(struct net_device *dev, int new_mtu) + /* allow change of MTU according to the CANFD ability of the device */ + switch (new_mtu) { + case CAN_MTU: ++ /* 'CANFD-only' controllers can not switch to CAN_MTU */ ++ if (priv->ctrlmode_static & CAN_CTRLMODE_FD) ++ return -EINVAL; ++ + priv->ctrlmode &= ~CAN_CTRLMODE_FD; + break; + + case CANFD_MTU: +- if (!(priv->ctrlmode_supported & CAN_CTRLMODE_FD)) ++ /* check for potential CANFD ability */ ++ if (!(priv->ctrlmode_supported & CAN_CTRLMODE_FD) && ++ !(priv->ctrlmode_static & CAN_CTRLMODE_FD)) + return -EINVAL; + + priv->ctrlmode |= CAN_CTRLMODE_FD; +@@ -782,6 +788,35 @@ static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = { + = { .len = sizeof(struct can_bittiming_const) }, + }; + ++static int can_validate(struct nlattr *tb[], struct nlattr *data[]) ++{ ++ bool is_can_fd = false; ++ ++ /* Make sure that valid CAN FD configurations always consist of ++ * - nominal/arbitration bittiming ++ * - data bittiming ++ * - control mode with CAN_CTRLMODE_FD set ++ */ ++ ++ if (data[IFLA_CAN_CTRLMODE]) { ++ struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]); ++ ++ is_can_fd = cm->flags & cm->mask & CAN_CTRLMODE_FD; ++ } ++ ++ if (is_can_fd) { ++ if (!data[IFLA_CAN_BITTIMING] || !data[IFLA_CAN_DATA_BITTIMING]) ++ return -EOPNOTSUPP; ++ } ++ ++ if (data[IFLA_CAN_DATA_BITTIMING]) { ++ if (!is_can_fd || !data[IFLA_CAN_BITTIMING]) ++ return -EOPNOTSUPP; ++ } ++ ++ return 0; ++} ++ + static int can_changelink(struct net_device *dev, + struct nlattr *tb[], struct nlattr *data[]) + { +@@ -813,19 +848,31 @@ static int can_changelink(struct net_device *dev, + + if (data[IFLA_CAN_CTRLMODE]) { + struct can_ctrlmode *cm; ++ u32 ctrlstatic; ++ u32 maskedflags; + + /* Do not allow changing controller mode while running */ + if (dev->flags & IFF_UP) + return -EBUSY; + cm = nla_data(data[IFLA_CAN_CTRLMODE]); ++ ctrlstatic = priv->ctrlmode_static; ++ maskedflags = cm->flags & cm->mask; ++ ++ /* check whether provided bits are allowed to be passed */ ++ if (cm->mask & ~(priv->ctrlmode_supported | ctrlstatic)) ++ return -EOPNOTSUPP; ++ ++ /* do not check for static fd-non-iso if 'fd' is disabled */ ++ if (!(maskedflags & CAN_CTRLMODE_FD)) ++ ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO; + +- /* check whether changed bits are allowed to be modified */ +- if (cm->mask & ~priv->ctrlmode_supported) ++ /* make sure static options are provided by configuration */ ++ if ((maskedflags & ctrlstatic) != ctrlstatic) + return -EOPNOTSUPP; + + /* clear bits to be modified and copy the flag values */ + priv->ctrlmode &= ~cm->mask; +- priv->ctrlmode |= (cm->flags & cm->mask); ++ priv->ctrlmode |= maskedflags; + + /* CAN_CTRLMODE_FD can only be set when driver supports FD */ + if (priv->ctrlmode & CAN_CTRLMODE_FD) +@@ -966,6 +1013,7 @@ static struct rtnl_link_ops can_link_ops __read_mostly = { + .maxtype = IFLA_CAN_MAX, + .policy = can_policy, + .setup = can_setup, ++ .validate = can_validate, + .newlink = can_newlink, + .changelink = can_changelink, + .get_size = can_get_size, +diff --git a/drivers/net/can/m_can/m_can.c b/drivers/net/can/m_can/m_can.c +index ef655177bb5e..37f15eb4260a 100644 +--- a/drivers/net/can/m_can/m_can.c ++++ b/drivers/net/can/m_can/m_can.c +@@ -958,7 +958,7 @@ static struct net_device *alloc_m_can_dev(void) + priv->can.do_get_berr_counter = m_can_get_berr_counter; + + /* CAN_CTRLMODE_FD_NON_ISO is fixed with M_CAN IP v3.0.1 */ +- priv->can.ctrlmode = CAN_CTRLMODE_FD_NON_ISO; ++ can_set_static_ctrlmode(dev, CAN_CTRLMODE_FD_NON_ISO); + + /* CAN_CTRLMODE_FD_NON_ISO can not be changed with M_CAN IP v3.0.1 */ + priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | +diff --git a/drivers/net/wireless/ath/ath10k/debug.c b/drivers/net/wireless/ath/ath10k/debug.c +index 301081db1ef6..1b69427fbb29 100644 +--- a/drivers/net/wireless/ath/ath10k/debug.c ++++ b/drivers/net/wireless/ath/ath10k/debug.c +@@ -1947,7 +1947,12 @@ static ssize_t ath10k_write_pktlog_filter(struct file *file, + goto out; + } + +- if (filter && (filter != ar->debug.pktlog_filter)) { ++ if (filter == ar->debug.pktlog_filter) { ++ ret = count; ++ goto out; ++ } ++ ++ if (filter) { + ret = ath10k_wmi_pdev_pktlog_enable(ar, filter); + if (ret) { + ath10k_warn(ar, "failed to enable pktlog filter %x: %d\n", +diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c +index 1734cc50ded8..56e0a1de0c37 100644 +--- a/drivers/net/wireless/ath/ath10k/mac.c ++++ b/drivers/net/wireless/ath/ath10k/mac.c +@@ -3329,7 +3329,10 @@ static int ath10k_add_interface(struct ieee80211_hw *hw, + goto err_vdev_delete; + } + +- if (ar->cfg_tx_chainmask) { ++ /* Configuring number of spatial stream for monitor interface is causing ++ * target assert in qca9888 and qca6174. ++ */ ++ if (ar->cfg_tx_chainmask && (vif->type != NL80211_IFTYPE_MONITOR)) { + u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask); + + vdev_param = ar->wmi.vdev_param->nss; +diff --git a/drivers/net/wireless/ath/ath5k/led.c b/drivers/net/wireless/ath/ath5k/led.c +index ca4b7ccd697f..afa0f764c617 100644 +--- a/drivers/net/wireless/ath/ath5k/led.c ++++ b/drivers/net/wireless/ath/ath5k/led.c +@@ -77,7 +77,7 @@ static const struct pci_device_id ath5k_led_devices[] = { + /* HP Compaq CQ60-206US (ddreggors@jumptv.com) */ + { ATH_SDEVICE(PCI_VENDOR_ID_HP, 0x0137a), ATH_LED(3, 1) }, + /* HP Compaq C700 (nitrousnrg@gmail.com) */ +- { ATH_SDEVICE(PCI_VENDOR_ID_HP, 0x0137b), ATH_LED(3, 1) }, ++ { ATH_SDEVICE(PCI_VENDOR_ID_HP, 0x0137b), ATH_LED(3, 0) }, + /* LiteOn AR5BXB63 (magooz@salug.it) */ + { ATH_SDEVICE(PCI_VENDOR_ID_ATHEROS, 0x3067), ATH_LED(3, 0) }, + /* IBM-specific AR5212 (all others) */ +diff --git a/drivers/net/wireless/ath/ath9k/init.c b/drivers/net/wireless/ath/ath9k/init.c +index 46a389c20bfc..b7b02549ef54 100644 +--- a/drivers/net/wireless/ath/ath9k/init.c ++++ b/drivers/net/wireless/ath/ath9k/init.c +@@ -49,6 +49,10 @@ int ath9k_led_blink; + module_param_named(blink, ath9k_led_blink, int, 0444); + MODULE_PARM_DESC(blink, "Enable LED blink on activity"); + ++static int ath9k_led_active_high = -1; ++module_param_named(led_active_high, ath9k_led_active_high, int, 0444); ++MODULE_PARM_DESC(led_active_high, "Invert LED polarity"); ++ + static int ath9k_btcoex_enable; + module_param_named(btcoex_enable, ath9k_btcoex_enable, int, 0444); + MODULE_PARM_DESC(btcoex_enable, "Enable wifi-BT coexistence"); +@@ -600,6 +604,9 @@ static int ath9k_init_softc(u16 devid, struct ath_softc *sc, + if (ret) + return ret; + ++ if (ath9k_led_active_high != -1) ++ ah->config.led_active_high = ath9k_led_active_high == 1; ++ + /* + * Enable WLAN/BT RX Antenna diversity only when: + * +diff --git a/drivers/net/wireless/ath/ath9k/pci.c b/drivers/net/wireless/ath/ath9k/pci.c +index e6fef1be9977..7cdaf40c3057 100644 +--- a/drivers/net/wireless/ath/ath9k/pci.c ++++ b/drivers/net/wireless/ath/ath9k/pci.c +@@ -28,6 +28,16 @@ static const struct pci_device_id ath_pci_id_table[] = { + { PCI_VDEVICE(ATHEROS, 0x0024) }, /* PCI-E */ + { PCI_VDEVICE(ATHEROS, 0x0027) }, /* PCI */ + { PCI_VDEVICE(ATHEROS, 0x0029) }, /* PCI */ ++ ++#ifdef CONFIG_ATH9K_PCOEM ++ /* Mini PCI AR9220 MB92 cards: Compex WLM200NX, Wistron DNMA-92 */ ++ { PCI_DEVICE_SUB(PCI_VENDOR_ID_ATHEROS, ++ 0x0029, ++ PCI_VENDOR_ID_ATHEROS, ++ 0x2096), ++ .driver_data = ATH9K_PCI_LED_ACT_HI }, ++#endif ++ + { PCI_VDEVICE(ATHEROS, 0x002A) }, /* PCI-E */ + + #ifdef CONFIG_ATH9K_PCOEM +diff --git a/drivers/net/wireless/rtlwifi/base.c b/drivers/net/wireless/rtlwifi/base.c +index 01f56c7df8b5..6b4c10676533 100644 +--- a/drivers/net/wireless/rtlwifi/base.c ++++ b/drivers/net/wireless/rtlwifi/base.c +@@ -1662,9 +1662,9 @@ void rtl_watchdog_wq_callback(void *data) + if (((rtlpriv->link_info.num_rx_inperiod + + rtlpriv->link_info.num_tx_inperiod) > 8) || + (rtlpriv->link_info.num_rx_inperiod > 2)) +- rtl_lps_enter(hw); +- else + rtl_lps_leave(hw); ++ else ++ rtl_lps_enter(hw); + } + + rtlpriv->link_info.num_rx_inperiod = 0; +diff --git a/drivers/net/wireless/rtlwifi/btcoexist/halbtc8723b2ant.c b/drivers/net/wireless/rtlwifi/btcoexist/halbtc8723b2ant.c +index cefe26991421..5c2c0a1b0353 100644 +--- a/drivers/net/wireless/rtlwifi/btcoexist/halbtc8723b2ant.c ++++ b/drivers/net/wireless/rtlwifi/btcoexist/halbtc8723b2ant.c +@@ -1203,7 +1203,6 @@ static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist, + + /* Force GNT_BT to low */ + btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x0); +- btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0); + + if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) { + /* tell firmware "no antenna inverse" */ +@@ -1211,19 +1210,25 @@ static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist, + h2c_parameter[1] = 1; /* ext switch type */ + btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, + h2c_parameter); ++ btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0); + } else { + /* tell firmware "antenna inverse" */ + h2c_parameter[0] = 1; + h2c_parameter[1] = 1; /* ext switch type */ + btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, + h2c_parameter); ++ btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280); + } + } + + /* ext switch setting */ + if (use_ext_switch) { + /* fixed internal switch S1->WiFi, S0->BT */ +- btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0); ++ if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) ++ btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0); ++ else ++ btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280); ++ + switch (antpos_type) { + case BTC_ANT_WIFI_AT_MAIN: + /* ext switch main at wifi */ +diff --git a/drivers/net/wireless/rtlwifi/btcoexist/halbtcoutsrc.c b/drivers/net/wireless/rtlwifi/btcoexist/halbtcoutsrc.c +index b2791c893417..babd1490f20c 100644 +--- a/drivers/net/wireless/rtlwifi/btcoexist/halbtcoutsrc.c ++++ b/drivers/net/wireless/rtlwifi/btcoexist/halbtcoutsrc.c +@@ -965,13 +965,38 @@ void exhalbtc_set_chip_type(u8 chip_type) + } + } + +-void exhalbtc_set_ant_num(u8 type, u8 ant_num) ++void exhalbtc_set_ant_num(struct rtl_priv *rtlpriv, u8 type, u8 ant_num) + { + if (BT_COEX_ANT_TYPE_PG == type) { + gl_bt_coexist.board_info.pg_ant_num = ant_num; + gl_bt_coexist.board_info.btdm_ant_num = ant_num; ++ /* The antenna position: ++ * Main (default) or Aux for pgAntNum=2 && btdmAntNum =1. ++ * The antenna position should be determined by ++ * auto-detect mechanism. ++ * The following is assumed to main, ++ * and those must be modified ++ * if y auto-detect mechanism is ready ++ */ ++ if ((gl_bt_coexist.board_info.pg_ant_num == 2) && ++ (gl_bt_coexist.board_info.btdm_ant_num == 1)) ++ gl_bt_coexist.board_info.btdm_ant_pos = ++ BTC_ANTENNA_AT_MAIN_PORT; ++ else ++ gl_bt_coexist.board_info.btdm_ant_pos = ++ BTC_ANTENNA_AT_MAIN_PORT; + } else if (BT_COEX_ANT_TYPE_ANTDIV == type) { + gl_bt_coexist.board_info.btdm_ant_num = ant_num; ++ gl_bt_coexist.board_info.btdm_ant_pos = ++ BTC_ANTENNA_AT_MAIN_PORT; ++ } else if (type == BT_COEX_ANT_TYPE_DETECTED) { ++ gl_bt_coexist.board_info.btdm_ant_num = ant_num; ++ if (rtlpriv->cfg->mod_params->ant_sel == 1) ++ gl_bt_coexist.board_info.btdm_ant_pos = ++ BTC_ANTENNA_AT_AUX_PORT; ++ else ++ gl_bt_coexist.board_info.btdm_ant_pos = ++ BTC_ANTENNA_AT_MAIN_PORT; + } + } + +diff --git a/drivers/net/wireless/rtlwifi/btcoexist/halbtcoutsrc.h b/drivers/net/wireless/rtlwifi/btcoexist/halbtcoutsrc.h +index 0a903ea179ef..f41ca57dd8a7 100644 +--- a/drivers/net/wireless/rtlwifi/btcoexist/halbtcoutsrc.h ++++ b/drivers/net/wireless/rtlwifi/btcoexist/halbtcoutsrc.h +@@ -535,7 +535,7 @@ void exhalbtc_set_bt_patch_version(u16 bt_hci_version, u16 bt_patch_version); + void exhalbtc_update_min_bt_rssi(char bt_rssi); + void exhalbtc_set_bt_exist(bool bt_exist); + void exhalbtc_set_chip_type(u8 chip_type); +-void exhalbtc_set_ant_num(u8 type, u8 ant_num); ++void exhalbtc_set_ant_num(struct rtl_priv *rtlpriv, u8 type, u8 ant_num); + void exhalbtc_display_bt_coex_info(struct btc_coexist *btcoexist); + void exhalbtc_signal_compensation(struct btc_coexist *btcoexist, + u8 *rssi_wifi, u8 *rssi_bt); +diff --git a/drivers/net/wireless/rtlwifi/btcoexist/rtl_btc.c b/drivers/net/wireless/rtlwifi/btcoexist/rtl_btc.c +index b9b0cb7af8ea..d3fd9211b3a4 100644 +--- a/drivers/net/wireless/rtlwifi/btcoexist/rtl_btc.c ++++ b/drivers/net/wireless/rtlwifi/btcoexist/rtl_btc.c +@@ -72,7 +72,10 @@ void rtl_btc_init_hal_vars(struct rtl_priv *rtlpriv) + __func__, bt_type); + exhalbtc_set_chip_type(bt_type); + +- exhalbtc_set_ant_num(BT_COEX_ANT_TYPE_PG, ant_num); ++ if (rtlpriv->cfg->mod_params->ant_sel == 1) ++ exhalbtc_set_ant_num(rtlpriv, BT_COEX_ANT_TYPE_DETECTED, 1); ++ else ++ exhalbtc_set_ant_num(rtlpriv, BT_COEX_ANT_TYPE_PG, ant_num); + } + + void rtl_btc_init_hw_config(struct rtl_priv *rtlpriv) +diff --git a/drivers/net/wireless/rtlwifi/pci.c b/drivers/net/wireless/rtlwifi/pci.c +index 7f471bff435c..5b4048041147 100644 +--- a/drivers/net/wireless/rtlwifi/pci.c ++++ b/drivers/net/wireless/rtlwifi/pci.c +@@ -1573,7 +1573,7 @@ int rtl_pci_reset_trx_ring(struct ieee80211_hw *hw) + true, + HW_DESC_TXBUFF_ADDR), + skb->len, PCI_DMA_TODEVICE); +- kfree_skb(skb); ++ dev_kfree_skb_irq(skb); + ring->idx = (ring->idx + 1) % ring->entries; + } + ring->idx = 0; +diff --git a/drivers/net/wireless/rtlwifi/rtl8723be/hw.c b/drivers/net/wireless/rtlwifi/rtl8723be/hw.c +index b9417268427e..bff9152c1ef0 100644 +--- a/drivers/net/wireless/rtlwifi/rtl8723be/hw.c ++++ b/drivers/net/wireless/rtlwifi/rtl8723be/hw.c +@@ -2684,6 +2684,7 @@ void rtl8723be_read_bt_coexist_info_from_hwpg(struct ieee80211_hw *hw, + bool auto_load_fail, u8 *hwinfo) + { + struct rtl_priv *rtlpriv = rtl_priv(hw); ++ struct rtl_mod_params *mod_params = rtlpriv->cfg->mod_params; + u8 value; + u32 tmpu_32; + +@@ -2702,6 +2703,10 @@ void rtl8723be_read_bt_coexist_info_from_hwpg(struct ieee80211_hw *hw, + rtlpriv->btcoexist.btc_info.ant_num = ANT_X2; + } + ++ /* override ant_num / ant_path */ ++ if (mod_params->ant_sel) ++ rtlpriv->btcoexist.btc_info.ant_num = ++ (mod_params->ant_sel == 1 ? ANT_X2 : ANT_X1); + } + + void rtl8723be_bt_reg_init(struct ieee80211_hw *hw) +diff --git a/drivers/net/wireless/rtlwifi/rtl8723be/sw.c b/drivers/net/wireless/rtlwifi/rtl8723be/sw.c +index 7bf88d9dcdc3..0adee281ded8 100644 +--- a/drivers/net/wireless/rtlwifi/rtl8723be/sw.c ++++ b/drivers/net/wireless/rtlwifi/rtl8723be/sw.c +@@ -93,7 +93,6 @@ int rtl8723be_init_sw_vars(struct ieee80211_hw *hw) + struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); + + rtl8723be_bt_reg_init(hw); +- rtlpci->msi_support = rtlpriv->cfg->mod_params->msi_support; + rtlpriv->btcoexist.btc_ops = rtl_btc_get_ops_pointer(); + + rtlpriv->dm.dm_initialgain_enable = 1; +@@ -151,6 +150,10 @@ int rtl8723be_init_sw_vars(struct ieee80211_hw *hw) + rtlpriv->psc.swctrl_lps = rtlpriv->cfg->mod_params->swctrl_lps; + rtlpriv->psc.fwctrl_lps = rtlpriv->cfg->mod_params->fwctrl_lps; + rtlpci->msi_support = rtlpriv->cfg->mod_params->msi_support; ++ rtlpriv->cfg->mod_params->sw_crypto = ++ rtlpriv->cfg->mod_params->sw_crypto; ++ rtlpriv->cfg->mod_params->disable_watchdog = ++ rtlpriv->cfg->mod_params->disable_watchdog; + if (rtlpriv->cfg->mod_params->disable_watchdog) + pr_info("watchdog disabled\n"); + rtlpriv->psc.reg_fwctrl_lps = 3; +@@ -267,6 +270,10 @@ static struct rtl_mod_params rtl8723be_mod_params = { + .inactiveps = true, + .swctrl_lps = false, + .fwctrl_lps = true, ++ .msi_support = false, ++ .disable_watchdog = false, ++ .debug = DBG_EMERG, ++ .ant_sel = 0, + }; + + static struct rtl_hal_cfg rtl8723be_hal_cfg = { +@@ -388,6 +395,7 @@ module_param_named(fwlps, rtl8723be_mod_params.fwctrl_lps, bool, 0444); + module_param_named(msi, rtl8723be_mod_params.msi_support, bool, 0444); + module_param_named(disable_watchdog, rtl8723be_mod_params.disable_watchdog, + bool, 0444); ++module_param_named(ant_sel, rtl8723be_mod_params.ant_sel, int, 0444); + MODULE_PARM_DESC(swenc, "Set to 1 for software crypto (default 0)\n"); + MODULE_PARM_DESC(ips, "Set to 0 to not use link power save (default 1)\n"); + MODULE_PARM_DESC(swlps, "Set to 1 to use SW control power save (default 0)\n"); +@@ -396,6 +404,7 @@ MODULE_PARM_DESC(msi, "Set to 1 to use MSI interrupts mode (default 0)\n"); + MODULE_PARM_DESC(debug, "Set debug level (0-5) (default 0)"); + MODULE_PARM_DESC(disable_watchdog, + "Set to 1 to disable the watchdog (default 0)\n"); ++MODULE_PARM_DESC(ant_sel, "Set to 1 or 2 to force antenna number (default 0)\n"); + + static SIMPLE_DEV_PM_OPS(rtlwifi_pm_ops, rtl_pci_suspend, rtl_pci_resume); + +diff --git a/drivers/net/wireless/rtlwifi/wifi.h b/drivers/net/wireless/rtlwifi/wifi.h +index f1fa8100f288..2fb502418fcb 100644 +--- a/drivers/net/wireless/rtlwifi/wifi.h ++++ b/drivers/net/wireless/rtlwifi/wifi.h +@@ -2236,6 +2236,9 @@ struct rtl_mod_params { + + /* default 0: 1 means do not disable interrupts */ + bool int_clear; ++ ++ /* select antenna */ ++ int ant_sel; + }; + + struct rtl_hal_usbint_cfg { +diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c +index 25ad1b27ffae..993ff22df7ec 100644 +--- a/drivers/pci/probe.c ++++ b/drivers/pci/probe.c +@@ -176,9 +176,6 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type, + u16 orig_cmd; + struct pci_bus_region region, inverted_region; + +- if (dev->non_compliant_bars) +- return 0; +- + mask = type ? PCI_ROM_ADDRESS_MASK : ~0; + + /* No printks while decoding is disabled! */ +@@ -319,6 +316,9 @@ static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom) + { + unsigned int pos, reg; + ++ if (dev->non_compliant_bars) ++ return; ++ + for (pos = 0; pos < howmany; pos++) { + struct resource *res = &dev->resource[pos]; + reg = PCI_BASE_ADDRESS_0 + (pos << 2); +diff --git a/drivers/pinctrl/samsung/pinctrl-exynos5440.c b/drivers/pinctrl/samsung/pinctrl-exynos5440.c +index 86192be3b679..cd047556d9ca 100644 +--- a/drivers/pinctrl/samsung/pinctrl-exynos5440.c ++++ b/drivers/pinctrl/samsung/pinctrl-exynos5440.c +@@ -109,6 +109,7 @@ struct exynos5440_pmx_func { + * @nr_groups: number of pin groups available. + * @pmx_functions: list of pin functions parsed from device tree. + * @nr_functions: number of pin functions available. ++ * @range: gpio range to register with pinctrl + */ + struct exynos5440_pinctrl_priv_data { + void __iomem *reg_base; +@@ -119,6 +120,7 @@ struct exynos5440_pinctrl_priv_data { + unsigned int nr_groups; + const struct exynos5440_pmx_func *pmx_functions; + unsigned int nr_functions; ++ struct pinctrl_gpio_range range; + }; + + /** +@@ -769,7 +771,6 @@ static int exynos5440_pinctrl_register(struct platform_device *pdev, + struct pinctrl_desc *ctrldesc; + struct pinctrl_dev *pctl_dev; + struct pinctrl_pin_desc *pindesc, *pdesc; +- struct pinctrl_gpio_range grange; + char *pin_names; + int pin, ret; + +@@ -827,12 +828,12 @@ static int exynos5440_pinctrl_register(struct platform_device *pdev, + return -EINVAL; + } + +- grange.name = "exynos5440-pctrl-gpio-range"; +- grange.id = 0; +- grange.base = 0; +- grange.npins = EXYNOS5440_MAX_PINS; +- grange.gc = priv->gc; +- pinctrl_add_gpio_range(pctl_dev, &grange); ++ priv->range.name = "exynos5440-pctrl-gpio-range"; ++ priv->range.id = 0; ++ priv->range.base = 0; ++ priv->range.npins = EXYNOS5440_MAX_PINS; ++ priv->range.gc = priv->gc; ++ pinctrl_add_gpio_range(pctl_dev, &priv->range); + return 0; + } + +diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c +index 8a28116b5805..b352a1fa2f2a 100644 +--- a/drivers/regulator/core.c ++++ b/drivers/regulator/core.c +@@ -110,6 +110,11 @@ static struct regulator *create_regulator(struct regulator_dev *rdev, + struct device *dev, + const char *supply_name); + ++static struct regulator_dev *dev_to_rdev(struct device *dev) ++{ ++ return container_of(dev, struct regulator_dev, dev); ++} ++ + static const char *rdev_get_name(struct regulator_dev *rdev) + { + if (rdev->constraints && rdev->constraints->name) +@@ -3587,6 +3592,11 @@ static void rdev_init_debugfs(struct regulator_dev *rdev) + &rdev->bypass_count); + } + ++static int regulator_register_resolve_supply(struct device *dev, void *data) ++{ ++ return regulator_resolve_supply(dev_to_rdev(dev)); ++} ++ + /** + * regulator_register - register regulator + * @regulator_desc: regulator to register +@@ -3735,6 +3745,10 @@ regulator_register(const struct regulator_desc *regulator_desc, + list_add(&rdev->list, ®ulator_list); + + rdev_init_debugfs(rdev); ++ ++ /* try to resolve regulators supply since a new one was registered */ ++ class_for_each_device(®ulator_class, NULL, NULL, ++ regulator_register_resolve_supply); + out: + mutex_unlock(®ulator_list_mutex); + kfree(config); +@@ -4104,13 +4118,57 @@ static int __init regulator_init(void) + /* init early to allow our consumers to complete system booting */ + core_initcall(regulator_init); + +-static int __init regulator_init_complete(void) ++static int __init regulator_late_cleanup(struct device *dev, void *data) + { +- struct regulator_dev *rdev; +- const struct regulator_ops *ops; +- struct regulation_constraints *c; ++ struct regulator_dev *rdev = dev_to_rdev(dev); ++ const struct regulator_ops *ops = rdev->desc->ops; ++ struct regulation_constraints *c = rdev->constraints; + int enabled, ret; + ++ if (c && c->always_on) ++ return 0; ++ ++ if (c && !(c->valid_ops_mask & REGULATOR_CHANGE_STATUS)) ++ return 0; ++ ++ mutex_lock(&rdev->mutex); ++ ++ if (rdev->use_count) ++ goto unlock; ++ ++ /* If we can't read the status assume it's on. */ ++ if (ops->is_enabled) ++ enabled = ops->is_enabled(rdev); ++ else ++ enabled = 1; ++ ++ if (!enabled) ++ goto unlock; ++ ++ if (have_full_constraints()) { ++ /* We log since this may kill the system if it goes ++ * wrong. */ ++ rdev_info(rdev, "disabling\n"); ++ ret = _regulator_do_disable(rdev); ++ if (ret != 0) ++ rdev_err(rdev, "couldn't disable: %d\n", ret); ++ } else { ++ /* The intention is that in future we will ++ * assume that full constraints are provided ++ * so warn even if we aren't going to do ++ * anything here. ++ */ ++ rdev_warn(rdev, "incomplete constraints, leaving on\n"); ++ } ++ ++unlock: ++ mutex_unlock(&rdev->mutex); ++ ++ return 0; ++} ++ ++static int __init regulator_init_complete(void) ++{ + /* + * Since DT doesn't provide an idiomatic mechanism for + * enabling full constraints and since it's much more natural +@@ -4120,58 +4178,13 @@ static int __init regulator_init_complete(void) + if (of_have_populated_dt()) + has_full_constraints = true; + +- mutex_lock(®ulator_list_mutex); +- + /* If we have a full configuration then disable any regulators + * we have permission to change the status for and which are + * not in use or always_on. This is effectively the default + * for DT and ACPI as they have full constraints. + */ +- list_for_each_entry(rdev, ®ulator_list, list) { +- ops = rdev->desc->ops; +- c = rdev->constraints; +- +- if (c && c->always_on) +- continue; +- +- if (c && !(c->valid_ops_mask & REGULATOR_CHANGE_STATUS)) +- continue; +- +- mutex_lock(&rdev->mutex); +- +- if (rdev->use_count) +- goto unlock; +- +- /* If we can't read the status assume it's on. */ +- if (ops->is_enabled) +- enabled = ops->is_enabled(rdev); +- else +- enabled = 1; +- +- if (!enabled) +- goto unlock; +- +- if (have_full_constraints()) { +- /* We log since this may kill the system if it +- * goes wrong. */ +- rdev_info(rdev, "disabling\n"); +- ret = _regulator_do_disable(rdev); +- if (ret != 0) +- rdev_err(rdev, "couldn't disable: %d\n", ret); +- } else { +- /* The intention is that in future we will +- * assume that full constraints are provided +- * so warn even if we aren't going to do +- * anything here. +- */ +- rdev_warn(rdev, "incomplete constraints, leaving on\n"); +- } +- +-unlock: +- mutex_unlock(&rdev->mutex); +- } +- +- mutex_unlock(®ulator_list_mutex); ++ class_for_each_device(®ulator_class, NULL, NULL, ++ regulator_late_cleanup); + + return 0; + } +diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h +index 18c9c0648bd0..3e8e92b1535d 100644 +--- a/drivers/scsi/aacraid/aacraid.h ++++ b/drivers/scsi/aacraid/aacraid.h +@@ -29,6 +29,7 @@ enum { + #define AAC_INT_MODE_MSI (1<<1) + #define AAC_INT_MODE_AIF (1<<2) + #define AAC_INT_MODE_SYNC (1<<3) ++#define AAC_INT_MODE_MSIX (1<<16) + + #define AAC_INT_ENABLE_TYPE1_INTX 0xfffffffb + #define AAC_INT_ENABLE_TYPE1_MSIX 0xfffffffa +diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c +index 45db84ad322f..e736ecb3b8a4 100644 +--- a/drivers/scsi/aacraid/comminit.c ++++ b/drivers/scsi/aacraid/comminit.c +@@ -37,6 +37,7 @@ + #include <linux/spinlock.h> + #include <linux/slab.h> + #include <linux/blkdev.h> ++#include <linux/delay.h> + #include <linux/completion.h> + #include <linux/mm.h> + #include <scsi/scsi_host.h> +@@ -49,6 +50,20 @@ struct aac_common aac_config = { + .irq_mod = 1 + }; + ++static inline int aac_is_msix_mode(struct aac_dev *dev) ++{ ++ u32 status; ++ ++ status = src_readl(dev, MUnit.OMR); ++ return (status & AAC_INT_MODE_MSIX); ++} ++ ++static inline void aac_change_to_intx(struct aac_dev *dev) ++{ ++ aac_src_access_devreg(dev, AAC_DISABLE_MSIX); ++ aac_src_access_devreg(dev, AAC_ENABLE_INTX); ++} ++ + static int aac_alloc_comm(struct aac_dev *dev, void **commaddr, unsigned long commsize, unsigned long commalign) + { + unsigned char *base; +@@ -358,6 +373,15 @@ struct aac_dev *aac_init_adapter(struct aac_dev *dev) + dev->comm_interface = AAC_COMM_PRODUCER; + dev->raw_io_interface = dev->raw_io_64 = 0; + ++ ++ /* ++ * Enable INTX mode, if not done already Enabled ++ */ ++ if (aac_is_msix_mode(dev)) { ++ aac_change_to_intx(dev); ++ dev_info(&dev->pdev->dev, "Changed firmware to INTX mode"); ++ } ++ + if ((!aac_adapter_sync_cmd(dev, GET_ADAPTER_PROPERTIES, + 0, 0, 0, 0, 0, 0, + status+0, status+1, status+2, status+3, NULL)) && +diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c +index 4b79d9511778..9410ffe68d0a 100644 +--- a/drivers/scsi/aacraid/commsup.c ++++ b/drivers/scsi/aacraid/commsup.c +@@ -611,10 +611,10 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size, + } + return -EFAULT; + } +- /* We used to udelay() here but that absorbed +- * a CPU when a timeout occured. Not very +- * useful. */ +- cpu_relax(); ++ /* ++ * Allow other processes / CPUS to use core ++ */ ++ schedule(); + } + } else if (down_interruptible(&fibptr->event_wait)) { + /* Do nothing ... satisfy +@@ -1999,6 +1999,10 @@ int aac_command_thread(void *data) + if (difference <= 0) + difference = 1; + set_current_state(TASK_INTERRUPTIBLE); ++ ++ if (kthread_should_stop()) ++ break; ++ + schedule_timeout(difference); + + if (kthread_should_stop()) +diff --git a/drivers/staging/comedi/drivers/das1800.c b/drivers/staging/comedi/drivers/das1800.c +index 53baf37cd21a..2e78d1fe1f09 100644 +--- a/drivers/staging/comedi/drivers/das1800.c ++++ b/drivers/staging/comedi/drivers/das1800.c +@@ -567,14 +567,17 @@ static int das1800_cancel(struct comedi_device *dev, struct comedi_subdevice *s) + struct comedi_isadma_desc *desc; + int i; + +- outb(0x0, dev->iobase + DAS1800_STATUS); /* disable conversions */ +- outb(0x0, dev->iobase + DAS1800_CONTROL_B); /* disable interrupts and dma */ +- outb(0x0, dev->iobase + DAS1800_CONTROL_A); /* disable and clear fifo and stop triggering */ +- +- for (i = 0; i < 2; i++) { +- desc = &dma->desc[i]; +- if (desc->chan) +- comedi_isadma_disable(desc->chan); ++ /* disable and stop conversions */ ++ outb(0x0, dev->iobase + DAS1800_STATUS); ++ outb(0x0, dev->iobase + DAS1800_CONTROL_B); ++ outb(0x0, dev->iobase + DAS1800_CONTROL_A); ++ ++ if (dma) { ++ for (i = 0; i < 2; i++) { ++ desc = &dma->desc[i]; ++ if (desc->chan) ++ comedi_isadma_disable(desc->chan); ++ } + } + + return 0; +@@ -934,13 +937,14 @@ static void das1800_ai_setup_dma(struct comedi_device *dev, + { + struct das1800_private *devpriv = dev->private; + struct comedi_isadma *dma = devpriv->dma; +- struct comedi_isadma_desc *desc = &dma->desc[0]; ++ struct comedi_isadma_desc *desc; + unsigned int bytes; + + if ((devpriv->irq_dma_bits & DMA_ENABLED) == 0) + return; + + dma->cur_dma = 0; ++ desc = &dma->desc[0]; + + /* determine a dma transfer size to fill buffer in 0.3 sec */ + bytes = das1800_ai_transfer_size(dev, s, desc->maxsize, 300000000); +diff --git a/drivers/thunderbolt/eeprom.c b/drivers/thunderbolt/eeprom.c +index 0dde34e3a7c5..545c60c826a1 100644 +--- a/drivers/thunderbolt/eeprom.c ++++ b/drivers/thunderbolt/eeprom.c +@@ -444,6 +444,7 @@ int tb_drom_read(struct tb_switch *sw) + return tb_drom_parse_entries(sw); + err: + kfree(sw->drom); ++ sw->drom = NULL; + return -EIO; + + } +diff --git a/drivers/tty/n_gsm.c b/drivers/tty/n_gsm.c +index 2c34c3249972..2ec337612a79 100644 +--- a/drivers/tty/n_gsm.c ++++ b/drivers/tty/n_gsm.c +@@ -2045,7 +2045,9 @@ static void gsm_cleanup_mux(struct gsm_mux *gsm) + } + } + spin_unlock(&gsm_mux_lock); +- WARN_ON(i == MAX_MUX); ++ /* open failed before registering => nothing to do */ ++ if (i == MAX_MUX) ++ return; + + /* In theory disconnecting DLCI 0 is sufficient but for some + modems this is apparently not the case. */ +diff --git a/drivers/tty/n_hdlc.c b/drivers/tty/n_hdlc.c +index bbc4ce66c2c1..644ddb841d9f 100644 +--- a/drivers/tty/n_hdlc.c ++++ b/drivers/tty/n_hdlc.c +@@ -600,7 +600,7 @@ static ssize_t n_hdlc_tty_read(struct tty_struct *tty, struct file *file, + add_wait_queue(&tty->read_wait, &wait); + + for (;;) { +- if (test_bit(TTY_OTHER_DONE, &tty->flags)) { ++ if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) { + ret = -EIO; + break; + } +@@ -828,7 +828,7 @@ static unsigned int n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp, + /* set bits for operations that won't block */ + if (n_hdlc->rx_buf_list.head) + mask |= POLLIN | POLLRDNORM; /* readable */ +- if (test_bit(TTY_OTHER_DONE, &tty->flags)) ++ if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) + mask |= POLLHUP; + if (tty_hung_up_p(filp)) + mask |= POLLHUP; +diff --git a/drivers/tty/n_tty.c b/drivers/tty/n_tty.c +index 33088c70ef3b..aba20f66bdd9 100644 +--- a/drivers/tty/n_tty.c ++++ b/drivers/tty/n_tty.c +@@ -1962,18 +1962,6 @@ static inline int input_available_p(struct tty_struct *tty, int poll) + return ldata->commit_head - ldata->read_tail >= amt; + } + +-static inline int check_other_done(struct tty_struct *tty) +-{ +- int done = test_bit(TTY_OTHER_DONE, &tty->flags); +- if (done) { +- /* paired with cmpxchg() in check_other_closed(); ensures +- * read buffer head index is not stale +- */ +- smp_mb__after_atomic(); +- } +- return done; +-} +- + /** + * copy_from_read_buf - copy read data directly + * @tty: terminal device +@@ -2192,7 +2180,7 @@ static ssize_t n_tty_read(struct tty_struct *tty, struct file *file, + struct n_tty_data *ldata = tty->disc_data; + unsigned char __user *b = buf; + DEFINE_WAIT_FUNC(wait, woken_wake_function); +- int c, done; ++ int c; + int minimum, time; + ssize_t retval = 0; + long timeout; +@@ -2260,32 +2248,35 @@ static ssize_t n_tty_read(struct tty_struct *tty, struct file *file, + ((minimum - (b - buf)) >= 1)) + ldata->minimum_to_wake = (minimum - (b - buf)); + +- done = check_other_done(tty); +- + if (!input_available_p(tty, 0)) { +- if (done) { +- retval = -EIO; +- break; +- } +- if (tty_hung_up_p(file)) +- break; +- if (!timeout) +- break; +- if (file->f_flags & O_NONBLOCK) { +- retval = -EAGAIN; +- break; +- } +- if (signal_pending(current)) { +- retval = -ERESTARTSYS; +- break; +- } + up_read(&tty->termios_rwsem); ++ tty_buffer_flush_work(tty->port); ++ down_read(&tty->termios_rwsem); ++ if (!input_available_p(tty, 0)) { ++ if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) { ++ retval = -EIO; ++ break; ++ } ++ if (tty_hung_up_p(file)) ++ break; ++ if (!timeout) ++ break; ++ if (file->f_flags & O_NONBLOCK) { ++ retval = -EAGAIN; ++ break; ++ } ++ if (signal_pending(current)) { ++ retval = -ERESTARTSYS; ++ break; ++ } ++ up_read(&tty->termios_rwsem); + +- timeout = wait_woken(&wait, TASK_INTERRUPTIBLE, +- timeout); ++ timeout = wait_woken(&wait, TASK_INTERRUPTIBLE, ++ timeout); + +- down_read(&tty->termios_rwsem); +- continue; ++ down_read(&tty->termios_rwsem); ++ continue; ++ } + } + + if (ldata->icanon && !L_EXTPROC(tty)) { +@@ -2470,12 +2461,17 @@ static unsigned int n_tty_poll(struct tty_struct *tty, struct file *file, + + poll_wait(file, &tty->read_wait, wait); + poll_wait(file, &tty->write_wait, wait); +- if (check_other_done(tty)) +- mask |= POLLHUP; + if (input_available_p(tty, 1)) + mask |= POLLIN | POLLRDNORM; ++ else { ++ tty_buffer_flush_work(tty->port); ++ if (input_available_p(tty, 1)) ++ mask |= POLLIN | POLLRDNORM; ++ } + if (tty->packet && tty->link->ctrl_status) + mask |= POLLPRI | POLLIN | POLLRDNORM; ++ if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) ++ mask |= POLLHUP; + if (tty_hung_up_p(file)) + mask |= POLLHUP; + if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) { +diff --git a/drivers/tty/pty.c b/drivers/tty/pty.c +index 254c183a5efe..b1f78aafb2d0 100644 +--- a/drivers/tty/pty.c ++++ b/drivers/tty/pty.c +@@ -54,7 +54,7 @@ static void pty_close(struct tty_struct *tty, struct file *filp) + if (!tty->link) + return; + set_bit(TTY_OTHER_CLOSED, &tty->link->flags); +- tty_flip_buffer_push(tty->link->port); ++ wake_up_interruptible(&tty->link->read_wait); + wake_up_interruptible(&tty->link->write_wait); + if (tty->driver->subtype == PTY_TYPE_MASTER) { + set_bit(TTY_OTHER_CLOSED, &tty->flags); +@@ -242,9 +242,7 @@ static int pty_open(struct tty_struct *tty, struct file *filp) + goto out; + + clear_bit(TTY_IO_ERROR, &tty->flags); +- /* TTY_OTHER_CLOSED must be cleared before TTY_OTHER_DONE */ + clear_bit(TTY_OTHER_CLOSED, &tty->link->flags); +- clear_bit(TTY_OTHER_DONE, &tty->link->flags); + set_bit(TTY_THROTTLED, &tty->flags); + return 0; + +diff --git a/drivers/tty/serial/8250/8250_pci.c b/drivers/tty/serial/8250/8250_pci.c +index b82b2a0f82a3..a78a62bf0c96 100644 +--- a/drivers/tty/serial/8250/8250_pci.c ++++ b/drivers/tty/serial/8250/8250_pci.c +@@ -1402,6 +1402,9 @@ byt_set_termios(struct uart_port *p, struct ktermios *termios, + unsigned long m, n; + u32 reg; + ++ /* Gracefully handle the B0 case: fall back to B9600 */ ++ fuart = fuart ? fuart : 9600 * 16; ++ + /* Get Fuart closer to Fref */ + fuart *= rounddown_pow_of_two(fref / fuart); + +diff --git a/drivers/tty/serial/ucc_uart.c b/drivers/tty/serial/ucc_uart.c +index 7d2532b23969..100c2413c22f 100644 +--- a/drivers/tty/serial/ucc_uart.c ++++ b/drivers/tty/serial/ucc_uart.c +@@ -1478,6 +1478,9 @@ static const struct of_device_id ucc_uart_match[] = { + .type = "serial", + .compatible = "ucc_uart", + }, ++ { ++ .compatible = "fsl,t1040-ucc-uart", ++ }, + {}, + }; + MODULE_DEVICE_TABLE(of, ucc_uart_match); +diff --git a/drivers/tty/tty_buffer.c b/drivers/tty/tty_buffer.c +index 2f78b77f0f81..6b9de83d297e 100644 +--- a/drivers/tty/tty_buffer.c ++++ b/drivers/tty/tty_buffer.c +@@ -37,29 +37,6 @@ + + #define TTY_BUFFER_PAGE (((PAGE_SIZE - sizeof(struct tty_buffer)) / 2) & ~0xFF) + +-/* +- * If all tty flip buffers have been processed by flush_to_ldisc() or +- * dropped by tty_buffer_flush(), check if the linked pty has been closed. +- * If so, wake the reader/poll to process +- */ +-static inline void check_other_closed(struct tty_struct *tty) +-{ +- unsigned long flags, old; +- +- /* transition from TTY_OTHER_CLOSED => TTY_OTHER_DONE must be atomic */ +- for (flags = ACCESS_ONCE(tty->flags); +- test_bit(TTY_OTHER_CLOSED, &flags); +- ) { +- old = flags; +- __set_bit(TTY_OTHER_DONE, &flags); +- flags = cmpxchg(&tty->flags, old, flags); +- if (old == flags) { +- wake_up_interruptible(&tty->read_wait); +- break; +- } +- } +-} +- + /** + * tty_buffer_lock_exclusive - gain exclusive access to buffer + * tty_buffer_unlock_exclusive - release exclusive access +@@ -251,8 +228,6 @@ void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld) + if (ld && ld->ops->flush_buffer) + ld->ops->flush_buffer(tty); + +- check_other_closed(tty); +- + atomic_dec(&buf->priority); + mutex_unlock(&buf->lock); + } +@@ -495,10 +470,8 @@ static void flush_to_ldisc(struct work_struct *work) + smp_rmb(); + count = head->commit - head->read; + if (!count) { +- if (next == NULL) { +- check_other_closed(tty); ++ if (next == NULL) + break; +- } + buf->head = next; + tty_buffer_free(port, head); + continue; +@@ -576,3 +549,8 @@ void tty_buffer_set_lock_subclass(struct tty_port *port) + { + lockdep_set_subclass(&port->buf.lock, TTY_LOCK_SLAVE); + } ++ ++void tty_buffer_flush_work(struct tty_port *port) ++{ ++ flush_work(&port->buf.work); ++} +diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c +index 7792c0e2d3b6..68323c267672 100644 +--- a/drivers/usb/core/driver.c ++++ b/drivers/usb/core/driver.c +@@ -283,7 +283,7 @@ static int usb_probe_interface(struct device *dev) + struct usb_device *udev = interface_to_usbdev(intf); + const struct usb_device_id *id; + int error = -ENODEV; +- int lpm_disable_error; ++ int lpm_disable_error = -ENODEV; + + dev_dbg(dev, "%s\n", __func__); + +@@ -331,12 +331,14 @@ static int usb_probe_interface(struct device *dev) + * setting during probe, that should also be fine. usb_set_interface() + * will attempt to disable LPM, and fail if it can't disable it. + */ +- lpm_disable_error = usb_unlocked_disable_lpm(udev); +- if (lpm_disable_error && driver->disable_hub_initiated_lpm) { +- dev_err(&intf->dev, "%s Failed to disable LPM for driver %s\n.", +- __func__, driver->name); +- error = lpm_disable_error; +- goto err; ++ if (driver->disable_hub_initiated_lpm) { ++ lpm_disable_error = usb_unlocked_disable_lpm(udev); ++ if (lpm_disable_error) { ++ dev_err(&intf->dev, "%s Failed to disable LPM for driver %s\n.", ++ __func__, driver->name); ++ error = lpm_disable_error; ++ goto err; ++ } + } + + /* Carry out a deferred switch to altsetting 0 */ +@@ -386,7 +388,8 @@ static int usb_unbind_interface(struct device *dev) + struct usb_interface *intf = to_usb_interface(dev); + struct usb_host_endpoint *ep, **eps = NULL; + struct usb_device *udev; +- int i, j, error, r, lpm_disable_error; ++ int i, j, error, r; ++ int lpm_disable_error = -ENODEV; + + intf->condition = USB_INTERFACE_UNBINDING; + +@@ -394,12 +397,13 @@ static int usb_unbind_interface(struct device *dev) + udev = interface_to_usbdev(intf); + error = usb_autoresume_device(udev); + +- /* Hub-initiated LPM policy may change, so attempt to disable LPM until ++ /* If hub-initiated LPM policy may change, attempt to disable LPM until + * the driver is unbound. If LPM isn't disabled, that's fine because it + * wouldn't be enabled unless all the bound interfaces supported + * hub-initiated LPM. + */ +- lpm_disable_error = usb_unlocked_disable_lpm(udev); ++ if (driver->disable_hub_initiated_lpm) ++ lpm_disable_error = usb_unlocked_disable_lpm(udev); + + /* + * Terminate all URBs for this interface unless the driver +@@ -502,7 +506,7 @@ int usb_driver_claim_interface(struct usb_driver *driver, + struct device *dev; + struct usb_device *udev; + int retval = 0; +- int lpm_disable_error; ++ int lpm_disable_error = -ENODEV; + + if (!iface) + return -ENODEV; +@@ -519,12 +523,14 @@ int usb_driver_claim_interface(struct usb_driver *driver, + + iface->condition = USB_INTERFACE_BOUND; + +- /* Disable LPM until this driver is bound. */ +- lpm_disable_error = usb_unlocked_disable_lpm(udev); +- if (lpm_disable_error && driver->disable_hub_initiated_lpm) { +- dev_err(&iface->dev, "%s Failed to disable LPM for driver %s\n.", +- __func__, driver->name); +- return -ENOMEM; ++ /* See the comment about disabling LPM in usb_probe_interface(). */ ++ if (driver->disable_hub_initiated_lpm) { ++ lpm_disable_error = usb_unlocked_disable_lpm(udev); ++ if (lpm_disable_error) { ++ dev_err(&iface->dev, "%s Failed to disable LPM for driver %s\n.", ++ __func__, driver->name); ++ return -ENOMEM; ++ } + } + + /* Claimed interfaces are initially inactive (suspended) and +diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c +index 1c1385e3a824..e47cfcd5640c 100644 +--- a/drivers/usb/core/hcd.c ++++ b/drivers/usb/core/hcd.c +@@ -915,7 +915,7 @@ static void usb_bus_init (struct usb_bus *bus) + bus->bandwidth_allocated = 0; + bus->bandwidth_int_reqs = 0; + bus->bandwidth_isoc_reqs = 0; +- mutex_init(&bus->usb_address0_mutex); ++ mutex_init(&bus->devnum_next_mutex); + + INIT_LIST_HEAD (&bus->bus_list); + } +@@ -2446,6 +2446,14 @@ struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver, + return NULL; + } + if (primary_hcd == NULL) { ++ hcd->address0_mutex = kmalloc(sizeof(*hcd->address0_mutex), ++ GFP_KERNEL); ++ if (!hcd->address0_mutex) { ++ kfree(hcd); ++ dev_dbg(dev, "hcd address0 mutex alloc failed\n"); ++ return NULL; ++ } ++ mutex_init(hcd->address0_mutex); + hcd->bandwidth_mutex = kmalloc(sizeof(*hcd->bandwidth_mutex), + GFP_KERNEL); + if (!hcd->bandwidth_mutex) { +@@ -2457,6 +2465,7 @@ struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver, + dev_set_drvdata(dev, hcd); + } else { + mutex_lock(&usb_port_peer_mutex); ++ hcd->address0_mutex = primary_hcd->address0_mutex; + hcd->bandwidth_mutex = primary_hcd->bandwidth_mutex; + hcd->primary_hcd = primary_hcd; + primary_hcd->primary_hcd = primary_hcd; +@@ -2523,8 +2532,10 @@ static void hcd_release(struct kref *kref) + struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref); + + mutex_lock(&usb_port_peer_mutex); +- if (usb_hcd_is_primary_hcd(hcd)) ++ if (usb_hcd_is_primary_hcd(hcd)) { ++ kfree(hcd->address0_mutex); + kfree(hcd->bandwidth_mutex); ++ } + if (hcd->shared_hcd) { + struct usb_hcd *peer = hcd->shared_hcd; + +diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c +index db6985f04054..563d84eb484d 100644 +--- a/drivers/usb/core/hub.c ++++ b/drivers/usb/core/hub.c +@@ -2066,7 +2066,7 @@ static void choose_devnum(struct usb_device *udev) + struct usb_bus *bus = udev->bus; + + /* be safe when more hub events are proceed in parallel */ +- mutex_lock(&bus->usb_address0_mutex); ++ mutex_lock(&bus->devnum_next_mutex); + if (udev->wusb) { + devnum = udev->portnum + 1; + BUG_ON(test_bit(devnum, bus->devmap.devicemap)); +@@ -2084,7 +2084,7 @@ static void choose_devnum(struct usb_device *udev) + set_bit(devnum, bus->devmap.devicemap); + udev->devnum = devnum; + } +- mutex_unlock(&bus->usb_address0_mutex); ++ mutex_unlock(&bus->devnum_next_mutex); + } + + static void release_devnum(struct usb_device *udev) +@@ -4257,7 +4257,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1, + if (oldspeed == USB_SPEED_LOW) + delay = HUB_LONG_RESET_TIME; + +- mutex_lock(&hdev->bus->usb_address0_mutex); ++ mutex_lock(hcd->address0_mutex); + + /* Reset the device; full speed may morph to high speed */ + /* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */ +@@ -4539,7 +4539,7 @@ fail: + hub_port_disable(hub, port1, 0); + update_devnum(udev, devnum); /* for disconnect processing */ + } +- mutex_unlock(&hdev->bus->usb_address0_mutex); ++ mutex_unlock(hcd->address0_mutex); + return retval; + } + +diff --git a/drivers/usb/gadget/function/f_mass_storage.c b/drivers/usb/gadget/function/f_mass_storage.c +index 15c307155037..917d99ccf7e4 100644 +--- a/drivers/usb/gadget/function/f_mass_storage.c ++++ b/drivers/usb/gadget/function/f_mass_storage.c +@@ -279,9 +279,8 @@ struct fsg_common { + int cmnd_size; + u8 cmnd[MAX_COMMAND_SIZE]; + +- unsigned int nluns; + unsigned int lun; +- struct fsg_lun **luns; ++ struct fsg_lun *luns[FSG_MAX_LUNS]; + struct fsg_lun *curlun; + + unsigned int bulk_out_maxpacket; +@@ -490,6 +489,16 @@ static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req) + spin_unlock(&common->lock); + } + ++static int _fsg_common_get_max_lun(struct fsg_common *common) ++{ ++ int i = ARRAY_SIZE(common->luns) - 1; ++ ++ while (i >= 0 && !common->luns[i]) ++ --i; ++ ++ return i; ++} ++ + static int fsg_setup(struct usb_function *f, + const struct usb_ctrlrequest *ctrl) + { +@@ -533,7 +542,7 @@ static int fsg_setup(struct usb_function *f, + w_length != 1) + return -EDOM; + VDBG(fsg, "get max LUN\n"); +- *(u8 *)req->buf = fsg->common->nluns - 1; ++ *(u8 *)req->buf = _fsg_common_get_max_lun(fsg->common); + + /* Respond with data/status */ + req->length = min((u16)1, w_length); +@@ -2131,8 +2140,9 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh) + } + + /* Is the CBW meaningful? */ +- if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~US_BULK_FLAG_IN || +- cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) { ++ if (cbw->Lun >= ARRAY_SIZE(common->luns) || ++ cbw->Flags & ~US_BULK_FLAG_IN || cbw->Length <= 0 || ++ cbw->Length > MAX_COMMAND_SIZE) { + DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, " + "cmdlen %u\n", + cbw->Lun, cbw->Flags, cbw->Length); +@@ -2159,7 +2169,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh) + if (common->data_size == 0) + common->data_dir = DATA_DIR_NONE; + common->lun = cbw->Lun; +- if (common->lun < common->nluns) ++ if (common->lun < ARRAY_SIZE(common->luns)) + common->curlun = common->luns[common->lun]; + else + common->curlun = NULL; +@@ -2307,7 +2317,7 @@ reset: + } + + common->running = 1; +- for (i = 0; i < common->nluns; ++i) ++ for (i = 0; i < ARRAY_SIZE(common->luns); ++i) + if (common->luns[i]) + common->luns[i]->unit_attention_data = + SS_RESET_OCCURRED; +@@ -2409,7 +2419,7 @@ static void handle_exception(struct fsg_common *common) + if (old_state == FSG_STATE_ABORT_BULK_OUT) + common->state = FSG_STATE_STATUS_PHASE; + else { +- for (i = 0; i < common->nluns; ++i) { ++ for (i = 0; i < ARRAY_SIZE(common->luns); ++i) { + curlun = common->luns[i]; + if (!curlun) + continue; +@@ -2453,7 +2463,7 @@ static void handle_exception(struct fsg_common *common) + * a waste of time. Ditto for the INTERFACE_CHANGE and + * CONFIG_CHANGE cases. + */ +- /* for (i = 0; i < common->nluns; ++i) */ ++ /* for (i = 0; i < common->ARRAY_SIZE(common->luns); ++i) */ + /* if (common->luns[i]) */ + /* common->luns[i]->unit_attention_data = */ + /* SS_RESET_OCCURRED; */ +@@ -2552,12 +2562,11 @@ static int fsg_main_thread(void *common_) + + if (!common->ops || !common->ops->thread_exits + || common->ops->thread_exits(common) < 0) { +- struct fsg_lun **curlun_it = common->luns; +- unsigned i = common->nluns; ++ int i; + + down_write(&common->filesem); +- for (; i--; ++curlun_it) { +- struct fsg_lun *curlun = *curlun_it; ++ for (i = 0; i < ARRAY_SIZE(common->luns); --i) { ++ struct fsg_lun *curlun = common->luns[i]; + if (!curlun || !fsg_lun_is_open(curlun)) + continue; + +@@ -2676,6 +2685,7 @@ static struct fsg_common *fsg_common_setup(struct fsg_common *common) + init_completion(&common->thread_notifier); + init_waitqueue_head(&common->fsg_wait); + common->state = FSG_STATE_TERMINATED; ++ memset(common->luns, 0, sizeof(common->luns)); + + return common; + } +@@ -2742,9 +2752,9 @@ error_release: + } + EXPORT_SYMBOL_GPL(fsg_common_set_num_buffers); + +-void fsg_common_remove_lun(struct fsg_lun *lun, bool sysfs) ++void fsg_common_remove_lun(struct fsg_lun *lun) + { +- if (sysfs) ++ if (device_is_registered(&lun->dev)) + device_unregister(&lun->dev); + fsg_lun_close(lun); + kfree(lun); +@@ -2757,7 +2767,7 @@ static void _fsg_common_remove_luns(struct fsg_common *common, int n) + + for (i = 0; i < n; ++i) + if (common->luns[i]) { +- fsg_common_remove_lun(common->luns[i], common->sysfs); ++ fsg_common_remove_lun(common->luns[i]); + common->luns[i] = NULL; + } + } +@@ -2765,40 +2775,8 @@ EXPORT_SYMBOL_GPL(fsg_common_remove_luns); + + void fsg_common_remove_luns(struct fsg_common *common) + { +- _fsg_common_remove_luns(common, common->nluns); +-} +- +-void fsg_common_free_luns(struct fsg_common *common) +-{ +- fsg_common_remove_luns(common); +- kfree(common->luns); +- common->luns = NULL; ++ _fsg_common_remove_luns(common, ARRAY_SIZE(common->luns)); + } +-EXPORT_SYMBOL_GPL(fsg_common_free_luns); +- +-int fsg_common_set_nluns(struct fsg_common *common, int nluns) +-{ +- struct fsg_lun **curlun; +- +- /* Find out how many LUNs there should be */ +- if (nluns < 1 || nluns > FSG_MAX_LUNS) { +- pr_err("invalid number of LUNs: %u\n", nluns); +- return -EINVAL; +- } +- +- curlun = kcalloc(FSG_MAX_LUNS, sizeof(*curlun), GFP_KERNEL); +- if (unlikely(!curlun)) +- return -ENOMEM; +- +- if (common->luns) +- fsg_common_free_luns(common); +- +- common->luns = curlun; +- common->nluns = nluns; +- +- return 0; +-} +-EXPORT_SYMBOL_GPL(fsg_common_set_nluns); + + void fsg_common_set_ops(struct fsg_common *common, + const struct fsg_operations *ops) +@@ -2880,7 +2858,7 @@ int fsg_common_create_lun(struct fsg_common *common, struct fsg_lun_config *cfg, + char *pathbuf, *p; + int rc = -ENOMEM; + +- if (!common->nluns || !common->luns) ++ if (id >= ARRAY_SIZE(common->luns)) + return -ENODEV; + + if (common->luns[id]) +@@ -2949,7 +2927,7 @@ int fsg_common_create_lun(struct fsg_common *common, struct fsg_lun_config *cfg, + return 0; + + error_lun: +- if (common->sysfs) ++ if (device_is_registered(&lun->dev)) + device_unregister(&lun->dev); + fsg_lun_close(lun); + common->luns[id] = NULL; +@@ -2964,14 +2942,16 @@ int fsg_common_create_luns(struct fsg_common *common, struct fsg_config *cfg) + char buf[8]; /* enough for 100000000 different numbers, decimal */ + int i, rc; + +- for (i = 0; i < common->nluns; ++i) { ++ fsg_common_remove_luns(common); ++ ++ for (i = 0; i < cfg->nluns; ++i) { + snprintf(buf, sizeof(buf), "lun%d", i); + rc = fsg_common_create_lun(common, &cfg->luns[i], i, buf, NULL); + if (rc) + goto fail; + } + +- pr_info("Number of LUNs=%d\n", common->nluns); ++ pr_info("Number of LUNs=%d\n", cfg->nluns); + + return 0; + +@@ -2998,51 +2978,26 @@ void fsg_common_set_inquiry_string(struct fsg_common *common, const char *vn, + } + EXPORT_SYMBOL_GPL(fsg_common_set_inquiry_string); + +-int fsg_common_run_thread(struct fsg_common *common) +-{ +- common->state = FSG_STATE_IDLE; +- /* Tell the thread to start working */ +- common->thread_task = +- kthread_create(fsg_main_thread, common, "file-storage"); +- if (IS_ERR(common->thread_task)) { +- common->state = FSG_STATE_TERMINATED; +- return PTR_ERR(common->thread_task); +- } +- +- DBG(common, "I/O thread pid: %d\n", task_pid_nr(common->thread_task)); +- +- wake_up_process(common->thread_task); +- +- return 0; +-} +-EXPORT_SYMBOL_GPL(fsg_common_run_thread); +- + static void fsg_common_release(struct kref *ref) + { + struct fsg_common *common = container_of(ref, struct fsg_common, ref); ++ int i; + + /* If the thread isn't already dead, tell it to exit now */ + if (common->state != FSG_STATE_TERMINATED) { + raise_exception(common, FSG_STATE_EXIT); + wait_for_completion(&common->thread_notifier); ++ common->thread_task = NULL; + } + +- if (likely(common->luns)) { +- struct fsg_lun **lun_it = common->luns; +- unsigned i = common->nluns; +- +- /* In error recovery common->nluns may be zero. */ +- for (; i; --i, ++lun_it) { +- struct fsg_lun *lun = *lun_it; +- if (!lun) +- continue; +- fsg_lun_close(lun); +- if (common->sysfs) +- device_unregister(&lun->dev); +- kfree(lun); +- } +- +- kfree(common->luns); ++ for (i = 0; i < ARRAY_SIZE(common->luns); ++i) { ++ struct fsg_lun *lun = common->luns[i]; ++ if (!lun) ++ continue; ++ fsg_lun_close(lun); ++ if (device_is_registered(&lun->dev)) ++ device_unregister(&lun->dev); ++ kfree(lun); + } + + _fsg_common_free_buffers(common->buffhds, common->fsg_num_buffers); +@@ -3056,6 +3011,7 @@ static void fsg_common_release(struct kref *ref) + static int fsg_bind(struct usb_configuration *c, struct usb_function *f) + { + struct fsg_dev *fsg = fsg_from_func(f); ++ struct fsg_common *common = fsg->common; + struct usb_gadget *gadget = c->cdev->gadget; + int i; + struct usb_ep *ep; +@@ -3063,6 +3019,13 @@ static int fsg_bind(struct usb_configuration *c, struct usb_function *f) + int ret; + struct fsg_opts *opts; + ++ /* Don't allow to bind if we don't have at least one LUN */ ++ ret = _fsg_common_get_max_lun(common); ++ if (ret < 0) { ++ pr_err("There should be at least one LUN.\n"); ++ return -EINVAL; ++ } ++ + opts = fsg_opts_from_func_inst(f->fi); + if (!opts->no_configfs) { + ret = fsg_common_set_cdev(fsg->common, c->cdev, +@@ -3070,9 +3033,21 @@ static int fsg_bind(struct usb_configuration *c, struct usb_function *f) + if (ret) + return ret; + fsg_common_set_inquiry_string(fsg->common, NULL, NULL); +- ret = fsg_common_run_thread(fsg->common); +- if (ret) ++ } ++ ++ if (!common->thread_task) { ++ common->state = FSG_STATE_IDLE; ++ common->thread_task = ++ kthread_create(fsg_main_thread, common, "file-storage"); ++ if (IS_ERR(common->thread_task)) { ++ int ret = PTR_ERR(common->thread_task); ++ common->thread_task = NULL; ++ common->state = FSG_STATE_TERMINATED; + return ret; ++ } ++ DBG(common, "I/O thread pid: %d\n", ++ task_pid_nr(common->thread_task)); ++ wake_up_process(common->thread_task); + } + + fsg->gadget = gadget; +@@ -3355,7 +3330,7 @@ static void fsg_lun_drop(struct config_group *group, struct config_item *item) + unregister_gadget_item(gadget); + } + +- fsg_common_remove_lun(lun_opts->lun, fsg_opts->common->sysfs); ++ fsg_common_remove_lun(lun_opts->lun); + fsg_opts->common->luns[lun_opts->lun_id] = NULL; + lun_opts->lun_id = 0; + mutex_unlock(&fsg_opts->lock); +@@ -3509,14 +3484,11 @@ static struct usb_function_instance *fsg_alloc_inst(void) + rc = PTR_ERR(opts->common); + goto release_opts; + } +- rc = fsg_common_set_nluns(opts->common, FSG_MAX_LUNS); +- if (rc) +- goto release_opts; + + rc = fsg_common_set_num_buffers(opts->common, + CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS); + if (rc) +- goto release_luns; ++ goto release_opts; + + pr_info(FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n"); + +@@ -3524,6 +3496,9 @@ static struct usb_function_instance *fsg_alloc_inst(void) + config.removable = true; + rc = fsg_common_create_lun(opts->common, &config, 0, "lun.0", + (const char **)&opts->func_inst.group.cg_item.ci_name); ++ if (rc) ++ goto release_buffers; ++ + opts->lun0.lun = opts->common->luns[0]; + opts->lun0.lun_id = 0; + config_group_init_type_name(&opts->lun0.group, "lun.0", &fsg_lun_type); +@@ -3534,8 +3509,8 @@ static struct usb_function_instance *fsg_alloc_inst(void) + + return &opts->func_inst; + +-release_luns: +- kfree(opts->common->luns); ++release_buffers: ++ fsg_common_free_buffers(opts->common); + release_opts: + kfree(opts); + return ERR_PTR(rc); +@@ -3561,23 +3536,12 @@ static struct usb_function *fsg_alloc(struct usb_function_instance *fi) + struct fsg_opts *opts = fsg_opts_from_func_inst(fi); + struct fsg_common *common = opts->common; + struct fsg_dev *fsg; +- unsigned nluns, i; + + fsg = kzalloc(sizeof(*fsg), GFP_KERNEL); + if (unlikely(!fsg)) + return ERR_PTR(-ENOMEM); + + mutex_lock(&opts->lock); +- if (!opts->refcnt) { +- for (nluns = i = 0; i < FSG_MAX_LUNS; ++i) +- if (common->luns[i]) +- nluns = i + 1; +- if (!nluns) +- pr_warn("No LUNS defined, continuing anyway\n"); +- else +- common->nluns = nluns; +- pr_info("Number of LUNs=%u\n", common->nluns); +- } + opts->refcnt++; + mutex_unlock(&opts->lock); + +diff --git a/drivers/usb/gadget/function/f_mass_storage.h b/drivers/usb/gadget/function/f_mass_storage.h +index b4866fcef30b..b6a9918eaefb 100644 +--- a/drivers/usb/gadget/function/f_mass_storage.h ++++ b/drivers/usb/gadget/function/f_mass_storage.h +@@ -137,14 +137,10 @@ void fsg_common_free_buffers(struct fsg_common *common); + int fsg_common_set_cdev(struct fsg_common *common, + struct usb_composite_dev *cdev, bool can_stall); + +-void fsg_common_remove_lun(struct fsg_lun *lun, bool sysfs); ++void fsg_common_remove_lun(struct fsg_lun *lun); + + void fsg_common_remove_luns(struct fsg_common *common); + +-void fsg_common_free_luns(struct fsg_common *common); +- +-int fsg_common_set_nluns(struct fsg_common *common, int nluns); +- + void fsg_common_set_ops(struct fsg_common *common, + const struct fsg_operations *ops); + +@@ -157,8 +153,6 @@ int fsg_common_create_luns(struct fsg_common *common, struct fsg_config *cfg); + void fsg_common_set_inquiry_string(struct fsg_common *common, const char *vn, + const char *pn); + +-int fsg_common_run_thread(struct fsg_common *common); +- + void fsg_config_from_params(struct fsg_config *cfg, + const struct fsg_module_parameters *params, + unsigned int fsg_num_buffers); +diff --git a/drivers/usb/gadget/legacy/acm_ms.c b/drivers/usb/gadget/legacy/acm_ms.c +index 1194b09ae746..bc97ec645e68 100644 +--- a/drivers/usb/gadget/legacy/acm_ms.c ++++ b/drivers/usb/gadget/legacy/acm_ms.c +@@ -147,10 +147,6 @@ static int acm_ms_do_config(struct usb_configuration *c) + if (status < 0) + goto put_msg; + +- status = fsg_common_run_thread(opts->common); +- if (status) +- goto remove_acm; +- + status = usb_add_function(c, f_msg); + if (status) + goto remove_acm; +@@ -200,10 +196,6 @@ static int acm_ms_bind(struct usb_composite_dev *cdev) + if (status) + goto fail; + +- status = fsg_common_set_nluns(opts->common, config.nluns); +- if (status) +- goto fail_set_nluns; +- + status = fsg_common_set_cdev(opts->common, cdev, config.can_stall); + if (status) + goto fail_set_cdev; +@@ -239,8 +231,6 @@ static int acm_ms_bind(struct usb_composite_dev *cdev) + fail_string_ids: + fsg_common_remove_luns(opts->common); + fail_set_cdev: +- fsg_common_free_luns(opts->common); +-fail_set_nluns: + fsg_common_free_buffers(opts->common); + fail: + usb_put_function_instance(fi_msg); +diff --git a/drivers/usb/gadget/legacy/mass_storage.c b/drivers/usb/gadget/legacy/mass_storage.c +index e7bfb081f111..3eb1b9fad5a0 100644 +--- a/drivers/usb/gadget/legacy/mass_storage.c ++++ b/drivers/usb/gadget/legacy/mass_storage.c +@@ -146,10 +146,6 @@ static int msg_do_config(struct usb_configuration *c) + if (IS_ERR(f_msg)) + return PTR_ERR(f_msg); + +- ret = fsg_common_run_thread(opts->common); +- if (ret) +- goto put_func; +- + ret = usb_add_function(c, f_msg); + if (ret) + goto put_func; +@@ -191,10 +187,6 @@ static int msg_bind(struct usb_composite_dev *cdev) + if (status) + goto fail; + +- status = fsg_common_set_nluns(opts->common, config.nluns); +- if (status) +- goto fail_set_nluns; +- + fsg_common_set_ops(opts->common, &ops); + + status = fsg_common_set_cdev(opts->common, cdev, config.can_stall); +@@ -227,8 +219,6 @@ static int msg_bind(struct usb_composite_dev *cdev) + fail_string_ids: + fsg_common_remove_luns(opts->common); + fail_set_cdev: +- fsg_common_free_luns(opts->common); +-fail_set_nluns: + fsg_common_free_buffers(opts->common); + fail: + usb_put_function_instance(fi_msg); +diff --git a/drivers/usb/gadget/legacy/multi.c b/drivers/usb/gadget/legacy/multi.c +index b21b51f0c9fa..5b2cfdda24a8 100644 +--- a/drivers/usb/gadget/legacy/multi.c ++++ b/drivers/usb/gadget/legacy/multi.c +@@ -151,7 +151,6 @@ static struct usb_function *f_msg_rndis; + + static int rndis_do_config(struct usb_configuration *c) + { +- struct fsg_opts *fsg_opts; + int ret; + + if (gadget_is_otg(c->cdev->gadget)) { +@@ -183,11 +182,6 @@ static int rndis_do_config(struct usb_configuration *c) + goto err_fsg; + } + +- fsg_opts = fsg_opts_from_func_inst(fi_msg); +- ret = fsg_common_run_thread(fsg_opts->common); +- if (ret) +- goto err_run; +- + ret = usb_add_function(c, f_msg_rndis); + if (ret) + goto err_run; +@@ -239,7 +233,6 @@ static struct usb_function *f_msg_multi; + + static int cdc_do_config(struct usb_configuration *c) + { +- struct fsg_opts *fsg_opts; + int ret; + + if (gadget_is_otg(c->cdev->gadget)) { +@@ -272,11 +265,6 @@ static int cdc_do_config(struct usb_configuration *c) + goto err_fsg; + } + +- fsg_opts = fsg_opts_from_func_inst(fi_msg); +- ret = fsg_common_run_thread(fsg_opts->common); +- if (ret) +- goto err_run; +- + ret = usb_add_function(c, f_msg_multi); + if (ret) + goto err_run; +@@ -407,10 +395,6 @@ static int __ref multi_bind(struct usb_composite_dev *cdev) + if (status) + goto fail2; + +- status = fsg_common_set_nluns(fsg_opts->common, config.nluns); +- if (status) +- goto fail_set_nluns; +- + status = fsg_common_set_cdev(fsg_opts->common, cdev, config.can_stall); + if (status) + goto fail_set_cdev; +@@ -448,8 +432,6 @@ static int __ref multi_bind(struct usb_composite_dev *cdev) + fail_string_ids: + fsg_common_remove_luns(fsg_opts->common); + fail_set_cdev: +- fsg_common_free_luns(fsg_opts->common); +-fail_set_nluns: + fsg_common_free_buffers(fsg_opts->common); + fail2: + usb_put_function_instance(fi_msg); +diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c +index 0bbafe795a72..bbddc44ce8bc 100644 +--- a/drivers/usb/misc/usbtest.c ++++ b/drivers/usb/misc/usbtest.c +@@ -303,11 +303,20 @@ static unsigned mod_pattern; + module_param_named(pattern, mod_pattern, uint, S_IRUGO | S_IWUSR); + MODULE_PARM_DESC(mod_pattern, "i/o pattern (0 == zeroes)"); + +-static inline void simple_fill_buf(struct urb *urb) ++static unsigned get_maxpacket(struct usb_device *udev, int pipe) ++{ ++ struct usb_host_endpoint *ep; ++ ++ ep = usb_pipe_endpoint(udev, pipe); ++ return le16_to_cpup(&ep->desc.wMaxPacketSize); ++} ++ ++static void simple_fill_buf(struct urb *urb) + { + unsigned i; + u8 *buf = urb->transfer_buffer; + unsigned len = urb->transfer_buffer_length; ++ unsigned maxpacket; + + switch (pattern) { + default: +@@ -316,8 +325,9 @@ static inline void simple_fill_buf(struct urb *urb) + memset(buf, 0, len); + break; + case 1: /* mod63 */ ++ maxpacket = get_maxpacket(urb->dev, urb->pipe); + for (i = 0; i < len; i++) +- *buf++ = (u8) (i % 63); ++ *buf++ = (u8) ((i % maxpacket) % 63); + break; + } + } +@@ -349,6 +359,7 @@ static int simple_check_buf(struct usbtest_dev *tdev, struct urb *urb) + u8 expected; + u8 *buf = urb->transfer_buffer; + unsigned len = urb->actual_length; ++ unsigned maxpacket = get_maxpacket(urb->dev, urb->pipe); + + int ret = check_guard_bytes(tdev, urb); + if (ret) +@@ -366,7 +377,7 @@ static int simple_check_buf(struct usbtest_dev *tdev, struct urb *urb) + * with set_interface or set_config. + */ + case 1: /* mod63 */ +- expected = i % 63; ++ expected = (i % maxpacket) % 63; + break; + /* always fail unsupported patterns */ + default: +@@ -478,11 +489,14 @@ static void free_sglist(struct scatterlist *sg, int nents) + } + + static struct scatterlist * +-alloc_sglist(int nents, int max, int vary) ++alloc_sglist(int nents, int max, int vary, struct usbtest_dev *dev, int pipe) + { + struct scatterlist *sg; ++ unsigned int n_size = 0; + unsigned i; + unsigned size = max; ++ unsigned maxpacket = ++ get_maxpacket(interface_to_usbdev(dev->intf), pipe); + + if (max == 0) + return NULL; +@@ -511,7 +525,8 @@ alloc_sglist(int nents, int max, int vary) + break; + case 1: + for (j = 0; j < size; j++) +- *buf++ = (u8) (j % 63); ++ *buf++ = (u8) (((j + n_size) % maxpacket) % 63); ++ n_size += size; + break; + } + +@@ -2175,7 +2190,8 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf) + "TEST 5: write %d sglists %d entries of %d bytes\n", + param->iterations, + param->sglen, param->length); +- sg = alloc_sglist(param->sglen, param->length, 0); ++ sg = alloc_sglist(param->sglen, param->length, ++ 0, dev, dev->out_pipe); + if (!sg) { + retval = -ENOMEM; + break; +@@ -2193,7 +2209,8 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf) + "TEST 6: read %d sglists %d entries of %d bytes\n", + param->iterations, + param->sglen, param->length); +- sg = alloc_sglist(param->sglen, param->length, 0); ++ sg = alloc_sglist(param->sglen, param->length, ++ 0, dev, dev->in_pipe); + if (!sg) { + retval = -ENOMEM; + break; +@@ -2210,7 +2227,8 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf) + "TEST 7: write/%d %d sglists %d entries 0..%d bytes\n", + param->vary, param->iterations, + param->sglen, param->length); +- sg = alloc_sglist(param->sglen, param->length, param->vary); ++ sg = alloc_sglist(param->sglen, param->length, ++ param->vary, dev, dev->out_pipe); + if (!sg) { + retval = -ENOMEM; + break; +@@ -2227,7 +2245,8 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf) + "TEST 8: read/%d %d sglists %d entries 0..%d bytes\n", + param->vary, param->iterations, + param->sglen, param->length); +- sg = alloc_sglist(param->sglen, param->length, param->vary); ++ sg = alloc_sglist(param->sglen, param->length, ++ param->vary, dev, dev->in_pipe); + if (!sg) { + retval = -ENOMEM; + break; +diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c +index a2b43a6e7fa7..f49e859ac5ce 100644 +--- a/drivers/usb/serial/cp210x.c ++++ b/drivers/usb/serial/cp210x.c +@@ -43,8 +43,8 @@ static int cp210x_tiocmset(struct tty_struct *, unsigned int, unsigned int); + static int cp210x_tiocmset_port(struct usb_serial_port *port, + unsigned int, unsigned int); + static void cp210x_break_ctl(struct tty_struct *, int); +-static int cp210x_startup(struct usb_serial *); +-static void cp210x_release(struct usb_serial *); ++static int cp210x_port_probe(struct usb_serial_port *); ++static int cp210x_port_remove(struct usb_serial_port *); + static void cp210x_dtr_rts(struct usb_serial_port *p, int on); + + static const struct usb_device_id id_table[] = { +@@ -206,7 +206,7 @@ static const struct usb_device_id id_table[] = { + + MODULE_DEVICE_TABLE(usb, id_table); + +-struct cp210x_serial_private { ++struct cp210x_port_private { + __u8 bInterfaceNumber; + }; + +@@ -225,8 +225,8 @@ static struct usb_serial_driver cp210x_device = { + .set_termios = cp210x_set_termios, + .tiocmget = cp210x_tiocmget, + .tiocmset = cp210x_tiocmset, +- .attach = cp210x_startup, +- .release = cp210x_release, ++ .port_probe = cp210x_port_probe, ++ .port_remove = cp210x_port_remove, + .dtr_rts = cp210x_dtr_rts + }; + +@@ -320,7 +320,7 @@ static int cp210x_get_config(struct usb_serial_port *port, u8 request, + unsigned int *data, int size) + { + struct usb_serial *serial = port->serial; +- struct cp210x_serial_private *spriv = usb_get_serial_data(serial); ++ struct cp210x_port_private *port_priv = usb_get_serial_port_data(port); + __le32 *buf; + int result, i, length; + +@@ -334,7 +334,7 @@ static int cp210x_get_config(struct usb_serial_port *port, u8 request, + /* Issue the request, attempting to read 'size' bytes */ + result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), + request, REQTYPE_INTERFACE_TO_HOST, 0x0000, +- spriv->bInterfaceNumber, buf, size, ++ port_priv->bInterfaceNumber, buf, size, + USB_CTRL_GET_TIMEOUT); + + /* Convert data into an array of integers */ +@@ -365,7 +365,7 @@ static int cp210x_set_config(struct usb_serial_port *port, u8 request, + unsigned int *data, int size) + { + struct usb_serial *serial = port->serial; +- struct cp210x_serial_private *spriv = usb_get_serial_data(serial); ++ struct cp210x_port_private *port_priv = usb_get_serial_port_data(port); + __le32 *buf; + int result, i, length; + +@@ -384,13 +384,13 @@ static int cp210x_set_config(struct usb_serial_port *port, u8 request, + result = usb_control_msg(serial->dev, + usb_sndctrlpipe(serial->dev, 0), + request, REQTYPE_HOST_TO_INTERFACE, 0x0000, +- spriv->bInterfaceNumber, buf, size, ++ port_priv->bInterfaceNumber, buf, size, + USB_CTRL_SET_TIMEOUT); + } else { + result = usb_control_msg(serial->dev, + usb_sndctrlpipe(serial->dev, 0), + request, REQTYPE_HOST_TO_INTERFACE, data[0], +- spriv->bInterfaceNumber, NULL, 0, ++ port_priv->bInterfaceNumber, NULL, 0, + USB_CTRL_SET_TIMEOUT); + } + +@@ -784,7 +784,7 @@ static void cp210x_set_termios(struct tty_struct *tty, + } else { + modem_ctl[0] &= ~0x7B; + modem_ctl[0] |= 0x01; +- modem_ctl[1] |= 0x40; ++ modem_ctl[1] = 0x40; + dev_dbg(dev, "%s - flow control = NONE\n", __func__); + } + +@@ -872,29 +872,32 @@ static void cp210x_break_ctl(struct tty_struct *tty, int break_state) + cp210x_set_config(port, CP210X_SET_BREAK, &state, 2); + } + +-static int cp210x_startup(struct usb_serial *serial) ++static int cp210x_port_probe(struct usb_serial_port *port) + { ++ struct usb_serial *serial = port->serial; + struct usb_host_interface *cur_altsetting; +- struct cp210x_serial_private *spriv; ++ struct cp210x_port_private *port_priv; + +- spriv = kzalloc(sizeof(*spriv), GFP_KERNEL); +- if (!spriv) ++ port_priv = kzalloc(sizeof(*port_priv), GFP_KERNEL); ++ if (!port_priv) + return -ENOMEM; + + cur_altsetting = serial->interface->cur_altsetting; +- spriv->bInterfaceNumber = cur_altsetting->desc.bInterfaceNumber; ++ port_priv->bInterfaceNumber = cur_altsetting->desc.bInterfaceNumber; + +- usb_set_serial_data(serial, spriv); ++ usb_set_serial_port_data(port, port_priv); + + return 0; + } + +-static void cp210x_release(struct usb_serial *serial) ++static int cp210x_port_remove(struct usb_serial_port *port) + { +- struct cp210x_serial_private *spriv; ++ struct cp210x_port_private *port_priv; ++ ++ port_priv = usb_get_serial_port_data(port); ++ kfree(port_priv); + +- spriv = usb_get_serial_data(serial); +- kfree(spriv); ++ return 0; + } + + module_usb_serial_driver(serial_drivers, id_table); +diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c +index c0866971db2b..1947ea0e0988 100644 +--- a/drivers/usb/serial/io_edgeport.c ++++ b/drivers/usb/serial/io_edgeport.c +@@ -2856,14 +2856,16 @@ static int edge_startup(struct usb_serial *serial) + /* not set up yet, so do it now */ + edge_serial->interrupt_read_urb = + usb_alloc_urb(0, GFP_KERNEL); +- if (!edge_serial->interrupt_read_urb) +- return -ENOMEM; ++ if (!edge_serial->interrupt_read_urb) { ++ response = -ENOMEM; ++ break; ++ } + + edge_serial->interrupt_in_buffer = + kmalloc(buffer_size, GFP_KERNEL); + if (!edge_serial->interrupt_in_buffer) { +- usb_free_urb(edge_serial->interrupt_read_urb); +- return -ENOMEM; ++ response = -ENOMEM; ++ break; + } + edge_serial->interrupt_in_endpoint = + endpoint->bEndpointAddress; +@@ -2891,14 +2893,16 @@ static int edge_startup(struct usb_serial *serial) + /* not set up yet, so do it now */ + edge_serial->read_urb = + usb_alloc_urb(0, GFP_KERNEL); +- if (!edge_serial->read_urb) +- return -ENOMEM; ++ if (!edge_serial->read_urb) { ++ response = -ENOMEM; ++ break; ++ } + + edge_serial->bulk_in_buffer = + kmalloc(buffer_size, GFP_KERNEL); + if (!edge_serial->bulk_in_buffer) { +- usb_free_urb(edge_serial->read_urb); +- return -ENOMEM; ++ response = -ENOMEM; ++ break; + } + edge_serial->bulk_in_endpoint = + endpoint->bEndpointAddress; +@@ -2924,9 +2928,22 @@ static int edge_startup(struct usb_serial *serial) + } + } + +- if (!interrupt_in_found || !bulk_in_found || !bulk_out_found) { +- dev_err(ddev, "Error - the proper endpoints were not found!\n"); +- return -ENODEV; ++ if (response || !interrupt_in_found || !bulk_in_found || ++ !bulk_out_found) { ++ if (!response) { ++ dev_err(ddev, "expected endpoints not found\n"); ++ response = -ENODEV; ++ } ++ ++ usb_free_urb(edge_serial->interrupt_read_urb); ++ kfree(edge_serial->interrupt_in_buffer); ++ ++ usb_free_urb(edge_serial->read_urb); ++ kfree(edge_serial->bulk_in_buffer); ++ ++ kfree(edge_serial); ++ ++ return response; + } + + /* start interrupt read for this edgeport this interrupt will +@@ -2949,16 +2966,9 @@ static void edge_disconnect(struct usb_serial *serial) + { + struct edgeport_serial *edge_serial = usb_get_serial_data(serial); + +- /* stop reads and writes on all ports */ +- /* free up our endpoint stuff */ + if (edge_serial->is_epic) { + usb_kill_urb(edge_serial->interrupt_read_urb); +- usb_free_urb(edge_serial->interrupt_read_urb); +- kfree(edge_serial->interrupt_in_buffer); +- + usb_kill_urb(edge_serial->read_urb); +- usb_free_urb(edge_serial->read_urb); +- kfree(edge_serial->bulk_in_buffer); + } + } + +@@ -2971,6 +2981,16 @@ static void edge_release(struct usb_serial *serial) + { + struct edgeport_serial *edge_serial = usb_get_serial_data(serial); + ++ if (edge_serial->is_epic) { ++ usb_kill_urb(edge_serial->interrupt_read_urb); ++ usb_free_urb(edge_serial->interrupt_read_urb); ++ kfree(edge_serial->interrupt_in_buffer); ++ ++ usb_kill_urb(edge_serial->read_urb); ++ usb_free_urb(edge_serial->read_urb); ++ kfree(edge_serial->bulk_in_buffer); ++ } ++ + kfree(edge_serial); + } + +diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c +index e07b15ed5814..7faa901ee47f 100644 +--- a/drivers/usb/serial/keyspan.c ++++ b/drivers/usb/serial/keyspan.c +@@ -2376,6 +2376,10 @@ static void keyspan_release(struct usb_serial *serial) + + s_priv = usb_get_serial_data(serial); + ++ /* Make sure to unlink the URBs submitted in attach. */ ++ usb_kill_urb(s_priv->instat_urb); ++ usb_kill_urb(s_priv->indat_urb); ++ + usb_free_urb(s_priv->instat_urb); + usb_free_urb(s_priv->indat_urb); + usb_free_urb(s_priv->glocont_urb); +diff --git a/drivers/usb/serial/mxuport.c b/drivers/usb/serial/mxuport.c +index 460a40669967..d029b2fc0f75 100644 +--- a/drivers/usb/serial/mxuport.c ++++ b/drivers/usb/serial/mxuport.c +@@ -1263,6 +1263,15 @@ static int mxuport_attach(struct usb_serial *serial) + return 0; + } + ++static void mxuport_release(struct usb_serial *serial) ++{ ++ struct usb_serial_port *port0 = serial->port[0]; ++ struct usb_serial_port *port1 = serial->port[1]; ++ ++ usb_serial_generic_close(port1); ++ usb_serial_generic_close(port0); ++} ++ + static int mxuport_open(struct tty_struct *tty, struct usb_serial_port *port) + { + struct mxuport_port *mxport = usb_get_serial_port_data(port); +@@ -1365,6 +1374,7 @@ static struct usb_serial_driver mxuport_device = { + .probe = mxuport_probe, + .port_probe = mxuport_port_probe, + .attach = mxuport_attach, ++ .release = mxuport_release, + .calc_num_ports = mxuport_calc_num_ports, + .open = mxuport_open, + .close = mxuport_close, +diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c +index 94e520de6404..f00919d579e0 100644 +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -378,18 +378,22 @@ static void option_instat_callback(struct urb *urb); + #define HAIER_PRODUCT_CE81B 0x10f8 + #define HAIER_PRODUCT_CE100 0x2009 + +-/* Cinterion (formerly Siemens) products */ +-#define SIEMENS_VENDOR_ID 0x0681 +-#define CINTERION_VENDOR_ID 0x1e2d ++/* Gemalto's Cinterion products (formerly Siemens) */ ++#define SIEMENS_VENDOR_ID 0x0681 ++#define CINTERION_VENDOR_ID 0x1e2d ++#define CINTERION_PRODUCT_HC25_MDMNET 0x0040 + #define CINTERION_PRODUCT_HC25_MDM 0x0047 +-#define CINTERION_PRODUCT_HC25_MDMNET 0x0040 ++#define CINTERION_PRODUCT_HC28_MDMNET 0x004A /* same for HC28J */ + #define CINTERION_PRODUCT_HC28_MDM 0x004C +-#define CINTERION_PRODUCT_HC28_MDMNET 0x004A /* same for HC28J */ + #define CINTERION_PRODUCT_EU3_E 0x0051 + #define CINTERION_PRODUCT_EU3_P 0x0052 + #define CINTERION_PRODUCT_PH8 0x0053 + #define CINTERION_PRODUCT_AHXX 0x0055 + #define CINTERION_PRODUCT_PLXX 0x0060 ++#define CINTERION_PRODUCT_PH8_2RMNET 0x0082 ++#define CINTERION_PRODUCT_PH8_AUDIO 0x0083 ++#define CINTERION_PRODUCT_AHXX_2RMNET 0x0084 ++#define CINTERION_PRODUCT_AHXX_AUDIO 0x0085 + + /* Olivetti products */ + #define OLIVETTI_VENDOR_ID 0x0b3c +@@ -641,6 +645,10 @@ static const struct option_blacklist_info telit_le922_blacklist_usbcfg3 = { + .reserved = BIT(1) | BIT(2) | BIT(3), + }; + ++static const struct option_blacklist_info cinterion_rmnet2_blacklist = { ++ .reserved = BIT(4) | BIT(5), ++}; ++ + static const struct usb_device_id option_ids[] = { + { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) }, + { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) }, +@@ -1614,7 +1622,79 @@ static const struct usb_device_id option_ids[] = { + .driver_info = (kernel_ulong_t)&net_intf3_blacklist }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0178, 0xff, 0xff, 0xff), + .driver_info = (kernel_ulong_t)&net_intf3_blacklist }, +- { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffe9, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff42, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff43, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff44, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff45, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff46, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff47, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff48, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff49, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4a, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4b, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4c, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4d, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4e, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4f, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff50, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff51, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff52, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff53, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff54, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff55, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff56, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff57, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff58, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff59, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5a, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5b, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5c, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5d, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5e, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5f, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff60, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff61, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff62, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff63, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff64, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff65, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff66, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff67, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff68, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff69, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6a, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6b, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6c, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6d, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6e, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6f, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff70, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff71, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff72, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff73, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff74, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff75, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff76, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff77, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff78, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff79, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7a, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7b, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7c, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7d, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7e, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7f, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff80, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff81, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff82, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff83, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff84, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff85, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff86, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff87, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff88, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff89, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8a, 0xff, 0xff, 0xff) }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8b, 0xff, 0xff, 0xff) }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8c, 0xff, 0xff, 0xff) }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8d, 0xff, 0xff, 0xff) }, +@@ -1625,6 +1705,61 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff92, 0xff, 0xff, 0xff) }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff93, 0xff, 0xff, 0xff) }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff94, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff9f, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa0, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa1, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa2, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa3, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa4, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa5, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa6, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa7, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa8, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa9, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffaa, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffab, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffac, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffae, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffaf, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb0, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb1, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb2, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb3, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb4, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb5, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb6, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb7, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb8, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb9, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffba, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffbb, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffbc, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffbd, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffbe, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffbf, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc0, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc1, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc2, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc3, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc4, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc5, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc6, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc7, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc8, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc9, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffca, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffcb, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffcc, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffcd, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffce, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffcf, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd0, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd1, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd2, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd3, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd4, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd5, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffe9, 0xff, 0xff, 0xff) }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffec, 0xff, 0xff, 0xff) }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffee, 0xff, 0xff, 0xff) }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xfff6, 0xff, 0xff, 0xff) }, +@@ -1724,7 +1859,13 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX, 0xff) }, + { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_PLXX), + .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, +- { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) }, ++ { USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_PH8_2RMNET, 0xff), ++ .driver_info = (kernel_ulong_t)&cinterion_rmnet2_blacklist }, ++ { USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_PH8_AUDIO, 0xff), ++ .driver_info = (kernel_ulong_t)&net_intf4_blacklist }, ++ { USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX_2RMNET, 0xff) }, ++ { USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX_AUDIO, 0xff) }, ++ { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) }, + { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDMNET) }, + { USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC25_MDM) }, + { USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC25_MDMNET) }, +diff --git a/drivers/usb/serial/quatech2.c b/drivers/usb/serial/quatech2.c +index 504f5bff79c0..b18974cbd995 100644 +--- a/drivers/usb/serial/quatech2.c ++++ b/drivers/usb/serial/quatech2.c +@@ -141,6 +141,7 @@ static void qt2_release(struct usb_serial *serial) + + serial_priv = usb_get_serial_data(serial); + ++ usb_kill_urb(serial_priv->read_urb); + usb_free_urb(serial_priv->read_urb); + kfree(serial_priv->read_buffer); + kfree(serial_priv); +diff --git a/drivers/xen/events/events_base.c b/drivers/xen/events/events_base.c +index 511aab3b9206..4bf7a34f6a4c 100644 +--- a/drivers/xen/events/events_base.c ++++ b/drivers/xen/events/events_base.c +@@ -486,7 +486,8 @@ static void eoi_pirq(struct irq_data *data) + if (!VALID_EVTCHN(evtchn)) + return; + +- if (unlikely(irqd_is_setaffinity_pending(data))) { ++ if (unlikely(irqd_is_setaffinity_pending(data)) && ++ likely(!irqd_irq_disabled(data))) { + int masked = test_and_set_mask(evtchn); + + clear_evtchn(evtchn); +@@ -1373,7 +1374,8 @@ static void ack_dynirq(struct irq_data *data) + if (!VALID_EVTCHN(evtchn)) + return; + +- if (unlikely(irqd_is_setaffinity_pending(data))) { ++ if (unlikely(irqd_is_setaffinity_pending(data)) && ++ likely(!irqd_irq_disabled(data))) { + int masked = test_and_set_mask(evtchn); + + clear_evtchn(evtchn); +diff --git a/fs/affs/super.c b/fs/affs/super.c +index 3f89c9e05b40..cc7571201b4f 100644 +--- a/fs/affs/super.c ++++ b/fs/affs/super.c +@@ -526,7 +526,7 @@ affs_remount(struct super_block *sb, int *flags, char *data) + char *prefix = NULL; + + new_opts = kstrdup(data, GFP_KERNEL); +- if (!new_opts) ++ if (data && !new_opts) + return -ENOMEM; + + pr_debug("%s(flags=0x%x,opts=\"%s\")\n", __func__, *flags, data); +@@ -544,7 +544,8 @@ affs_remount(struct super_block *sb, int *flags, char *data) + } + + flush_delayed_work(&sbi->sb_work); +- replace_mount_options(sb, new_opts); ++ if (new_opts) ++ replace_mount_options(sb, new_opts); + + sbi->s_flags = mount_flags; + sbi->s_mode = mode; +diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h +index 699944a07491..53cbbedf21d1 100644 +--- a/fs/btrfs/ctree.h ++++ b/fs/btrfs/ctree.h +@@ -3956,6 +3956,7 @@ void btrfs_test_inode_set_ops(struct inode *inode); + + /* ioctl.c */ + long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg); ++long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg); + void btrfs_update_iflags(struct inode *inode); + void btrfs_inherit_iflags(struct inode *inode, struct inode *dir); + int btrfs_is_empty_uuid(u8 *uuid); +diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c +index 2b0d84d32db4..2b230e9b3bad 100644 +--- a/fs/btrfs/file.c ++++ b/fs/btrfs/file.c +@@ -2819,7 +2819,7 @@ const struct file_operations btrfs_file_operations = { + .fallocate = btrfs_fallocate, + .unlocked_ioctl = btrfs_ioctl, + #ifdef CONFIG_COMPAT +- .compat_ioctl = btrfs_ioctl, ++ .compat_ioctl = btrfs_compat_ioctl, + #endif + }; + +diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c +index f751ab47e9a5..c4771af7fd6f 100644 +--- a/fs/btrfs/inode.c ++++ b/fs/btrfs/inode.c +@@ -9894,7 +9894,7 @@ static const struct file_operations btrfs_dir_file_operations = { + .iterate = btrfs_real_readdir, + .unlocked_ioctl = btrfs_ioctl, + #ifdef CONFIG_COMPAT +- .compat_ioctl = btrfs_ioctl, ++ .compat_ioctl = btrfs_compat_ioctl, + #endif + .release = btrfs_release_file, + .fsync = btrfs_sync_file, +diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c +index 5189d54417ab..43502247e176 100644 +--- a/fs/btrfs/ioctl.c ++++ b/fs/btrfs/ioctl.c +@@ -5492,3 +5492,24 @@ long btrfs_ioctl(struct file *file, unsigned int + + return -ENOTTY; + } ++ ++#ifdef CONFIG_COMPAT ++long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) ++{ ++ switch (cmd) { ++ case FS_IOC32_GETFLAGS: ++ cmd = FS_IOC_GETFLAGS; ++ break; ++ case FS_IOC32_SETFLAGS: ++ cmd = FS_IOC_SETFLAGS; ++ break; ++ case FS_IOC32_GETVERSION: ++ cmd = FS_IOC_GETVERSION; ++ break; ++ default: ++ return -ENOIOCTLCMD; ++ } ++ ++ return btrfs_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); ++} ++#endif +diff --git a/fs/cifs/cifs_spnego.c b/fs/cifs/cifs_spnego.c +index f4cf200b3c76..79450fa66d16 100644 +--- a/fs/cifs/cifs_spnego.c ++++ b/fs/cifs/cifs_spnego.c +@@ -24,10 +24,13 @@ + #include <linux/string.h> + #include <keys/user-type.h> + #include <linux/key-type.h> ++#include <linux/keyctl.h> + #include <linux/inet.h> + #include "cifsglob.h" + #include "cifs_spnego.h" + #include "cifs_debug.h" ++#include "cifsproto.h" ++static const struct cred *spnego_cred; + + /* create a new cifs key */ + static int +@@ -102,6 +105,7 @@ cifs_get_spnego_key(struct cifs_ses *sesInfo) + size_t desc_len; + struct key *spnego_key; + const char *hostname = server->hostname; ++ const struct cred *saved_cred; + + /* length of fields (with semicolons): ver=0xyz ip4=ipaddress + host=hostname sec=mechanism uid=0xFF user=username */ +@@ -163,7 +167,9 @@ cifs_get_spnego_key(struct cifs_ses *sesInfo) + sprintf(dp, ";pid=0x%x", current->pid); + + cifs_dbg(FYI, "key description = %s\n", description); ++ saved_cred = override_creds(spnego_cred); + spnego_key = request_key(&cifs_spnego_key_type, description, ""); ++ revert_creds(saved_cred); + + #ifdef CONFIG_CIFS_DEBUG2 + if (cifsFYI && !IS_ERR(spnego_key)) { +@@ -177,3 +183,64 @@ out: + kfree(description); + return spnego_key; + } ++ ++int ++init_cifs_spnego(void) ++{ ++ struct cred *cred; ++ struct key *keyring; ++ int ret; ++ ++ cifs_dbg(FYI, "Registering the %s key type\n", ++ cifs_spnego_key_type.name); ++ ++ /* ++ * Create an override credential set with special thread keyring for ++ * spnego upcalls. ++ */ ++ ++ cred = prepare_kernel_cred(NULL); ++ if (!cred) ++ return -ENOMEM; ++ ++ keyring = keyring_alloc(".cifs_spnego", ++ GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred, ++ (KEY_POS_ALL & ~KEY_POS_SETATTR) | ++ KEY_USR_VIEW | KEY_USR_READ, ++ KEY_ALLOC_NOT_IN_QUOTA, NULL); ++ if (IS_ERR(keyring)) { ++ ret = PTR_ERR(keyring); ++ goto failed_put_cred; ++ } ++ ++ ret = register_key_type(&cifs_spnego_key_type); ++ if (ret < 0) ++ goto failed_put_key; ++ ++ /* ++ * instruct request_key() to use this special keyring as a cache for ++ * the results it looks up ++ */ ++ set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags); ++ cred->thread_keyring = keyring; ++ cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING; ++ spnego_cred = cred; ++ ++ cifs_dbg(FYI, "cifs spnego keyring: %d\n", key_serial(keyring)); ++ return 0; ++ ++failed_put_key: ++ key_put(keyring); ++failed_put_cred: ++ put_cred(cred); ++ return ret; ++} ++ ++void ++exit_cifs_spnego(void) ++{ ++ key_revoke(spnego_cred->thread_keyring); ++ unregister_key_type(&cifs_spnego_key_type); ++ put_cred(spnego_cred); ++ cifs_dbg(FYI, "Unregistered %s key type\n", cifs_spnego_key_type.name); ++} +diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c +index 6a1119e87fbb..fe24e22fc154 100644 +--- a/fs/cifs/cifsfs.c ++++ b/fs/cifs/cifsfs.c +@@ -1238,7 +1238,7 @@ init_cifs(void) + goto out_destroy_mids; + + #ifdef CONFIG_CIFS_UPCALL +- rc = register_key_type(&cifs_spnego_key_type); ++ rc = init_cifs_spnego(); + if (rc) + goto out_destroy_request_bufs; + #endif /* CONFIG_CIFS_UPCALL */ +@@ -1261,7 +1261,7 @@ out_init_cifs_idmap: + out_register_key_type: + #endif + #ifdef CONFIG_CIFS_UPCALL +- unregister_key_type(&cifs_spnego_key_type); ++ exit_cifs_spnego(); + out_destroy_request_bufs: + #endif + cifs_destroy_request_bufs(); +diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h +index c63fd1dde25b..f730c065df34 100644 +--- a/fs/cifs/cifsproto.h ++++ b/fs/cifs/cifsproto.h +@@ -60,6 +60,8 @@ do { \ + } while (0) + extern int init_cifs_idmap(void); + extern void exit_cifs_idmap(void); ++extern int init_cifs_spnego(void); ++extern void exit_cifs_spnego(void); + extern char *build_path_from_dentry(struct dentry *); + extern char *cifs_build_path_to_root(struct smb_vol *vol, + struct cifs_sb_info *cifs_sb, +diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c +index bce6fdcd5d48..8ffda5084dbf 100644 +--- a/fs/cifs/sess.c ++++ b/fs/cifs/sess.c +@@ -400,19 +400,27 @@ int build_ntlmssp_auth_blob(unsigned char *pbuffer, + sec_blob->LmChallengeResponse.MaximumLength = 0; + + sec_blob->NtChallengeResponse.BufferOffset = cpu_to_le32(tmp - pbuffer); +- rc = setup_ntlmv2_rsp(ses, nls_cp); +- if (rc) { +- cifs_dbg(VFS, "Error %d during NTLMSSP authentication\n", rc); +- goto setup_ntlmv2_ret; ++ if (ses->user_name != NULL) { ++ rc = setup_ntlmv2_rsp(ses, nls_cp); ++ if (rc) { ++ cifs_dbg(VFS, "Error %d during NTLMSSP authentication\n", rc); ++ goto setup_ntlmv2_ret; ++ } ++ memcpy(tmp, ses->auth_key.response + CIFS_SESS_KEY_SIZE, ++ ses->auth_key.len - CIFS_SESS_KEY_SIZE); ++ tmp += ses->auth_key.len - CIFS_SESS_KEY_SIZE; ++ ++ sec_blob->NtChallengeResponse.Length = ++ cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); ++ sec_blob->NtChallengeResponse.MaximumLength = ++ cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); ++ } else { ++ /* ++ * don't send an NT Response for anonymous access ++ */ ++ sec_blob->NtChallengeResponse.Length = 0; ++ sec_blob->NtChallengeResponse.MaximumLength = 0; + } +- memcpy(tmp, ses->auth_key.response + CIFS_SESS_KEY_SIZE, +- ses->auth_key.len - CIFS_SESS_KEY_SIZE); +- tmp += ses->auth_key.len - CIFS_SESS_KEY_SIZE; +- +- sec_blob->NtChallengeResponse.Length = +- cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); +- sec_blob->NtChallengeResponse.MaximumLength = +- cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); + + if (ses->domainName == NULL) { + sec_blob->DomainName.BufferOffset = cpu_to_le32(tmp - pbuffer); +@@ -670,20 +678,24 @@ sess_auth_lanman(struct sess_data *sess_data) + + pSMB->req.hdr.Flags2 &= ~SMBFLG2_UNICODE; + +- /* no capabilities flags in old lanman negotiation */ +- pSMB->old_req.PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE); +- +- /* Calculate hash with password and copy into bcc_ptr. +- * Encryption Key (stored as in cryptkey) gets used if the +- * security mode bit in Negottiate Protocol response states +- * to use challenge/response method (i.e. Password bit is 1). +- */ +- rc = calc_lanman_hash(ses->password, ses->server->cryptkey, +- ses->server->sec_mode & SECMODE_PW_ENCRYPT ? +- true : false, lnm_session_key); +- +- memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_AUTH_RESP_SIZE); +- bcc_ptr += CIFS_AUTH_RESP_SIZE; ++ if (ses->user_name != NULL) { ++ /* no capabilities flags in old lanman negotiation */ ++ pSMB->old_req.PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE); ++ ++ /* Calculate hash with password and copy into bcc_ptr. ++ * Encryption Key (stored as in cryptkey) gets used if the ++ * security mode bit in Negottiate Protocol response states ++ * to use challenge/response method (i.e. Password bit is 1). ++ */ ++ rc = calc_lanman_hash(ses->password, ses->server->cryptkey, ++ ses->server->sec_mode & SECMODE_PW_ENCRYPT ? ++ true : false, lnm_session_key); ++ ++ memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_AUTH_RESP_SIZE); ++ bcc_ptr += CIFS_AUTH_RESP_SIZE; ++ } else { ++ pSMB->old_req.PasswordLength = 0; ++ } + + /* + * can not sign if LANMAN negotiated so no need +@@ -769,26 +781,31 @@ sess_auth_ntlm(struct sess_data *sess_data) + capabilities = cifs_ssetup_hdr(ses, pSMB); + + pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities); +- pSMB->req_no_secext.CaseInsensitivePasswordLength = +- cpu_to_le16(CIFS_AUTH_RESP_SIZE); +- pSMB->req_no_secext.CaseSensitivePasswordLength = +- cpu_to_le16(CIFS_AUTH_RESP_SIZE); +- +- /* calculate ntlm response and session key */ +- rc = setup_ntlm_response(ses, sess_data->nls_cp); +- if (rc) { +- cifs_dbg(VFS, "Error %d during NTLM authentication\n", +- rc); +- goto out; +- } ++ if (ses->user_name != NULL) { ++ pSMB->req_no_secext.CaseInsensitivePasswordLength = ++ cpu_to_le16(CIFS_AUTH_RESP_SIZE); ++ pSMB->req_no_secext.CaseSensitivePasswordLength = ++ cpu_to_le16(CIFS_AUTH_RESP_SIZE); ++ ++ /* calculate ntlm response and session key */ ++ rc = setup_ntlm_response(ses, sess_data->nls_cp); ++ if (rc) { ++ cifs_dbg(VFS, "Error %d during NTLM authentication\n", ++ rc); ++ goto out; ++ } + +- /* copy ntlm response */ +- memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, +- CIFS_AUTH_RESP_SIZE); +- bcc_ptr += CIFS_AUTH_RESP_SIZE; +- memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, +- CIFS_AUTH_RESP_SIZE); +- bcc_ptr += CIFS_AUTH_RESP_SIZE; ++ /* copy ntlm response */ ++ memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, ++ CIFS_AUTH_RESP_SIZE); ++ bcc_ptr += CIFS_AUTH_RESP_SIZE; ++ memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, ++ CIFS_AUTH_RESP_SIZE); ++ bcc_ptr += CIFS_AUTH_RESP_SIZE; ++ } else { ++ pSMB->req_no_secext.CaseInsensitivePasswordLength = 0; ++ pSMB->req_no_secext.CaseSensitivePasswordLength = 0; ++ } + + if (ses->capabilities & CAP_UNICODE) { + /* unicode strings must be word aligned */ +@@ -878,22 +895,26 @@ sess_auth_ntlmv2(struct sess_data *sess_data) + /* LM2 password would be here if we supported it */ + pSMB->req_no_secext.CaseInsensitivePasswordLength = 0; + +- /* calculate nlmv2 response and session key */ +- rc = setup_ntlmv2_rsp(ses, sess_data->nls_cp); +- if (rc) { +- cifs_dbg(VFS, "Error %d during NTLMv2 authentication\n", rc); +- goto out; +- } ++ if (ses->user_name != NULL) { ++ /* calculate nlmv2 response and session key */ ++ rc = setup_ntlmv2_rsp(ses, sess_data->nls_cp); ++ if (rc) { ++ cifs_dbg(VFS, "Error %d during NTLMv2 authentication\n", rc); ++ goto out; ++ } + +- memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, +- ses->auth_key.len - CIFS_SESS_KEY_SIZE); +- bcc_ptr += ses->auth_key.len - CIFS_SESS_KEY_SIZE; ++ memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, ++ ses->auth_key.len - CIFS_SESS_KEY_SIZE); ++ bcc_ptr += ses->auth_key.len - CIFS_SESS_KEY_SIZE; + +- /* set case sensitive password length after tilen may get +- * assigned, tilen is 0 otherwise. +- */ +- pSMB->req_no_secext.CaseSensitivePasswordLength = +- cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); ++ /* set case sensitive password length after tilen may get ++ * assigned, tilen is 0 otherwise. ++ */ ++ pSMB->req_no_secext.CaseSensitivePasswordLength = ++ cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); ++ } else { ++ pSMB->req_no_secext.CaseSensitivePasswordLength = 0; ++ } + + if (ses->capabilities & CAP_UNICODE) { + if (sess_data->iov[0].iov_len % 2) { +diff --git a/fs/cifs/smb2glob.h b/fs/cifs/smb2glob.h +index bc0bb9c34f72..0ffa18094335 100644 +--- a/fs/cifs/smb2glob.h ++++ b/fs/cifs/smb2glob.h +@@ -44,6 +44,7 @@ + #define SMB2_OP_DELETE 7 + #define SMB2_OP_HARDLINK 8 + #define SMB2_OP_SET_EOF 9 ++#define SMB2_OP_RMDIR 10 + + /* Used when constructing chained read requests. */ + #define CHAINED_REQUEST 1 +diff --git a/fs/cifs/smb2inode.c b/fs/cifs/smb2inode.c +index 899bbc86f73e..4f0231e685a9 100644 +--- a/fs/cifs/smb2inode.c ++++ b/fs/cifs/smb2inode.c +@@ -80,6 +80,10 @@ smb2_open_op_close(const unsigned int xid, struct cifs_tcon *tcon, + * SMB2_open() call. + */ + break; ++ case SMB2_OP_RMDIR: ++ tmprc = SMB2_rmdir(xid, tcon, fid.persistent_fid, ++ fid.volatile_fid); ++ break; + case SMB2_OP_RENAME: + tmprc = SMB2_rename(xid, tcon, fid.persistent_fid, + fid.volatile_fid, (__le16 *)data); +@@ -191,8 +195,8 @@ smb2_rmdir(const unsigned int xid, struct cifs_tcon *tcon, const char *name, + struct cifs_sb_info *cifs_sb) + { + return smb2_open_op_close(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN, +- CREATE_NOT_FILE | CREATE_DELETE_ON_CLOSE, +- NULL, SMB2_OP_DELETE); ++ CREATE_NOT_FILE, ++ NULL, SMB2_OP_RMDIR); + } + + int +diff --git a/fs/cifs/smb2pdu.c b/fs/cifs/smb2pdu.c +index 657a9c5c4fff..14e845e8996f 100644 +--- a/fs/cifs/smb2pdu.c ++++ b/fs/cifs/smb2pdu.c +@@ -2384,6 +2384,22 @@ SMB2_rename(const unsigned int xid, struct cifs_tcon *tcon, + } + + int ++SMB2_rmdir(const unsigned int xid, struct cifs_tcon *tcon, ++ u64 persistent_fid, u64 volatile_fid) ++{ ++ __u8 delete_pending = 1; ++ void *data; ++ unsigned int size; ++ ++ data = &delete_pending; ++ size = 1; /* sizeof __u8 */ ++ ++ return send_set_info(xid, tcon, persistent_fid, volatile_fid, ++ current->tgid, FILE_DISPOSITION_INFORMATION, 1, &data, ++ &size); ++} ++ ++int + SMB2_set_hardlink(const unsigned int xid, struct cifs_tcon *tcon, + u64 persistent_fid, u64 volatile_fid, __le16 *target_file) + { +diff --git a/fs/cifs/smb2proto.h b/fs/cifs/smb2proto.h +index 79dc650c18b2..9bc59f9c12fb 100644 +--- a/fs/cifs/smb2proto.h ++++ b/fs/cifs/smb2proto.h +@@ -140,6 +140,8 @@ extern int SMB2_query_directory(const unsigned int xid, struct cifs_tcon *tcon, + extern int SMB2_rename(const unsigned int xid, struct cifs_tcon *tcon, + u64 persistent_fid, u64 volatile_fid, + __le16 *target_file); ++extern int SMB2_rmdir(const unsigned int xid, struct cifs_tcon *tcon, ++ u64 persistent_fid, u64 volatile_fid); + extern int SMB2_set_hardlink(const unsigned int xid, struct cifs_tcon *tcon, + u64 persistent_fid, u64 volatile_fid, + __le16 *target_file); +diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c +index 1eaa6cb96cd0..3fcdb2e9d228 100644 +--- a/fs/ext4/ialloc.c ++++ b/fs/ext4/ialloc.c +@@ -1112,22 +1112,20 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino) + unsigned long max_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count); + ext4_group_t block_group; + int bit; +- struct buffer_head *bitmap_bh; ++ struct buffer_head *bitmap_bh = NULL; + struct inode *inode = NULL; +- long err = -EIO; ++ int err = -EIO; + +- /* Error cases - e2fsck has already cleaned up for us */ +- if (ino > max_ino) { +- ext4_warning(sb, "bad orphan ino %lu! e2fsck was run?", ino); +- goto error; +- } ++ if (ino < EXT4_FIRST_INO(sb) || ino > max_ino) ++ goto bad_orphan; + + block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb); + bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb); + bitmap_bh = ext4_read_inode_bitmap(sb, block_group); + if (!bitmap_bh) { +- ext4_warning(sb, "inode bitmap error for orphan %lu", ino); +- goto error; ++ ext4_error(sb, "inode bitmap error %ld for orphan %lu", ++ ino, PTR_ERR(bitmap_bh)); ++ return (struct inode *) bitmap_bh; + } + + /* Having the inode bit set should be a 100% indicator that this +@@ -1138,15 +1136,21 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino) + goto bad_orphan; + + inode = ext4_iget(sb, ino); +- if (IS_ERR(inode)) +- goto iget_failed; ++ if (IS_ERR(inode)) { ++ err = PTR_ERR(inode); ++ ext4_error(sb, "couldn't read orphan inode %lu (err %d)", ++ ino, err); ++ return inode; ++ } + + /* +- * If the orphans has i_nlinks > 0 then it should be able to be +- * truncated, otherwise it won't be removed from the orphan list +- * during processing and an infinite loop will result. ++ * If the orphans has i_nlinks > 0 then it should be able to ++ * be truncated, otherwise it won't be removed from the orphan ++ * list during processing and an infinite loop will result. ++ * Similarly, it must not be a bad inode. + */ +- if (inode->i_nlink && !ext4_can_truncate(inode)) ++ if ((inode->i_nlink && !ext4_can_truncate(inode)) || ++ is_bad_inode(inode)) + goto bad_orphan; + + if (NEXT_ORPHAN(inode) > max_ino) +@@ -1154,29 +1158,25 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino) + brelse(bitmap_bh); + return inode; + +-iget_failed: +- err = PTR_ERR(inode); +- inode = NULL; + bad_orphan: +- ext4_warning(sb, "bad orphan inode %lu! e2fsck was run?", ino); +- printk(KERN_WARNING "ext4_test_bit(bit=%d, block=%llu) = %d\n", +- bit, (unsigned long long)bitmap_bh->b_blocknr, +- ext4_test_bit(bit, bitmap_bh->b_data)); +- printk(KERN_WARNING "inode=%p\n", inode); ++ ext4_error(sb, "bad orphan inode %lu", ino); ++ if (bitmap_bh) ++ printk(KERN_ERR "ext4_test_bit(bit=%d, block=%llu) = %d\n", ++ bit, (unsigned long long)bitmap_bh->b_blocknr, ++ ext4_test_bit(bit, bitmap_bh->b_data)); + if (inode) { +- printk(KERN_WARNING "is_bad_inode(inode)=%d\n", ++ printk(KERN_ERR "is_bad_inode(inode)=%d\n", + is_bad_inode(inode)); +- printk(KERN_WARNING "NEXT_ORPHAN(inode)=%u\n", ++ printk(KERN_ERR "NEXT_ORPHAN(inode)=%u\n", + NEXT_ORPHAN(inode)); +- printk(KERN_WARNING "max_ino=%lu\n", max_ino); +- printk(KERN_WARNING "i_nlink=%u\n", inode->i_nlink); ++ printk(KERN_ERR "max_ino=%lu\n", max_ino); ++ printk(KERN_ERR "i_nlink=%u\n", inode->i_nlink); + /* Avoid freeing blocks if we got a bad deleted inode */ + if (inode->i_nlink == 0) + inode->i_blocks = 0; + iput(inode); + } + brelse(bitmap_bh); +-error: + return ERR_PTR(err); + } + +diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c +index 41260489d3bc..5b58e266892b 100644 +--- a/fs/ext4/mballoc.c ++++ b/fs/ext4/mballoc.c +@@ -1248,6 +1248,7 @@ static void ext4_mb_unload_buddy(struct ext4_buddy *e4b) + static int mb_find_order_for_block(struct ext4_buddy *e4b, int block) + { + int order = 1; ++ int bb_incr = 1 << (e4b->bd_blkbits - 1); + void *bb; + + BUG_ON(e4b->bd_bitmap == e4b->bd_buddy); +@@ -1260,7 +1261,8 @@ static int mb_find_order_for_block(struct ext4_buddy *e4b, int block) + /* this block is part of buddy of order 'order' */ + return order; + } +- bb += 1 << (e4b->bd_blkbits - order); ++ bb += bb_incr; ++ bb_incr >>= 1; + order++; + } + return 0; +@@ -2553,7 +2555,7 @@ int ext4_mb_init(struct super_block *sb) + { + struct ext4_sb_info *sbi = EXT4_SB(sb); + unsigned i, j; +- unsigned offset; ++ unsigned offset, offset_incr; + unsigned max; + int ret; + +@@ -2582,11 +2584,13 @@ int ext4_mb_init(struct super_block *sb) + + i = 1; + offset = 0; ++ offset_incr = 1 << (sb->s_blocksize_bits - 1); + max = sb->s_blocksize << 2; + do { + sbi->s_mb_offsets[i] = offset; + sbi->s_mb_maxs[i] = max; +- offset += 1 << (sb->s_blocksize_bits - i); ++ offset += offset_incr; ++ offset_incr = offset_incr >> 1; + max = max >> 1; + i++; + } while (i <= sb->s_blocksize_bits + 1); +diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c +index 814f3beb4369..03482c01fb3e 100644 +--- a/fs/ext4/namei.c ++++ b/fs/ext4/namei.c +@@ -2897,7 +2897,7 @@ int ext4_orphan_add(handle_t *handle, struct inode *inode) + * list entries can cause panics at unmount time. + */ + mutex_lock(&sbi->s_orphan_lock); +- list_del(&EXT4_I(inode)->i_orphan); ++ list_del_init(&EXT4_I(inode)->i_orphan); + mutex_unlock(&sbi->s_orphan_lock); + } + } +diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c +index 8685c655737f..bc6e5c5da88c 100644 +--- a/fs/hpfs/super.c ++++ b/fs/hpfs/super.c +@@ -15,6 +15,7 @@ + #include <linux/sched.h> + #include <linux/bitmap.h> + #include <linux/slab.h> ++#include <linux/seq_file.h> + + /* Mark the filesystem dirty, so that chkdsk checks it when os/2 booted */ + +@@ -426,10 +427,6 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data) + int lowercase, eas, chk, errs, chkdsk, timeshift; + int o; + struct hpfs_sb_info *sbi = hpfs_sb(s); +- char *new_opts = kstrdup(data, GFP_KERNEL); +- +- if (!new_opts) +- return -ENOMEM; + + sync_filesystem(s); + +@@ -466,17 +463,44 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data) + + if (!(*flags & MS_RDONLY)) mark_dirty(s, 1); + +- replace_mount_options(s, new_opts); +- + hpfs_unlock(s); + return 0; + + out_err: + hpfs_unlock(s); +- kfree(new_opts); + return -EINVAL; + } + ++static int hpfs_show_options(struct seq_file *seq, struct dentry *root) ++{ ++ struct hpfs_sb_info *sbi = hpfs_sb(root->d_sb); ++ ++ seq_printf(seq, ",uid=%u", from_kuid_munged(&init_user_ns, sbi->sb_uid)); ++ seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, sbi->sb_gid)); ++ seq_printf(seq, ",umask=%03o", (~sbi->sb_mode & 0777)); ++ if (sbi->sb_lowercase) ++ seq_printf(seq, ",case=lower"); ++ if (!sbi->sb_chk) ++ seq_printf(seq, ",check=none"); ++ if (sbi->sb_chk == 2) ++ seq_printf(seq, ",check=strict"); ++ if (!sbi->sb_err) ++ seq_printf(seq, ",errors=continue"); ++ if (sbi->sb_err == 2) ++ seq_printf(seq, ",errors=panic"); ++ if (!sbi->sb_chkdsk) ++ seq_printf(seq, ",chkdsk=no"); ++ if (sbi->sb_chkdsk == 2) ++ seq_printf(seq, ",chkdsk=always"); ++ if (!sbi->sb_eas) ++ seq_printf(seq, ",eas=no"); ++ if (sbi->sb_eas == 1) ++ seq_printf(seq, ",eas=ro"); ++ if (sbi->sb_timeshift) ++ seq_printf(seq, ",timeshift=%d", sbi->sb_timeshift); ++ return 0; ++} ++ + /* Super operations */ + + static const struct super_operations hpfs_sops = +@@ -487,7 +511,7 @@ static const struct super_operations hpfs_sops = + .put_super = hpfs_put_super, + .statfs = hpfs_statfs, + .remount_fs = hpfs_remount_fs, +- .show_options = generic_show_options, ++ .show_options = hpfs_show_options, + }; + + static int hpfs_fill_super(struct super_block *s, void *options, int silent) +@@ -510,8 +534,6 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent) + + int o; + +- save_mount_options(s, options); +- + sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); + if (!sbi) { + return -ENOMEM; +diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h +index 4daaa662337b..30c42ed58fc9 100644 +--- a/fs/xfs/libxfs/xfs_format.h ++++ b/fs/xfs/libxfs/xfs_format.h +@@ -754,7 +754,7 @@ typedef struct xfs_agfl { + __be64 agfl_lsn; + __be32 agfl_crc; + __be32 agfl_bno[]; /* actually XFS_AGFL_SIZE(mp) */ +-} xfs_agfl_t; ++} __attribute__((packed)) xfs_agfl_t; + + #define XFS_AGFL_CRC_OFF offsetof(struct xfs_agfl, agfl_crc) + +diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c +index cb7e8a29dfb6..1a89b3417989 100644 +--- a/fs/xfs/xfs_fsops.c ++++ b/fs/xfs/xfs_fsops.c +@@ -241,8 +241,8 @@ xfs_growfs_data_private( + agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp)); + agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1); + agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1); +- agf->agf_flfirst = 0; +- agf->agf_fllast = cpu_to_be32(XFS_AGFL_SIZE(mp) - 1); ++ agf->agf_flfirst = cpu_to_be32(1); ++ agf->agf_fllast = 0; + agf->agf_flcount = 0; + tmpsize = agsize - XFS_PREALLOC_BLOCKS(mp); + agf->agf_freeblks = cpu_to_be32(tmpsize); +diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c +index 539a85fddbc2..c29f34253e2b 100644 +--- a/fs/xfs/xfs_inode.c ++++ b/fs/xfs/xfs_inode.c +@@ -3236,13 +3236,14 @@ xfs_iflush_cluster( + * We need to check under the i_flags_lock for a valid inode + * here. Skip it if it is not valid or the wrong inode. + */ +- spin_lock(&ip->i_flags_lock); +- if (!ip->i_ino || ++ spin_lock(&iq->i_flags_lock); ++ if (!iq->i_ino || ++ __xfs_iflags_test(iq, XFS_ISTALE) || + (XFS_INO_TO_AGINO(mp, iq->i_ino) & mask) != first_index) { +- spin_unlock(&ip->i_flags_lock); ++ spin_unlock(&iq->i_flags_lock); + continue; + } +- spin_unlock(&ip->i_flags_lock); ++ spin_unlock(&iq->i_flags_lock); + + /* + * Do an un-protected check to see if the inode is dirty and +@@ -3358,7 +3359,7 @@ xfs_iflush( + struct xfs_buf **bpp) + { + struct xfs_mount *mp = ip->i_mount; +- struct xfs_buf *bp; ++ struct xfs_buf *bp = NULL; + struct xfs_dinode *dip; + int error; + +@@ -3400,14 +3401,22 @@ xfs_iflush( + } + + /* +- * Get the buffer containing the on-disk inode. ++ * Get the buffer containing the on-disk inode. We are doing a try-lock ++ * operation here, so we may get an EAGAIN error. In that case, we ++ * simply want to return with the inode still dirty. ++ * ++ * If we get any other error, we effectively have a corruption situation ++ * and we cannot flush the inode, so we treat it the same as failing ++ * xfs_iflush_int(). + */ + error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &bp, XBF_TRYLOCK, + 0); +- if (error || !bp) { ++ if (error == -EAGAIN) { + xfs_ifunlock(ip); + return error; + } ++ if (error) ++ goto corrupt_out; + + /* + * First flush out the inode that xfs_iflush was called with. +@@ -3435,7 +3444,8 @@ xfs_iflush( + return 0; + + corrupt_out: +- xfs_buf_relse(bp); ++ if (bp) ++ xfs_buf_relse(bp); + xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); + cluster_corrupt_out: + error = -EFSCORRUPTED; +diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c +index 65a45372fb1f..2a517576f2bc 100644 +--- a/fs/xfs/xfs_super.c ++++ b/fs/xfs/xfs_super.c +@@ -1233,6 +1233,16 @@ xfs_fs_remount( + return -EINVAL; + } + ++ if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 && ++ xfs_sb_has_ro_compat_feature(sbp, ++ XFS_SB_FEAT_RO_COMPAT_UNKNOWN)) { ++ xfs_warn(mp, ++"ro->rw transition prohibited on unknown (0x%x) ro-compat filesystem", ++ (sbp->sb_features_ro_compat & ++ XFS_SB_FEAT_RO_COMPAT_UNKNOWN)); ++ return -EINVAL; ++ } ++ + mp->m_flags &= ~XFS_MOUNT_RDONLY; + + /* +diff --git a/include/asm-generic/siginfo.h b/include/asm-generic/siginfo.h +index 3d1a3af5cf59..a2508a8f9a9c 100644 +--- a/include/asm-generic/siginfo.h ++++ b/include/asm-generic/siginfo.h +@@ -17,21 +17,6 @@ + struct siginfo; + void do_schedule_next_timer(struct siginfo *info); + +-#ifndef HAVE_ARCH_COPY_SIGINFO +- +-#include <linux/string.h> +- +-static inline void copy_siginfo(struct siginfo *to, struct siginfo *from) +-{ +- if (from->si_code < 0) +- memcpy(to, from, sizeof(*to)); +- else +- /* _sigchld is currently the largest know union member */ +- memcpy(to, from, __ARCH_SI_PREAMBLE_SIZE + sizeof(from->_sifields._sigchld)); +-} +- +-#endif +- + extern int copy_siginfo_to_user(struct siginfo __user *to, const struct siginfo *from); + + #endif +diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h +index c3a9c8fc60fa..5e13b987d9e2 100644 +--- a/include/linux/can/dev.h ++++ b/include/linux/can/dev.h +@@ -39,8 +39,11 @@ struct can_priv { + struct can_clock clock; + + enum can_state state; +- u32 ctrlmode; +- u32 ctrlmode_supported; ++ ++ /* CAN controller features - see include/uapi/linux/can/netlink.h */ ++ u32 ctrlmode; /* current options setting */ ++ u32 ctrlmode_supported; /* options that can be modified by netlink */ ++ u32 ctrlmode_static; /* static enabled options for driver/hardware */ + + int restart_ms; + struct timer_list restart_timer; +@@ -107,6 +110,21 @@ static inline bool can_is_canfd_skb(const struct sk_buff *skb) + return skb->len == CANFD_MTU; + } + ++/* helper to define static CAN controller features at device creation time */ ++static inline void can_set_static_ctrlmode(struct net_device *dev, ++ u32 static_mode) ++{ ++ struct can_priv *priv = netdev_priv(dev); ++ ++ /* alloc_candev() succeeded => netdev_priv() is valid at this point */ ++ priv->ctrlmode = static_mode; ++ priv->ctrlmode_static = static_mode; ++ ++ /* override MTU which was set by default in can_setup()? */ ++ if (static_mode & CAN_CTRLMODE_FD) ++ dev->mtu = CANFD_MTU; ++} ++ + /* get data length from can_dlc with sanitized can_dlc */ + u8 can_dlc2len(u8 can_dlc); + +diff --git a/include/linux/signal.h b/include/linux/signal.h +index ab1e0392b5ac..883ceb1439fa 100644 +--- a/include/linux/signal.h ++++ b/include/linux/signal.h +@@ -28,6 +28,21 @@ struct sigpending { + sigset_t signal; + }; + ++#ifndef HAVE_ARCH_COPY_SIGINFO ++ ++#include <linux/string.h> ++ ++static inline void copy_siginfo(struct siginfo *to, struct siginfo *from) ++{ ++ if (from->si_code < 0) ++ memcpy(to, from, sizeof(*to)); ++ else ++ /* _sigchld is currently the largest know union member */ ++ memcpy(to, from, __ARCH_SI_PREAMBLE_SIZE + sizeof(from->_sifields._sigchld)); ++} ++ ++#endif ++ + /* + * Define some primitives to manipulate sigset_t. + */ +diff --git a/include/linux/tty.h b/include/linux/tty.h +index 5e704e26f9a2..52baf4089bd2 100644 +--- a/include/linux/tty.h ++++ b/include/linux/tty.h +@@ -339,7 +339,6 @@ struct tty_file_private { + #define TTY_EXCLUSIVE 3 /* Exclusive open mode */ + #define TTY_DEBUG 4 /* Debugging */ + #define TTY_DO_WRITE_WAKEUP 5 /* Call write_wakeup after queuing new */ +-#define TTY_OTHER_DONE 6 /* Closed pty has completed input processing */ + #define TTY_LDISC_OPEN 11 /* Line discipline is open */ + #define TTY_PTY_LOCK 16 /* pty private */ + #define TTY_NO_WRITE_SPLIT 17 /* Preserve write boundaries to driver */ +@@ -467,6 +466,7 @@ extern void tty_buffer_free_all(struct tty_port *port); + extern void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld); + extern void tty_buffer_init(struct tty_port *port); + extern void tty_buffer_set_lock_subclass(struct tty_port *port); ++extern void tty_buffer_flush_work(struct tty_port *port); + extern speed_t tty_termios_baud_rate(struct ktermios *termios); + extern speed_t tty_termios_input_baud_rate(struct ktermios *termios); + extern void tty_termios_encode_baud_rate(struct ktermios *termios, +diff --git a/include/linux/usb.h b/include/linux/usb.h +index 447fe29b55b4..cb793594aa1e 100644 +--- a/include/linux/usb.h ++++ b/include/linux/usb.h +@@ -367,14 +367,13 @@ struct usb_bus { + + int devnum_next; /* Next open device number in + * round-robin allocation */ ++ struct mutex devnum_next_mutex; /* devnum_next mutex */ + + struct usb_devmap devmap; /* device address allocation map */ + struct usb_device *root_hub; /* Root hub */ + struct usb_bus *hs_companion; /* Companion EHCI bus, if any */ + struct list_head bus_list; /* list of busses */ + +- struct mutex usb_address0_mutex; /* unaddressed device mutex */ +- + int bandwidth_allocated; /* on this bus: how much of the time + * reserved for periodic (intr/iso) + * requests is used, on average? +@@ -1060,7 +1059,7 @@ struct usbdrv_wrap { + * for interfaces bound to this driver. + * @soft_unbind: if set to 1, the USB core will not kill URBs and disable + * endpoints before calling the driver's disconnect method. +- * @disable_hub_initiated_lpm: if set to 0, the USB core will not allow hubs ++ * @disable_hub_initiated_lpm: if set to 1, the USB core will not allow hubs + * to initiate lower power link state transitions when an idle timeout + * occurs. Device-initiated USB 3.0 link PM will still be allowed. + * +diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h +index 68b1e836dff1..c00c7393ce8c 100644 +--- a/include/linux/usb/hcd.h ++++ b/include/linux/usb/hcd.h +@@ -169,6 +169,7 @@ struct usb_hcd { + * bandwidth_mutex should be dropped after a successful control message + * to the device, or resetting the bandwidth after a failed attempt. + */ ++ struct mutex *address0_mutex; + struct mutex *bandwidth_mutex; + struct usb_hcd *shared_hcd; + struct usb_hcd *primary_hcd; +diff --git a/kernel/exit.c b/kernel/exit.c +index 22fcc05dec40..819f51ec4f55 100644 +--- a/kernel/exit.c ++++ b/kernel/exit.c +@@ -914,17 +914,28 @@ static int eligible_pid(struct wait_opts *wo, struct task_struct *p) + task_pid_type(p, wo->wo_type) == wo->wo_pid; + } + +-static int eligible_child(struct wait_opts *wo, struct task_struct *p) ++static int ++eligible_child(struct wait_opts *wo, bool ptrace, struct task_struct *p) + { + if (!eligible_pid(wo, p)) + return 0; +- /* Wait for all children (clone and not) if __WALL is set; +- * otherwise, wait for clone children *only* if __WCLONE is +- * set; otherwise, wait for non-clone children *only*. (Note: +- * A "clone" child here is one that reports to its parent +- * using a signal other than SIGCHLD.) */ +- if (((p->exit_signal != SIGCHLD) ^ !!(wo->wo_flags & __WCLONE)) +- && !(wo->wo_flags & __WALL)) ++ ++ /* ++ * Wait for all children (clone and not) if __WALL is set or ++ * if it is traced by us. ++ */ ++ if (ptrace || (wo->wo_flags & __WALL)) ++ return 1; ++ ++ /* ++ * Otherwise, wait for clone children *only* if __WCLONE is set; ++ * otherwise, wait for non-clone children *only*. ++ * ++ * Note: a "clone" child here is one that reports to its parent ++ * using a signal other than SIGCHLD, or a non-leader thread which ++ * we can only see if it is traced by us. ++ */ ++ if ((p->exit_signal != SIGCHLD) ^ !!(wo->wo_flags & __WCLONE)) + return 0; + + return 1; +@@ -1297,7 +1308,7 @@ static int wait_consider_task(struct wait_opts *wo, int ptrace, + if (unlikely(exit_state == EXIT_DEAD)) + return 0; + +- ret = eligible_child(wo, p); ++ ret = eligible_child(wo, ptrace, p); + if (!ret) + return ret; + +diff --git a/kernel/sched/proc.c b/kernel/sched/proc.c +index 8ecd552fe4f2..09dfe51f89b5 100644 +--- a/kernel/sched/proc.c ++++ b/kernel/sched/proc.c +@@ -97,10 +97,13 @@ long calc_load_fold_active(struct rq *this_rq) + static unsigned long + calc_load(unsigned long load, unsigned long exp, unsigned long active) + { +- load *= exp; +- load += active * (FIXED_1 - exp); +- load += 1UL << (FSHIFT - 1); +- return load >> FSHIFT; ++ unsigned long newload; ++ ++ newload = load * exp + active * (FIXED_1 - exp); ++ if (active >= load) ++ newload += FIXED_1-1; ++ ++ return newload / FIXED_1; + } + + #ifdef CONFIG_NO_HZ_COMMON +diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c +index 0315d43176d8..fb147c7811d2 100644 +--- a/kernel/trace/ring_buffer.c ++++ b/kernel/trace/ring_buffer.c +@@ -461,7 +461,8 @@ struct ring_buffer_per_cpu { + raw_spinlock_t reader_lock; /* serialize readers */ + arch_spinlock_t lock; + struct lock_class_key lock_key; +- unsigned int nr_pages; ++ unsigned long nr_pages; ++ unsigned int current_context; + struct list_head *pages; + struct buffer_page *head_page; /* read from head */ + struct buffer_page *tail_page; /* write to tail */ +@@ -481,7 +482,7 @@ struct ring_buffer_per_cpu { + u64 write_stamp; + u64 read_stamp; + /* ring buffer pages to update, > 0 to add, < 0 to remove */ +- int nr_pages_to_update; ++ long nr_pages_to_update; + struct list_head new_pages; /* new pages to add */ + struct work_struct update_pages_work; + struct completion update_done; +@@ -1160,10 +1161,10 @@ static int rb_check_pages(struct ring_buffer_per_cpu *cpu_buffer) + return 0; + } + +-static int __rb_allocate_pages(int nr_pages, struct list_head *pages, int cpu) ++static int __rb_allocate_pages(long nr_pages, struct list_head *pages, int cpu) + { +- int i; + struct buffer_page *bpage, *tmp; ++ long i; + + for (i = 0; i < nr_pages; i++) { + struct page *page; +@@ -1200,7 +1201,7 @@ free_pages: + } + + static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer, +- unsigned nr_pages) ++ unsigned long nr_pages) + { + LIST_HEAD(pages); + +@@ -1225,7 +1226,7 @@ static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer, + } + + static struct ring_buffer_per_cpu * +-rb_allocate_cpu_buffer(struct ring_buffer *buffer, int nr_pages, int cpu) ++rb_allocate_cpu_buffer(struct ring_buffer *buffer, long nr_pages, int cpu) + { + struct ring_buffer_per_cpu *cpu_buffer; + struct buffer_page *bpage; +@@ -1325,8 +1326,9 @@ struct ring_buffer *__ring_buffer_alloc(unsigned long size, unsigned flags, + struct lock_class_key *key) + { + struct ring_buffer *buffer; ++ long nr_pages; + int bsize; +- int cpu, nr_pages; ++ int cpu; + + /* keep it in its own cache line */ + buffer = kzalloc(ALIGN(sizeof(*buffer), cache_line_size()), +@@ -1452,12 +1454,12 @@ static inline unsigned long rb_page_write(struct buffer_page *bpage) + } + + static int +-rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned int nr_pages) ++rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned long nr_pages) + { + struct list_head *tail_page, *to_remove, *next_page; + struct buffer_page *to_remove_page, *tmp_iter_page; + struct buffer_page *last_page, *first_page; +- unsigned int nr_removed; ++ unsigned long nr_removed; + unsigned long head_bit; + int page_entries; + +@@ -1674,7 +1676,7 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size, + int cpu_id) + { + struct ring_buffer_per_cpu *cpu_buffer; +- unsigned nr_pages; ++ unsigned long nr_pages; + int cpu, err = 0; + + /* +@@ -1688,14 +1690,13 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size, + !cpumask_test_cpu(cpu_id, buffer->cpumask)) + return size; + +- size = DIV_ROUND_UP(size, BUF_PAGE_SIZE); +- size *= BUF_PAGE_SIZE; ++ nr_pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE); + + /* we need a minimum of two pages */ +- if (size < BUF_PAGE_SIZE * 2) +- size = BUF_PAGE_SIZE * 2; ++ if (nr_pages < 2) ++ nr_pages = 2; + +- nr_pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE); ++ size = nr_pages * BUF_PAGE_SIZE; + + /* + * Don't succeed if resizing is disabled, as a reader might be +@@ -2675,11 +2676,11 @@ rb_reserve_next_event(struct ring_buffer *buffer, + * just so happens that it is the same bit corresponding to + * the current context. + */ +-static DEFINE_PER_CPU(unsigned int, current_context); + +-static __always_inline int trace_recursive_lock(void) ++static __always_inline int ++trace_recursive_lock(struct ring_buffer_per_cpu *cpu_buffer) + { +- unsigned int val = __this_cpu_read(current_context); ++ unsigned int val = cpu_buffer->current_context; + int bit; + + if (in_interrupt()) { +@@ -2696,20 +2697,21 @@ static __always_inline int trace_recursive_lock(void) + return 1; + + val |= (1 << bit); +- __this_cpu_write(current_context, val); ++ cpu_buffer->current_context = val; + + return 0; + } + +-static __always_inline void trace_recursive_unlock(void) ++static __always_inline void ++trace_recursive_unlock(struct ring_buffer_per_cpu *cpu_buffer) + { +- __this_cpu_and(current_context, __this_cpu_read(current_context) - 1); ++ cpu_buffer->current_context &= cpu_buffer->current_context - 1; + } + + #else + +-#define trace_recursive_lock() (0) +-#define trace_recursive_unlock() do { } while (0) ++#define trace_recursive_lock(cpu_buffer) (0) ++#define trace_recursive_unlock(cpu_buffer) do { } while (0) + + #endif + +@@ -2741,35 +2743,34 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer, unsigned long length) + /* If we are tracing schedule, we don't want to recurse */ + preempt_disable_notrace(); + +- if (atomic_read(&buffer->record_disabled)) +- goto out_nocheck; +- +- if (trace_recursive_lock()) +- goto out_nocheck; ++ if (unlikely(atomic_read(&buffer->record_disabled))) ++ goto out; + + cpu = raw_smp_processor_id(); + +- if (!cpumask_test_cpu(cpu, buffer->cpumask)) ++ if (unlikely(!cpumask_test_cpu(cpu, buffer->cpumask))) + goto out; + + cpu_buffer = buffer->buffers[cpu]; + +- if (atomic_read(&cpu_buffer->record_disabled)) ++ if (unlikely(atomic_read(&cpu_buffer->record_disabled))) + goto out; + +- if (length > BUF_MAX_DATA_SIZE) ++ if (unlikely(length > BUF_MAX_DATA_SIZE)) ++ goto out; ++ ++ if (unlikely(trace_recursive_lock(cpu_buffer))) + goto out; + + event = rb_reserve_next_event(buffer, cpu_buffer, length); + if (!event) +- goto out; ++ goto out_unlock; + + return event; + ++ out_unlock: ++ trace_recursive_unlock(cpu_buffer); + out: +- trace_recursive_unlock(); +- +- out_nocheck: + preempt_enable_notrace(); + return NULL; + } +@@ -2859,7 +2860,7 @@ int ring_buffer_unlock_commit(struct ring_buffer *buffer, + + rb_wakeups(buffer, cpu_buffer); + +- trace_recursive_unlock(); ++ trace_recursive_unlock(cpu_buffer); + + preempt_enable_notrace(); + +@@ -2970,7 +2971,7 @@ void ring_buffer_discard_commit(struct ring_buffer *buffer, + out: + rb_end_commit(cpu_buffer); + +- trace_recursive_unlock(); ++ trace_recursive_unlock(cpu_buffer); + + preempt_enable_notrace(); + +@@ -4647,8 +4648,9 @@ static int rb_cpu_notify(struct notifier_block *self, + struct ring_buffer *buffer = + container_of(self, struct ring_buffer, cpu_notify); + long cpu = (long)hcpu; +- int cpu_i, nr_pages_same; +- unsigned int nr_pages; ++ long nr_pages_same; ++ int cpu_i; ++ unsigned long nr_pages; + + switch (action) { + case CPU_UP_PREPARE: +diff --git a/lib/dma-debug.c b/lib/dma-debug.c +index 517a568f038d..a30bd1018f7e 100644 +--- a/lib/dma-debug.c ++++ b/lib/dma-debug.c +@@ -657,9 +657,9 @@ static struct dma_debug_entry *dma_entry_alloc(void) + spin_lock_irqsave(&free_entries_lock, flags); + + if (list_empty(&free_entries)) { +- pr_err("DMA-API: debugging out of memory - disabling\n"); + global_disable = true; + spin_unlock_irqrestore(&free_entries_lock, flags); ++ pr_err("DMA-API: debugging out of memory - disabling\n"); + return NULL; + } + +diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c +index 1095be9c80ab..4605dc73def6 100644 +--- a/net/sunrpc/auth_gss/svcauth_gss.c ++++ b/net/sunrpc/auth_gss/svcauth_gss.c +@@ -857,8 +857,8 @@ unwrap_integ_data(struct svc_rqst *rqstp, struct xdr_buf *buf, u32 seq, struct g + goto out; + if (svc_getnl(&buf->head[0]) != seq) + goto out; +- /* trim off the mic at the end before returning */ +- xdr_buf_trim(buf, mic.len + 4); ++ /* trim off the mic and padding at the end before returning */ ++ xdr_buf_trim(buf, round_up_to_quad(mic.len) + 4); + stat = 0; + out: + kfree(mic.data); +diff --git a/scripts/Makefile.extrawarn b/scripts/Makefile.extrawarn +index f734033af219..5c17a5c1f306 100644 +--- a/scripts/Makefile.extrawarn ++++ b/scripts/Makefile.extrawarn +@@ -24,6 +24,7 @@ warning-1 += $(call cc-option, -Wmissing-prototypes) + warning-1 += -Wold-style-definition + warning-1 += $(call cc-option, -Wmissing-include-dirs) + warning-1 += $(call cc-option, -Wunused-but-set-variable) ++warning-1 += $(call cc-option, -Wunused-const-variable) + warning-1 += $(call cc-disable-warning, missing-field-initializers) + + warning-2 := -Waggregate-return +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index 29595e0c3fb4..bee74795c9b9 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -4630,6 +4630,7 @@ enum { + ALC288_FIXUP_DISABLE_AAMIX, + ALC292_FIXUP_DELL_E7X, + ALC292_FIXUP_DISABLE_AAMIX, ++ ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, + ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, + ALC275_FIXUP_DELL_XPS, + ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE, +@@ -5201,6 +5202,12 @@ static const struct hda_fixup alc269_fixups[] = { + .chained = true, + .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE + }, ++ [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = { ++ .type = HDA_FIXUP_FUNC, ++ .v.func = alc_fixup_disable_aamix, ++ .chained = true, ++ .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE ++ }, + [ALC292_FIXUP_DELL_E7X] = { + .type = HDA_FIXUP_FUNC, + .v.func = alc_fixup_dell_xps13, +@@ -5323,13 +5330,14 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), +- SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC292_FIXUP_DISABLE_AAMIX), +- SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC292_FIXUP_DISABLE_AAMIX), +- SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC292_FIXUP_DISABLE_AAMIX), +- SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC292_FIXUP_DISABLE_AAMIX), +- SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC292_FIXUP_DISABLE_AAMIX), +- SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE), ++ SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), ++ SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), ++ SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), ++ SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), ++ SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), ++ SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13 9350", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE), + SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE), ++ SND_PCI_QUIRK(0x1028, 0x075b, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE), + SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2), +diff --git a/sound/soc/codecs/ak4642.c b/sound/soc/codecs/ak4642.c +index 13585e88f597..8e9b76d03f81 100644 +--- a/sound/soc/codecs/ak4642.c ++++ b/sound/soc/codecs/ak4642.c +@@ -64,12 +64,15 @@ + #define FIL1_0 0x1c + #define FIL1_1 0x1d + #define FIL1_2 0x1e +-#define FIL1_3 0x1f ++#define FIL1_3 0x1f /* The maximum valid register for ak4642 */ + #define PW_MGMT4 0x20 + #define MD_CTL5 0x21 + #define LO_MS 0x22 + #define HP_MS 0x23 +-#define SPK_MS 0x24 ++#define SPK_MS 0x24 /* The maximum valid register for ak4643 */ ++#define EQ_FBEQAB 0x25 ++#define EQ_FBEQCD 0x26 ++#define EQ_FBEQE 0x27 /* The maximum valid register for ak4648 */ + + /* PW_MGMT1*/ + #define PMVCM (1 << 6) /* VCOM Power Management */ +@@ -241,7 +244,7 @@ static const struct snd_soc_dapm_route ak4642_intercon[] = { + /* + * ak4642 register cache + */ +-static const struct reg_default ak4642_reg[] = { ++static const struct reg_default ak4643_reg[] = { + { 0, 0x00 }, { 1, 0x00 }, { 2, 0x01 }, { 3, 0x00 }, + { 4, 0x02 }, { 5, 0x00 }, { 6, 0x00 }, { 7, 0x00 }, + { 8, 0xe1 }, { 9, 0xe1 }, { 10, 0x18 }, { 11, 0x00 }, +@@ -254,6 +257,14 @@ static const struct reg_default ak4642_reg[] = { + { 36, 0x00 }, + }; + ++/* The default settings for 0x0 ~ 0x1f registers are the same for ak4642 ++ and ak4643. So we reuse the ak4643 reg_default for ak4642. ++ The valid registers for ak4642 are 0x0 ~ 0x1f which is a subset of ak4643, ++ so define NUM_AK4642_REG_DEFAULTS for ak4642. ++*/ ++#define ak4642_reg ak4643_reg ++#define NUM_AK4642_REG_DEFAULTS (FIL1_3 + 1) ++ + static const struct reg_default ak4648_reg[] = { + { 0, 0x00 }, { 1, 0x00 }, { 2, 0x01 }, { 3, 0x00 }, + { 4, 0x02 }, { 5, 0x00 }, { 6, 0x00 }, { 7, 0x00 }, +@@ -536,17 +547,28 @@ static struct snd_soc_codec_driver soc_codec_dev_ak4642 = { + static const struct regmap_config ak4642_regmap = { + .reg_bits = 8, + .val_bits = 8, +- .max_register = ARRAY_SIZE(ak4642_reg) + 1, ++ .max_register = FIL1_3, + .reg_defaults = ak4642_reg, +- .num_reg_defaults = ARRAY_SIZE(ak4642_reg), ++ .num_reg_defaults = NUM_AK4642_REG_DEFAULTS, ++ .cache_type = REGCACHE_RBTREE, ++}; ++ ++static const struct regmap_config ak4643_regmap = { ++ .reg_bits = 8, ++ .val_bits = 8, ++ .max_register = SPK_MS, ++ .reg_defaults = ak4643_reg, ++ .num_reg_defaults = ARRAY_SIZE(ak4643_reg), ++ .cache_type = REGCACHE_RBTREE, + }; + + static const struct regmap_config ak4648_regmap = { + .reg_bits = 8, + .val_bits = 8, +- .max_register = ARRAY_SIZE(ak4648_reg) + 1, ++ .max_register = EQ_FBEQE, + .reg_defaults = ak4648_reg, + .num_reg_defaults = ARRAY_SIZE(ak4648_reg), ++ .cache_type = REGCACHE_RBTREE, + }; + + static const struct ak4642_drvdata ak4642_drvdata = { +@@ -554,7 +576,7 @@ static const struct ak4642_drvdata ak4642_drvdata = { + }; + + static const struct ak4642_drvdata ak4643_drvdata = { +- .regmap_config = &ak4642_regmap, ++ .regmap_config = &ak4643_regmap, + }; + + static const struct ak4642_drvdata ak4648_drvdata = { |