commit: d90887db45c919719e541d2b025a26f8f23958c3 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Wed Sep 23 12:14:03 2020 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Wed Sep 23 12:14:03 2020 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=d90887db
Linux patch 5.8.11 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1010_linux-5.8.11.patch | 3917 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 3921 insertions(+) diff --git a/0000_README b/0000_README index f2e8a67..e5b0bab 100644 --- a/0000_README +++ b/0000_README @@ -83,6 +83,10 @@ Patch: 1009_linux-5.8.10.patch From: http://www.kernel.org Desc: Linux 5.8.10 +Patch: 1010_linux-5.8.11.patch +From: http://www.kernel.org +Desc: Linux 5.8.11 + 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/1010_linux-5.8.11.patch b/1010_linux-5.8.11.patch new file mode 100644 index 0000000..2bc9a4f --- /dev/null +++ b/1010_linux-5.8.11.patch @@ -0,0 +1,3917 @@ +diff --git a/Documentation/devicetree/bindings/pci/intel-gw-pcie.yaml b/Documentation/devicetree/bindings/pci/intel-gw-pcie.yaml +index 64b2c64ca8065..a1e2be737eec9 100644 +--- a/Documentation/devicetree/bindings/pci/intel-gw-pcie.yaml ++++ b/Documentation/devicetree/bindings/pci/intel-gw-pcie.yaml +@@ -9,6 +9,14 @@ title: PCIe RC controller on Intel Gateway SoCs + maintainers: + - Dilip Kota <eswara.k...@linux.intel.com> + ++select: ++ properties: ++ compatible: ++ contains: ++ const: intel,lgm-pcie ++ required: ++ - compatible ++ + properties: + compatible: + items: +diff --git a/Documentation/devicetree/bindings/spi/brcm,spi-bcm-qspi.txt b/Documentation/devicetree/bindings/spi/brcm,spi-bcm-qspi.txt +index f5e518d099f2c..62d4ed2d7fd79 100644 +--- a/Documentation/devicetree/bindings/spi/brcm,spi-bcm-qspi.txt ++++ b/Documentation/devicetree/bindings/spi/brcm,spi-bcm-qspi.txt +@@ -23,8 +23,8 @@ Required properties: + + - compatible: + Must be one of : +- "brcm,spi-bcm-qspi", "brcm,spi-brcmstb-qspi" : MSPI+BSPI on BRCMSTB SoCs +- "brcm,spi-bcm-qspi", "brcm,spi-brcmstb-mspi" : Second Instance of MSPI ++ "brcm,spi-brcmstb-qspi", "brcm,spi-bcm-qspi" : MSPI+BSPI on BRCMSTB SoCs ++ "brcm,spi-brcmstb-mspi", "brcm,spi-bcm-qspi" : Second Instance of MSPI + BRCMSTB SoCs + "brcm,spi-bcm7425-qspi", "brcm,spi-bcm-qspi", "brcm,spi-brcmstb-mspi" : Second Instance of MSPI + BRCMSTB SoCs +@@ -36,8 +36,8 @@ Required properties: + BRCMSTB SoCs + "brcm,spi-bcm7278-qspi", "brcm,spi-bcm-qspi", "brcm,spi-brcmstb-mspi" : Second Instance of MSPI + BRCMSTB SoCs +- "brcm,spi-bcm-qspi", "brcm,spi-nsp-qspi" : MSPI+BSPI on Cygnus, NSP +- "brcm,spi-bcm-qspi", "brcm,spi-ns2-qspi" : NS2 SoCs ++ "brcm,spi-nsp-qspi", "brcm,spi-bcm-qspi" : MSPI+BSPI on Cygnus, NSP ++ "brcm,spi-ns2-qspi", "brcm,spi-bcm-qspi" : NS2 SoCs + + - reg: + Define the bases and ranges of the associated I/O address spaces. +@@ -86,7 +86,7 @@ BRCMSTB SoC Example: + spi@f03e3400 { + #address-cells = <0x1>; + #size-cells = <0x0>; +- compatible = "brcm,spi-brcmstb-qspi", "brcm,spi-brcmstb-qspi"; ++ compatible = "brcm,spi-brcmstb-qspi", "brcm,spi-bcm-qspi"; + reg = <0xf03e0920 0x4 0xf03e3400 0x188 0xf03e3200 0x50>; + reg-names = "cs_reg", "mspi", "bspi"; + interrupts = <0x6 0x5 0x4 0x3 0x2 0x1 0x0>; +@@ -149,7 +149,7 @@ BRCMSTB SoC Example: + #address-cells = <1>; + #size-cells = <0>; + clocks = <&upg_fixed>; +- compatible = "brcm,spi-brcmstb-qspi", "brcm,spi-brcmstb-mspi"; ++ compatible = "brcm,spi-brcmstb-mspi", "brcm,spi-bcm-qspi"; + reg = <0xf0416000 0x180>; + reg-names = "mspi"; + interrupts = <0x14>; +@@ -160,7 +160,7 @@ BRCMSTB SoC Example: + iProc SoC Example: + + qspi: spi@18027200 { +- compatible = "brcm,spi-bcm-qspi", "brcm,spi-nsp-qspi"; ++ compatible = "brcm,spi-nsp-qspi", "brcm,spi-bcm-qspi"; + reg = <0x18027200 0x184>, + <0x18027000 0x124>, + <0x1811c408 0x004>, +@@ -191,7 +191,7 @@ iProc SoC Example: + NS2 SoC Example: + + qspi: spi@66470200 { +- compatible = "brcm,spi-bcm-qspi", "brcm,spi-ns2-qspi"; ++ compatible = "brcm,spi-ns2-qspi", "brcm,spi-bcm-qspi"; + reg = <0x66470200 0x184>, + <0x66470000 0x124>, + <0x67017408 0x004>, +diff --git a/Makefile b/Makefile +index d937530d33427..0b025b3a56401 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 8 +-SUBLEVEL = 10 ++SUBLEVEL = 11 + EXTRAVERSION = + NAME = Kleptomaniac Octopus + +diff --git a/arch/arm64/kernel/cpu_errata.c b/arch/arm64/kernel/cpu_errata.c +index 2c0b82db825ba..422ed2e38a6c8 100644 +--- a/arch/arm64/kernel/cpu_errata.c ++++ b/arch/arm64/kernel/cpu_errata.c +@@ -910,8 +910,12 @@ const struct arm64_cpu_capabilities arm64_errata[] = { + .desc = "ARM erratum 1418040", + .capability = ARM64_WORKAROUND_1418040, + ERRATA_MIDR_RANGE_LIST(erratum_1418040_list), +- .type = (ARM64_CPUCAP_SCOPE_LOCAL_CPU | +- ARM64_CPUCAP_PERMITTED_FOR_LATE_CPU), ++ /* ++ * We need to allow affected CPUs to come in late, but ++ * also need the non-affected CPUs to be able to come ++ * in at any point in time. Wonderful. ++ */ ++ .type = ARM64_CPUCAP_WEAK_LOCAL_CPU_FEATURE, + }, + #endif + #ifdef CONFIG_ARM64_WORKAROUND_SPECULATIVE_AT +diff --git a/arch/arm64/kernel/paravirt.c b/arch/arm64/kernel/paravirt.c +index 295d66490584b..c07d7a0349410 100644 +--- a/arch/arm64/kernel/paravirt.c ++++ b/arch/arm64/kernel/paravirt.c +@@ -50,16 +50,19 @@ static u64 pv_steal_clock(int cpu) + struct pv_time_stolen_time_region *reg; + + reg = per_cpu_ptr(&stolen_time_region, cpu); +- if (!reg->kaddr) { +- pr_warn_once("stolen time enabled but not configured for cpu %d\n", +- cpu); ++ ++ /* ++ * paravirt_steal_clock() may be called before the CPU ++ * online notification callback runs. Until the callback ++ * has run we just return zero. ++ */ ++ if (!reg->kaddr) + return 0; +- } + + return le64_to_cpu(READ_ONCE(reg->kaddr->stolen_time)); + } + +-static int stolen_time_dying_cpu(unsigned int cpu) ++static int stolen_time_cpu_down_prepare(unsigned int cpu) + { + struct pv_time_stolen_time_region *reg; + +@@ -73,7 +76,7 @@ static int stolen_time_dying_cpu(unsigned int cpu) + return 0; + } + +-static int init_stolen_time_cpu(unsigned int cpu) ++static int stolen_time_cpu_online(unsigned int cpu) + { + struct pv_time_stolen_time_region *reg; + struct arm_smccc_res res; +@@ -103,19 +106,20 @@ static int init_stolen_time_cpu(unsigned int cpu) + return 0; + } + +-static int pv_time_init_stolen_time(void) ++static int __init pv_time_init_stolen_time(void) + { + int ret; + +- ret = cpuhp_setup_state(CPUHP_AP_ARM_KVMPV_STARTING, +- "hypervisor/arm/pvtime:starting", +- init_stolen_time_cpu, stolen_time_dying_cpu); ++ ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, ++ "hypervisor/arm/pvtime:online", ++ stolen_time_cpu_online, ++ stolen_time_cpu_down_prepare); + if (ret < 0) + return ret; + return 0; + } + +-static bool has_pv_steal_clock(void) ++static bool __init has_pv_steal_clock(void) + { + struct arm_smccc_res res; + +diff --git a/arch/arm64/net/bpf_jit_comp.c b/arch/arm64/net/bpf_jit_comp.c +index 3cb25b43b368e..1b2d82755e41f 100644 +--- a/arch/arm64/net/bpf_jit_comp.c ++++ b/arch/arm64/net/bpf_jit_comp.c +@@ -141,14 +141,17 @@ static inline void emit_addr_mov_i64(const int reg, const u64 val, + } + } + +-static inline int bpf2a64_offset(int bpf_to, int bpf_from, ++static inline int bpf2a64_offset(int bpf_insn, int off, + const struct jit_ctx *ctx) + { +- int to = ctx->offset[bpf_to]; +- /* -1 to account for the Branch instruction */ +- int from = ctx->offset[bpf_from] - 1; +- +- return to - from; ++ /* BPF JMP offset is relative to the next instruction */ ++ bpf_insn++; ++ /* ++ * Whereas arm64 branch instructions encode the offset ++ * from the branch itself, so we must subtract 1 from the ++ * instruction offset. ++ */ ++ return ctx->offset[bpf_insn + off] - (ctx->offset[bpf_insn] - 1); + } + + static void jit_fill_hole(void *area, unsigned int size) +@@ -578,7 +581,7 @@ emit_bswap_uxt: + + /* JUMP off */ + case BPF_JMP | BPF_JA: +- jmp_offset = bpf2a64_offset(i + off, i, ctx); ++ jmp_offset = bpf2a64_offset(i, off, ctx); + check_imm26(jmp_offset); + emit(A64_B(jmp_offset), ctx); + break; +@@ -605,7 +608,7 @@ emit_bswap_uxt: + case BPF_JMP32 | BPF_JSLE | BPF_X: + emit(A64_CMP(is64, dst, src), ctx); + emit_cond_jmp: +- jmp_offset = bpf2a64_offset(i + off, i, ctx); ++ jmp_offset = bpf2a64_offset(i, off, ctx); + check_imm19(jmp_offset); + switch (BPF_OP(code)) { + case BPF_JEQ: +@@ -837,10 +840,21 @@ static int build_body(struct jit_ctx *ctx, bool extra_pass) + const struct bpf_prog *prog = ctx->prog; + int i; + ++ /* ++ * - offset[0] offset of the end of prologue, ++ * start of the 1st instruction. ++ * - offset[1] - offset of the end of 1st instruction, ++ * start of the 2nd instruction ++ * [....] ++ * - offset[3] - offset of the end of 3rd instruction, ++ * start of 4th instruction ++ */ + for (i = 0; i < prog->len; i++) { + const struct bpf_insn *insn = &prog->insnsi[i]; + int ret; + ++ if (ctx->image == NULL) ++ ctx->offset[i] = ctx->idx; + ret = build_insn(insn, ctx, extra_pass); + if (ret > 0) { + i++; +@@ -848,11 +862,16 @@ static int build_body(struct jit_ctx *ctx, bool extra_pass) + ctx->offset[i] = ctx->idx; + continue; + } +- if (ctx->image == NULL) +- ctx->offset[i] = ctx->idx; + if (ret) + return ret; + } ++ /* ++ * offset is allocated with prog->len + 1 so fill in ++ * the last element with the offset after the last ++ * instruction (end of program) ++ */ ++ if (ctx->image == NULL) ++ ctx->offset[i] = ctx->idx; + + return 0; + } +@@ -928,7 +947,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog) + memset(&ctx, 0, sizeof(ctx)); + ctx.prog = prog; + +- ctx.offset = kcalloc(prog->len, sizeof(int), GFP_KERNEL); ++ ctx.offset = kcalloc(prog->len + 1, sizeof(int), GFP_KERNEL); + if (ctx.offset == NULL) { + prog = orig_prog; + goto out_off; +@@ -1008,7 +1027,7 @@ skip_init_ctx: + prog->jited_len = image_size; + + if (!prog->is_func || extra_pass) { +- bpf_prog_fill_jited_linfo(prog, ctx.offset); ++ bpf_prog_fill_jited_linfo(prog, ctx.offset + 1); + out_off: + kfree(ctx.offset); + kfree(jit_data); +diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig +index c43ad3b3cea4b..daa24f1e14831 100644 +--- a/arch/mips/Kconfig ++++ b/arch/mips/Kconfig +@@ -876,6 +876,7 @@ config SNI_RM + select I8253 + select I8259 + select ISA ++ select MIPS_L1_CACHE_SHIFT_6 + select SWAP_IO_SPACE if CPU_BIG_ENDIAN + select SYS_HAS_CPU_R4X00 + select SYS_HAS_CPU_R5000 +diff --git a/arch/mips/kvm/mips.c b/arch/mips/kvm/mips.c +index 666d3350b4ac1..6c6836669ce16 100644 +--- a/arch/mips/kvm/mips.c ++++ b/arch/mips/kvm/mips.c +@@ -137,6 +137,8 @@ extern void kvm_init_loongson_ipi(struct kvm *kvm); + int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) + { + switch (type) { ++ case KVM_VM_MIPS_AUTO: ++ break; + #ifdef CONFIG_KVM_MIPS_VZ + case KVM_VM_MIPS_VZ: + #else +diff --git a/arch/mips/sni/a20r.c b/arch/mips/sni/a20r.c +index b09dc844985a8..eeeec18c420a6 100644 +--- a/arch/mips/sni/a20r.c ++++ b/arch/mips/sni/a20r.c +@@ -143,7 +143,10 @@ static struct platform_device sc26xx_pdev = { + }, + }; + +-static u32 a20r_ack_hwint(void) ++/* ++ * Trigger chipset to update CPU's CAUSE IP field ++ */ ++static u32 a20r_update_cause_ip(void) + { + u32 status = read_c0_status(); + +@@ -205,12 +208,14 @@ static void a20r_hwint(void) + int irq; + + clear_c0_status(IE_IRQ0); +- status = a20r_ack_hwint(); ++ status = a20r_update_cause_ip(); + cause = read_c0_cause(); + + irq = ffs(((cause & status) >> 8) & 0xf8); + if (likely(irq > 0)) + do_IRQ(SNI_A20R_IRQ_BASE + irq - 1); ++ ++ a20r_update_cause_ip(); + set_c0_status(IE_IRQ0); + } + +diff --git a/arch/openrisc/mm/cache.c b/arch/openrisc/mm/cache.c +index 08f56af387ac4..534a52ec5e667 100644 +--- a/arch/openrisc/mm/cache.c ++++ b/arch/openrisc/mm/cache.c +@@ -16,7 +16,7 @@ + #include <asm/cacheflush.h> + #include <asm/tlbflush.h> + +-static void cache_loop(struct page *page, const unsigned int reg) ++static __always_inline void cache_loop(struct page *page, const unsigned int reg) + { + unsigned long paddr = page_to_pfn(page) << PAGE_SHIFT; + unsigned long line = paddr & ~(L1_CACHE_BYTES - 1); +diff --git a/arch/powerpc/include/asm/book3s/64/mmu.h b/arch/powerpc/include/asm/book3s/64/mmu.h +index 5393a535240c7..dfbbffa0eb2e2 100644 +--- a/arch/powerpc/include/asm/book3s/64/mmu.h ++++ b/arch/powerpc/include/asm/book3s/64/mmu.h +@@ -228,14 +228,14 @@ static inline void early_init_mmu_secondary(void) + + extern void hash__setup_initial_memory_limit(phys_addr_t first_memblock_base, + phys_addr_t first_memblock_size); +-extern void radix__setup_initial_memory_limit(phys_addr_t first_memblock_base, +- phys_addr_t first_memblock_size); + static inline void setup_initial_memory_limit(phys_addr_t first_memblock_base, + phys_addr_t first_memblock_size) + { +- if (early_radix_enabled()) +- return radix__setup_initial_memory_limit(first_memblock_base, +- first_memblock_size); ++ /* ++ * Hash has more strict restrictions. At this point we don't ++ * know which translations we will pick. Hence go with hash ++ * restrictions. ++ */ + return hash__setup_initial_memory_limit(first_memblock_base, + first_memblock_size); + } +diff --git a/arch/powerpc/kernel/dma-iommu.c b/arch/powerpc/kernel/dma-iommu.c +index e486d1d78de28..f4cb2c546adbb 100644 +--- a/arch/powerpc/kernel/dma-iommu.c ++++ b/arch/powerpc/kernel/dma-iommu.c +@@ -160,7 +160,8 @@ u64 dma_iommu_get_required_mask(struct device *dev) + return bypass_mask; + } + +- mask = 1ULL < (fls_long(tbl->it_offset + tbl->it_size) - 1); ++ mask = 1ULL << (fls_long(tbl->it_offset + tbl->it_size) + ++ tbl->it_page_shift - 1); + mask += mask - 1; + + return mask; +diff --git a/arch/powerpc/mm/book3s64/radix_pgtable.c b/arch/powerpc/mm/book3s64/radix_pgtable.c +index c2989c1718839..1e9a298020a63 100644 +--- a/arch/powerpc/mm/book3s64/radix_pgtable.c ++++ b/arch/powerpc/mm/book3s64/radix_pgtable.c +@@ -654,21 +654,6 @@ void radix__mmu_cleanup_all(void) + } + } + +-void radix__setup_initial_memory_limit(phys_addr_t first_memblock_base, +- phys_addr_t first_memblock_size) +-{ +- /* +- * We don't currently support the first MEMBLOCK not mapping 0 +- * physical on those processors +- */ +- BUG_ON(first_memblock_base != 0); +- +- /* +- * Radix mode is not limited by RMA / VRMA addressing. +- */ +- ppc64_rma_size = ULONG_MAX; +-} +- + #ifdef CONFIG_MEMORY_HOTPLUG + static void free_pte_table(pte_t *pte_start, pmd_t *pmd) + { +diff --git a/arch/powerpc/mm/init_64.c b/arch/powerpc/mm/init_64.c +index bc73abf0bc25e..ef566fc43933e 100644 +--- a/arch/powerpc/mm/init_64.c ++++ b/arch/powerpc/mm/init_64.c +@@ -431,9 +431,16 @@ void __init mmu_early_init_devtree(void) + if (!(mfmsr() & MSR_HV)) + early_check_vec5(); + +- if (early_radix_enabled()) ++ if (early_radix_enabled()) { + radix__early_init_devtree(); +- else ++ /* ++ * We have finalized the translation we are going to use by now. ++ * Radix mode is not limited by RMA / VRMA addressing. ++ * Hence don't limit memblock allocations. ++ */ ++ ppc64_rma_size = ULONG_MAX; ++ memblock_set_current_limit(MEMBLOCK_ALLOC_ANYWHERE); ++ } else + hash__early_init_devtree(); + } + #endif /* CONFIG_PPC_BOOK3S_64 */ +diff --git a/arch/riscv/mm/init.c b/arch/riscv/mm/init.c +index 79e9d55bdf1ac..e229d95f470b8 100644 +--- a/arch/riscv/mm/init.c ++++ b/arch/riscv/mm/init.c +@@ -226,12 +226,11 @@ void __set_fixmap(enum fixed_addresses idx, phys_addr_t phys, pgprot_t prot) + + ptep = &fixmap_pte[pte_index(addr)]; + +- if (pgprot_val(prot)) { ++ if (pgprot_val(prot)) + set_pte(ptep, pfn_pte(phys >> PAGE_SHIFT, prot)); +- } else { ++ else + pte_clear(&init_mm, addr, ptep); +- local_flush_tlb_page(addr); +- } ++ local_flush_tlb_page(addr); + } + + static pte_t *__init get_pte_virt(phys_addr_t pa) +diff --git a/arch/s390/kernel/entry.h b/arch/s390/kernel/entry.h +index faca269d5f278..a44ddc2f2dec5 100644 +--- a/arch/s390/kernel/entry.h ++++ b/arch/s390/kernel/entry.h +@@ -26,6 +26,7 @@ void do_protection_exception(struct pt_regs *regs); + void do_dat_exception(struct pt_regs *regs); + void do_secure_storage_access(struct pt_regs *regs); + void do_non_secure_storage_access(struct pt_regs *regs); ++void do_secure_storage_violation(struct pt_regs *regs); + + void addressing_exception(struct pt_regs *regs); + void data_exception(struct pt_regs *regs); +diff --git a/arch/s390/kernel/pgm_check.S b/arch/s390/kernel/pgm_check.S +index 2c27907a5ffcb..9a92638360eee 100644 +--- a/arch/s390/kernel/pgm_check.S ++++ b/arch/s390/kernel/pgm_check.S +@@ -80,7 +80,7 @@ PGM_CHECK(do_dat_exception) /* 3b */ + PGM_CHECK_DEFAULT /* 3c */ + PGM_CHECK(do_secure_storage_access) /* 3d */ + PGM_CHECK(do_non_secure_storage_access) /* 3e */ +-PGM_CHECK_DEFAULT /* 3f */ ++PGM_CHECK(do_secure_storage_violation) /* 3f */ + PGM_CHECK(monitor_event_exception) /* 40 */ + PGM_CHECK_DEFAULT /* 41 */ + PGM_CHECK_DEFAULT /* 42 */ +diff --git a/arch/s390/mm/fault.c b/arch/s390/mm/fault.c +index d53c2e2ea1fd2..48d9fc5b699b4 100644 +--- a/arch/s390/mm/fault.c ++++ b/arch/s390/mm/fault.c +@@ -875,6 +875,21 @@ void do_non_secure_storage_access(struct pt_regs *regs) + } + NOKPROBE_SYMBOL(do_non_secure_storage_access); + ++void do_secure_storage_violation(struct pt_regs *regs) ++{ ++ /* ++ * Either KVM messed up the secure guest mapping or the same ++ * page is mapped into multiple secure guests. ++ * ++ * This exception is only triggered when a guest 2 is running ++ * and can therefore never occur in kernel context. ++ */ ++ printk_ratelimited(KERN_WARNING ++ "Secure storage violation in task: %s, pid %d\n", ++ current->comm, current->pid); ++ send_sig(SIGSEGV, current, 0); ++} ++ + #else + void do_secure_storage_access(struct pt_regs *regs) + { +@@ -885,4 +900,9 @@ void do_non_secure_storage_access(struct pt_regs *regs) + { + default_trap_handler(regs); + } ++ ++void do_secure_storage_violation(struct pt_regs *regs) ++{ ++ default_trap_handler(regs); ++} + #endif +diff --git a/arch/s390/pci/pci.c b/arch/s390/pci/pci.c +index 4b62d6b550246..1804230dd8d82 100644 +--- a/arch/s390/pci/pci.c ++++ b/arch/s390/pci/pci.c +@@ -668,6 +668,10 @@ EXPORT_SYMBOL_GPL(zpci_enable_device); + int zpci_disable_device(struct zpci_dev *zdev) + { + zpci_dma_exit_device(zdev); ++ /* ++ * The zPCI function may already be disabled by the platform, this is ++ * detected in clp_disable_fh() which becomes a no-op. ++ */ + return clp_disable_fh(zdev); + } + EXPORT_SYMBOL_GPL(zpci_disable_device); +diff --git a/arch/s390/pci/pci_event.c b/arch/s390/pci/pci_event.c +index 9a3a291cad432..d9ae7456dd4c8 100644 +--- a/arch/s390/pci/pci_event.c ++++ b/arch/s390/pci/pci_event.c +@@ -143,6 +143,8 @@ static void __zpci_event_availability(struct zpci_ccdf_avail *ccdf) + zpci_remove_device(zdev); + } + ++ zdev->fh = ccdf->fh; ++ zpci_disable_device(zdev); + zdev->state = ZPCI_FN_STATE_STANDBY; + if (!clp_get_state(ccdf->fid, &state) && + state == ZPCI_FN_STATE_RESERVED) { +diff --git a/arch/x86/boot/compressed/Makefile b/arch/x86/boot/compressed/Makefile +index 5a828fde7a42f..be38af7bea89d 100644 +--- a/arch/x86/boot/compressed/Makefile ++++ b/arch/x86/boot/compressed/Makefile +@@ -42,6 +42,8 @@ KBUILD_CFLAGS += $(call cc-disable-warning, gnu) + KBUILD_CFLAGS += -Wno-pointer-sign + KBUILD_CFLAGS += $(call cc-option,-fmacro-prefix-map=$(srctree)/=) + KBUILD_CFLAGS += -fno-asynchronous-unwind-tables ++# Disable relocation relaxation in case the link is not PIE. ++KBUILD_CFLAGS += $(call as-option,-Wa$(comma)-mrelax-relocations=no) + + KBUILD_AFLAGS := $(KBUILD_CFLAGS) -D__ASSEMBLY__ + GCOV_PROFILE := n +diff --git a/arch/x86/include/asm/frame.h b/arch/x86/include/asm/frame.h +index 296b346184b27..fb42659f6e988 100644 +--- a/arch/x86/include/asm/frame.h ++++ b/arch/x86/include/asm/frame.h +@@ -60,12 +60,26 @@ + #define FRAME_END "pop %" _ASM_BP "\n" + + #ifdef CONFIG_X86_64 ++ + #define ENCODE_FRAME_POINTER \ + "lea 1(%rsp), %rbp\n\t" ++ ++static inline unsigned long encode_frame_pointer(struct pt_regs *regs) ++{ ++ return (unsigned long)regs + 1; ++} ++ + #else /* !CONFIG_X86_64 */ ++ + #define ENCODE_FRAME_POINTER \ + "movl %esp, %ebp\n\t" \ + "andl $0x7fffffff, %ebp\n\t" ++ ++static inline unsigned long encode_frame_pointer(struct pt_regs *regs) ++{ ++ return (unsigned long)regs & 0x7fffffff; ++} ++ + #endif /* CONFIG_X86_64 */ + + #endif /* __ASSEMBLY__ */ +@@ -83,6 +97,11 @@ + + #define ENCODE_FRAME_POINTER + ++static inline unsigned long encode_frame_pointer(struct pt_regs *regs) ++{ ++ return 0; ++} ++ + #endif + + #define FRAME_BEGIN +diff --git a/arch/x86/kernel/process.c b/arch/x86/kernel/process.c +index fe67dbd76e517..bff502e779e44 100644 +--- a/arch/x86/kernel/process.c ++++ b/arch/x86/kernel/process.c +@@ -42,6 +42,7 @@ + #include <asm/spec-ctrl.h> + #include <asm/io_bitmap.h> + #include <asm/proto.h> ++#include <asm/frame.h> + + #include "process.h" + +@@ -133,7 +134,7 @@ int copy_thread_tls(unsigned long clone_flags, unsigned long sp, + fork_frame = container_of(childregs, struct fork_frame, regs); + frame = &fork_frame->frame; + +- frame->bp = 0; ++ frame->bp = encode_frame_pointer(childregs); + frame->ret_addr = (unsigned long) ret_from_fork; + p->thread.sp = (unsigned long) fork_frame; + p->thread.io_bitmap = NULL; +diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c +index 50c8f034c01c5..caa4fa7f42b84 100644 +--- a/block/bfq-iosched.c ++++ b/block/bfq-iosched.c +@@ -5895,18 +5895,6 @@ static void bfq_finish_requeue_request(struct request *rq) + struct bfq_queue *bfqq = RQ_BFQQ(rq); + struct bfq_data *bfqd; + +- /* +- * Requeue and finish hooks are invoked in blk-mq without +- * checking whether the involved request is actually still +- * referenced in the scheduler. To handle this fact, the +- * following two checks make this function exit in case of +- * spurious invocations, for which there is nothing to do. +- * +- * First, check whether rq has nothing to do with an elevator. +- */ +- if (unlikely(!(rq->rq_flags & RQF_ELVPRIV))) +- return; +- + /* + * rq either is not associated with any icq, or is an already + * requeued request that has not (yet) been re-inserted into +diff --git a/block/blk-mq-sched.h b/block/blk-mq-sched.h +index 126021fc3a11f..e81ca1bf6e10b 100644 +--- a/block/blk-mq-sched.h ++++ b/block/blk-mq-sched.h +@@ -66,7 +66,7 @@ static inline void blk_mq_sched_requeue_request(struct request *rq) + struct request_queue *q = rq->q; + struct elevator_queue *e = q->elevator; + +- if (e && e->type->ops.requeue_request) ++ if ((rq->rq_flags & RQF_ELVPRIV) && e && e->type->ops.requeue_request) + e->type->ops.requeue_request(rq); + } + +diff --git a/drivers/base/firmware_loader/firmware.h b/drivers/base/firmware_loader/firmware.h +index 933e2192fbe8a..d08efc77cf16a 100644 +--- a/drivers/base/firmware_loader/firmware.h ++++ b/drivers/base/firmware_loader/firmware.h +@@ -142,10 +142,12 @@ int assign_fw(struct firmware *fw, struct device *device, u32 opt_flags); + void fw_free_paged_buf(struct fw_priv *fw_priv); + int fw_grow_paged_buf(struct fw_priv *fw_priv, int pages_needed); + int fw_map_paged_buf(struct fw_priv *fw_priv); ++bool fw_is_paged_buf(struct fw_priv *fw_priv); + #else + static inline void fw_free_paged_buf(struct fw_priv *fw_priv) {} + static inline int fw_grow_paged_buf(struct fw_priv *fw_priv, int pages_needed) { return -ENXIO; } + static inline int fw_map_paged_buf(struct fw_priv *fw_priv) { return -ENXIO; } ++static inline bool fw_is_paged_buf(struct fw_priv *fw_priv) { return false; } + #endif + + #endif /* __FIRMWARE_LOADER_H */ +diff --git a/drivers/base/firmware_loader/main.c b/drivers/base/firmware_loader/main.c +index ca871b13524e2..36bf45509e0b0 100644 +--- a/drivers/base/firmware_loader/main.c ++++ b/drivers/base/firmware_loader/main.c +@@ -252,9 +252,11 @@ static void __free_fw_priv(struct kref *ref) + list_del(&fw_priv->list); + spin_unlock(&fwc->lock); + +- fw_free_paged_buf(fw_priv); /* free leftover pages */ +- if (!fw_priv->allocated_size) ++ if (fw_is_paged_buf(fw_priv)) ++ fw_free_paged_buf(fw_priv); ++ else if (!fw_priv->allocated_size) + vfree(fw_priv->data); ++ + kfree_const(fw_priv->fw_name); + kfree(fw_priv); + } +@@ -268,6 +270,11 @@ static void free_fw_priv(struct fw_priv *fw_priv) + } + + #ifdef CONFIG_FW_LOADER_PAGED_BUF ++bool fw_is_paged_buf(struct fw_priv *fw_priv) ++{ ++ return fw_priv->is_paged_buf; ++} ++ + void fw_free_paged_buf(struct fw_priv *fw_priv) + { + int i; +@@ -275,6 +282,8 @@ void fw_free_paged_buf(struct fw_priv *fw_priv) + if (!fw_priv->pages) + return; + ++ vunmap(fw_priv->data); ++ + for (i = 0; i < fw_priv->nr_pages; i++) + __free_page(fw_priv->pages[i]); + kvfree(fw_priv->pages); +@@ -328,10 +337,6 @@ int fw_map_paged_buf(struct fw_priv *fw_priv) + if (!fw_priv->data) + return -ENOMEM; + +- /* page table is no longer needed after mapping, let's free */ +- kvfree(fw_priv->pages); +- fw_priv->pages = NULL; +- + return 0; + } + #endif +diff --git a/drivers/block/loop.c b/drivers/block/loop.c +index 84433922aed16..dfc66038bef9f 100644 +--- a/drivers/block/loop.c ++++ b/drivers/block/loop.c +@@ -1114,8 +1114,6 @@ static int loop_configure(struct loop_device *lo, fmode_t mode, + mapping = file->f_mapping; + inode = mapping->host; + +- size = get_loop_size(lo, file); +- + if ((config->info.lo_flags & ~LOOP_CONFIGURE_SETTABLE_FLAGS) != 0) { + error = -EINVAL; + goto out_unlock; +@@ -1165,6 +1163,8 @@ static int loop_configure(struct loop_device *lo, fmode_t mode, + loop_update_rotational(lo); + loop_update_dio(lo); + loop_sysfs_init(lo); ++ ++ size = get_loop_size(lo, file); + loop_set_size(lo, size); + + set_blocksize(bdev, S_ISBLK(inode->i_mode) ? +diff --git a/drivers/clk/davinci/pll.c b/drivers/clk/davinci/pll.c +index 8a23d5dfd1f8d..5f063e1be4b14 100644 +--- a/drivers/clk/davinci/pll.c ++++ b/drivers/clk/davinci/pll.c +@@ -491,7 +491,7 @@ struct clk *davinci_pll_clk_register(struct device *dev, + parent_name = postdiv_name; + } + +- pllen = kzalloc(sizeof(*pllout), GFP_KERNEL); ++ pllen = kzalloc(sizeof(*pllen), GFP_KERNEL); + if (!pllen) { + ret = -ENOMEM; + goto err_unregister_postdiv; +diff --git a/drivers/clk/rockchip/clk-rk3228.c b/drivers/clk/rockchip/clk-rk3228.c +index d7243c09cc843..47d6482dda9df 100644 +--- a/drivers/clk/rockchip/clk-rk3228.c ++++ b/drivers/clk/rockchip/clk-rk3228.c +@@ -137,7 +137,7 @@ PNAME(mux_usb480m_p) = { "usb480m_phy", "xin24m" }; + PNAME(mux_hdmiphy_p) = { "hdmiphy_phy", "xin24m" }; + PNAME(mux_aclk_cpu_src_p) = { "cpll_aclk_cpu", "gpll_aclk_cpu", "hdmiphy_aclk_cpu" }; + +-PNAME(mux_pll_src_4plls_p) = { "cpll", "gpll", "hdmiphy" "usb480m" }; ++PNAME(mux_pll_src_4plls_p) = { "cpll", "gpll", "hdmiphy", "usb480m" }; + PNAME(mux_pll_src_3plls_p) = { "cpll", "gpll", "hdmiphy" }; + PNAME(mux_pll_src_2plls_p) = { "cpll", "gpll" }; + PNAME(mux_sclk_hdmi_cec_p) = { "cpll", "gpll", "xin24m" }; +diff --git a/drivers/dax/super.c b/drivers/dax/super.c +index 8e32345be0f74..af95d7e723f76 100644 +--- a/drivers/dax/super.c ++++ b/drivers/dax/super.c +@@ -318,11 +318,15 @@ EXPORT_SYMBOL_GPL(dax_direct_access); + bool dax_supported(struct dax_device *dax_dev, struct block_device *bdev, + int blocksize, sector_t start, sector_t len) + { ++ if (!dax_dev) ++ return false; ++ + if (!dax_alive(dax_dev)) + return false; + + return dax_dev->ops->dax_supported(dax_dev, bdev, blocksize, start, len); + } ++EXPORT_SYMBOL_GPL(dax_supported); + + size_t dax_copy_from_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr, + size_t bytes, struct iov_iter *i) +diff --git a/drivers/firmware/efi/efibc.c b/drivers/firmware/efi/efibc.c +index 35dccc88ac0af..15a47539dc563 100644 +--- a/drivers/firmware/efi/efibc.c ++++ b/drivers/firmware/efi/efibc.c +@@ -84,7 +84,7 @@ static int __init efibc_init(void) + { + int ret; + +- if (!efi_enabled(EFI_RUNTIME_SERVICES)) ++ if (!efivars_kobject() || !efivar_supports_writes()) + return -ENODEV; + + ret = register_reboot_notifier(&efibc_reboot_notifier); +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +index e9c4867abeffb..aa1e0f0550835 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +@@ -1287,7 +1287,7 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q, + if (q->properties.is_active) { + increment_queue_count(dqm, q->properties.type); + +- retval = execute_queues_cpsch(dqm, ++ execute_queues_cpsch(dqm, + KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES, 0); + } + +diff --git a/drivers/gpu/drm/i915/gem/i915_gem_context.c b/drivers/gpu/drm/i915/gem/i915_gem_context.c +index 30c229fcb4046..c5c549177d726 100644 +--- a/drivers/gpu/drm/i915/gem/i915_gem_context.c ++++ b/drivers/gpu/drm/i915/gem/i915_gem_context.c +@@ -440,29 +440,36 @@ static bool __cancel_engine(struct intel_engine_cs *engine) + return __reset_engine(engine); + } + +-static struct intel_engine_cs *__active_engine(struct i915_request *rq) ++static bool ++__active_engine(struct i915_request *rq, struct intel_engine_cs **active) + { + struct intel_engine_cs *engine, *locked; ++ bool ret = false; + + /* + * Serialise with __i915_request_submit() so that it sees + * is-banned?, or we know the request is already inflight. ++ * ++ * Note that rq->engine is unstable, and so we double ++ * check that we have acquired the lock on the final engine. + */ + locked = READ_ONCE(rq->engine); + spin_lock_irq(&locked->active.lock); + while (unlikely(locked != (engine = READ_ONCE(rq->engine)))) { + spin_unlock(&locked->active.lock); +- spin_lock(&engine->active.lock); + locked = engine; ++ spin_lock(&locked->active.lock); + } + +- engine = NULL; +- if (i915_request_is_active(rq) && rq->fence.error != -EIO) +- engine = rq->engine; ++ if (!i915_request_completed(rq)) { ++ if (i915_request_is_active(rq) && rq->fence.error != -EIO) ++ *active = locked; ++ ret = true; ++ } + + spin_unlock_irq(&locked->active.lock); + +- return engine; ++ return ret; + } + + static struct intel_engine_cs *active_engine(struct intel_context *ce) +@@ -473,17 +480,16 @@ static struct intel_engine_cs *active_engine(struct intel_context *ce) + if (!ce->timeline) + return NULL; + +- mutex_lock(&ce->timeline->mutex); +- list_for_each_entry_reverse(rq, &ce->timeline->requests, link) { +- if (i915_request_completed(rq)) +- break; ++ rcu_read_lock(); ++ list_for_each_entry_rcu(rq, &ce->timeline->requests, link) { ++ if (i915_request_is_active(rq) && i915_request_completed(rq)) ++ continue; + + /* Check with the backend if the request is inflight */ +- engine = __active_engine(rq); +- if (engine) ++ if (__active_engine(rq, &engine)) + break; + } +- mutex_unlock(&ce->timeline->mutex); ++ rcu_read_unlock(); + + return engine; + } +@@ -714,6 +720,7 @@ __create_context(struct drm_i915_private *i915) + ctx->i915 = i915; + ctx->sched.priority = I915_USER_PRIORITY(I915_PRIORITY_NORMAL); + mutex_init(&ctx->mutex); ++ INIT_LIST_HEAD(&ctx->link); + + spin_lock_init(&ctx->stale.lock); + INIT_LIST_HEAD(&ctx->stale.engines); +@@ -740,10 +747,6 @@ __create_context(struct drm_i915_private *i915) + for (i = 0; i < ARRAY_SIZE(ctx->hang_timestamp); i++) + ctx->hang_timestamp[i] = jiffies - CONTEXT_FAST_HANG_JIFFIES; + +- spin_lock(&i915->gem.contexts.lock); +- list_add_tail(&ctx->link, &i915->gem.contexts.list); +- spin_unlock(&i915->gem.contexts.lock); +- + return ctx; + + err_free: +@@ -931,6 +934,7 @@ static int gem_context_register(struct i915_gem_context *ctx, + struct drm_i915_file_private *fpriv, + u32 *id) + { ++ struct drm_i915_private *i915 = ctx->i915; + struct i915_address_space *vm; + int ret; + +@@ -949,8 +953,16 @@ static int gem_context_register(struct i915_gem_context *ctx, + /* And finally expose ourselves to userspace via the idr */ + ret = xa_alloc(&fpriv->context_xa, id, ctx, xa_limit_32b, GFP_KERNEL); + if (ret) +- put_pid(fetch_and_zero(&ctx->pid)); ++ goto err_pid; ++ ++ spin_lock(&i915->gem.contexts.lock); ++ list_add_tail(&ctx->link, &i915->gem.contexts.list); ++ spin_unlock(&i915->gem.contexts.lock); ++ ++ return 0; + ++err_pid: ++ put_pid(fetch_and_zero(&ctx->pid)); + return ret; + } + +diff --git a/drivers/gpu/drm/i915/i915_sw_fence.c b/drivers/gpu/drm/i915/i915_sw_fence.c +index 295b9829e2da5..4cd2038cbe359 100644 +--- a/drivers/gpu/drm/i915/i915_sw_fence.c ++++ b/drivers/gpu/drm/i915/i915_sw_fence.c +@@ -164,9 +164,13 @@ static void __i915_sw_fence_wake_up_all(struct i915_sw_fence *fence, + + do { + list_for_each_entry_safe(pos, next, &x->head, entry) { +- pos->func(pos, +- TASK_NORMAL, fence->error, +- &extra); ++ int wake_flags; ++ ++ wake_flags = fence->error; ++ if (pos->func == autoremove_wake_function) ++ wake_flags = 0; ++ ++ pos->func(pos, TASK_NORMAL, wake_flags, &extra); + } + + if (list_empty(&extra)) +diff --git a/drivers/gpu/drm/mediatek/mtk_drm_crtc.c b/drivers/gpu/drm/mediatek/mtk_drm_crtc.c +index 7cd8f415fd029..d8b43500f12d1 100644 +--- a/drivers/gpu/drm/mediatek/mtk_drm_crtc.c ++++ b/drivers/gpu/drm/mediatek/mtk_drm_crtc.c +@@ -834,13 +834,19 @@ int mtk_drm_crtc_create(struct drm_device *drm_dev, + drm_crtc_index(&mtk_crtc->base)); + mtk_crtc->cmdq_client = NULL; + } +- ret = of_property_read_u32_index(priv->mutex_node, +- "mediatek,gce-events", +- drm_crtc_index(&mtk_crtc->base), +- &mtk_crtc->cmdq_event); +- if (ret) +- dev_dbg(dev, "mtk_crtc %d failed to get mediatek,gce-events property\n", +- drm_crtc_index(&mtk_crtc->base)); ++ ++ if (mtk_crtc->cmdq_client) { ++ ret = of_property_read_u32_index(priv->mutex_node, ++ "mediatek,gce-events", ++ drm_crtc_index(&mtk_crtc->base), ++ &mtk_crtc->cmdq_event); ++ if (ret) { ++ dev_dbg(dev, "mtk_crtc %d failed to get mediatek,gce-events property\n", ++ drm_crtc_index(&mtk_crtc->base)); ++ cmdq_mbox_destroy(mtk_crtc->cmdq_client); ++ mtk_crtc->cmdq_client = NULL; ++ } ++ } + #endif + return 0; + } +diff --git a/drivers/gpu/drm/mediatek/mtk_drm_ddp_comp.c b/drivers/gpu/drm/mediatek/mtk_drm_ddp_comp.c +index 57c88de9a3293..526648885b97e 100644 +--- a/drivers/gpu/drm/mediatek/mtk_drm_ddp_comp.c ++++ b/drivers/gpu/drm/mediatek/mtk_drm_ddp_comp.c +@@ -496,6 +496,7 @@ int mtk_ddp_comp_init(struct device *dev, struct device_node *node, + #if IS_REACHABLE(CONFIG_MTK_CMDQ) + if (of_address_to_resource(node, 0, &res) != 0) { + dev_err(dev, "Missing reg in %s node\n", node->full_name); ++ put_device(&larb_pdev->dev); + return -EINVAL; + } + comp->regs_pa = res.start; +diff --git a/drivers/gpu/drm/mediatek/mtk_drm_drv.c b/drivers/gpu/drm/mediatek/mtk_drm_drv.c +index 040a8f393fe24..b77dc36be4224 100644 +--- a/drivers/gpu/drm/mediatek/mtk_drm_drv.c ++++ b/drivers/gpu/drm/mediatek/mtk_drm_drv.c +@@ -165,7 +165,7 @@ static int mtk_drm_kms_init(struct drm_device *drm) + + ret = drmm_mode_config_init(drm); + if (ret) +- return ret; ++ goto put_mutex_dev; + + drm->mode_config.min_width = 64; + drm->mode_config.min_height = 64; +@@ -182,7 +182,7 @@ static int mtk_drm_kms_init(struct drm_device *drm) + + ret = component_bind_all(drm->dev, drm); + if (ret) +- return ret; ++ goto put_mutex_dev; + + /* + * We currently support two fixed data streams, each optional, +@@ -229,7 +229,7 @@ static int mtk_drm_kms_init(struct drm_device *drm) + } + if (!dma_dev->dma_parms) { + ret = -ENOMEM; +- goto err_component_unbind; ++ goto put_dma_dev; + } + + ret = dma_set_max_seg_size(dma_dev, (unsigned int)DMA_BIT_MASK(32)); +@@ -256,9 +256,12 @@ static int mtk_drm_kms_init(struct drm_device *drm) + err_unset_dma_parms: + if (private->dma_parms_allocated) + dma_dev->dma_parms = NULL; ++put_dma_dev: ++ put_device(private->dma_dev); + err_component_unbind: + component_unbind_all(drm->dev, drm); +- ++put_mutex_dev: ++ put_device(private->mutex_dev); + return ret; + } + +@@ -544,8 +547,13 @@ err_pm: + pm_runtime_disable(dev); + err_node: + of_node_put(private->mutex_node); +- for (i = 0; i < DDP_COMPONENT_ID_MAX; i++) ++ for (i = 0; i < DDP_COMPONENT_ID_MAX; i++) { + of_node_put(private->comp_node[i]); ++ if (private->ddp_comp[i]) { ++ put_device(private->ddp_comp[i]->larb_dev); ++ private->ddp_comp[i] = NULL; ++ } ++ } + return ret; + } + +diff --git a/drivers/gpu/drm/mediatek/mtk_dsi.c b/drivers/gpu/drm/mediatek/mtk_dsi.c +index 02ac55c13a80b..ee011a0633841 100644 +--- a/drivers/gpu/drm/mediatek/mtk_dsi.c ++++ b/drivers/gpu/drm/mediatek/mtk_dsi.c +@@ -470,14 +470,13 @@ static void mtk_dsi_config_vdo_timing(struct mtk_dsi *dsi) + horizontal_sync_active_byte = (vm->hsync_len * dsi_tmp_buf_bpp - 10); + + if (dsi->mode_flags & MIPI_DSI_MODE_VIDEO_SYNC_PULSE) +- horizontal_backporch_byte = +- (vm->hback_porch * dsi_tmp_buf_bpp - 10); ++ horizontal_backporch_byte = vm->hback_porch * dsi_tmp_buf_bpp; + else +- horizontal_backporch_byte = ((vm->hback_porch + vm->hsync_len) * +- dsi_tmp_buf_bpp - 10); ++ horizontal_backporch_byte = (vm->hback_porch + vm->hsync_len) * ++ dsi_tmp_buf_bpp; + + data_phy_cycles = timing->lpx + timing->da_hs_prepare + +- timing->da_hs_zero + timing->da_hs_exit + 3; ++ timing->da_hs_zero + timing->da_hs_exit; + + if (dsi->mode_flags & MIPI_DSI_MODE_VIDEO_BURST) { + if ((vm->hfront_porch + vm->hback_porch) * dsi_tmp_buf_bpp > +diff --git a/drivers/gpu/drm/mediatek/mtk_hdmi.c b/drivers/gpu/drm/mediatek/mtk_hdmi.c +index 1eebe310470af..a9704822c0334 100644 +--- a/drivers/gpu/drm/mediatek/mtk_hdmi.c ++++ b/drivers/gpu/drm/mediatek/mtk_hdmi.c +@@ -1507,25 +1507,30 @@ static int mtk_hdmi_dt_parse_pdata(struct mtk_hdmi *hdmi, + dev_err(dev, + "Failed to get system configuration registers: %d\n", + ret); +- return ret; ++ goto put_device; + } + hdmi->sys_regmap = regmap; + + mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); + hdmi->regs = devm_ioremap_resource(dev, mem); +- if (IS_ERR(hdmi->regs)) +- return PTR_ERR(hdmi->regs); ++ if (IS_ERR(hdmi->regs)) { ++ ret = PTR_ERR(hdmi->regs); ++ goto put_device; ++ } + + remote = of_graph_get_remote_node(np, 1, 0); +- if (!remote) +- return -EINVAL; ++ if (!remote) { ++ ret = -EINVAL; ++ goto put_device; ++ } + + if (!of_device_is_compatible(remote, "hdmi-connector")) { + hdmi->next_bridge = of_drm_find_bridge(remote); + if (!hdmi->next_bridge) { + dev_err(dev, "Waiting for external bridge\n"); + of_node_put(remote); +- return -EPROBE_DEFER; ++ ret = -EPROBE_DEFER; ++ goto put_device; + } + } + +@@ -1534,7 +1539,8 @@ static int mtk_hdmi_dt_parse_pdata(struct mtk_hdmi *hdmi, + dev_err(dev, "Failed to find ddc-i2c-bus node in %pOF\n", + remote); + of_node_put(remote); +- return -EINVAL; ++ ret = -EINVAL; ++ goto put_device; + } + of_node_put(remote); + +@@ -1542,10 +1548,14 @@ static int mtk_hdmi_dt_parse_pdata(struct mtk_hdmi *hdmi, + of_node_put(i2c_np); + if (!hdmi->ddc_adpt) { + dev_err(dev, "Failed to get ddc i2c adapter by node\n"); +- return -EINVAL; ++ ret = -EINVAL; ++ goto put_device; + } + + return 0; ++put_device: ++ put_device(hdmi->cec_dev); ++ return ret; + } + + /* +diff --git a/drivers/hv/channel_mgmt.c b/drivers/hv/channel_mgmt.c +index 417a95e5094dd..af7832e131674 100644 +--- a/drivers/hv/channel_mgmt.c ++++ b/drivers/hv/channel_mgmt.c +@@ -750,7 +750,7 @@ static void vmbus_wait_for_unload(void) + void *page_addr; + struct hv_message *msg; + struct vmbus_channel_message_header *hdr; +- u32 message_type; ++ u32 message_type, i; + + /* + * CHANNELMSG_UNLOAD_RESPONSE is always delivered to the CPU which was +@@ -760,8 +760,11 @@ static void vmbus_wait_for_unload(void) + * functional and vmbus_unload_response() will complete + * vmbus_connection.unload_event. If not, the last thing we can do is + * read message pages for all CPUs directly. ++ * ++ * Wait no more than 10 seconds so that the panic path can't get ++ * hung forever in case the response message isn't seen. + */ +- while (1) { ++ for (i = 0; i < 1000; i++) { + if (completion_done(&vmbus_connection.unload_event)) + break; + +diff --git a/drivers/hv/vmbus_drv.c b/drivers/hv/vmbus_drv.c +index d69f4efa37198..dacdd8d2eb1b3 100644 +--- a/drivers/hv/vmbus_drv.c ++++ b/drivers/hv/vmbus_drv.c +@@ -2383,7 +2383,10 @@ static int vmbus_bus_suspend(struct device *dev) + if (atomic_read(&vmbus_connection.nr_chan_close_on_suspend) > 0) + wait_for_completion(&vmbus_connection.ready_for_suspend_event); + +- WARN_ON(atomic_read(&vmbus_connection.nr_chan_fixup_on_resume) != 0); ++ if (atomic_read(&vmbus_connection.nr_chan_fixup_on_resume) != 0) { ++ pr_err("Can not suspend due to a previous failed resuming\n"); ++ return -EBUSY; ++ } + + mutex_lock(&vmbus_connection.channel_mutex); + +@@ -2459,7 +2462,9 @@ static int vmbus_bus_resume(struct device *dev) + + vmbus_request_offers(); + +- wait_for_completion(&vmbus_connection.ready_for_resume_event); ++ if (wait_for_completion_timeout( ++ &vmbus_connection.ready_for_resume_event, 10 * HZ) == 0) ++ pr_err("Some vmbus device is missing after suspending?\n"); + + /* Reset the event for the next suspend. */ + reinit_completion(&vmbus_connection.ready_for_suspend_event); +diff --git a/drivers/i2c/algos/i2c-algo-pca.c b/drivers/i2c/algos/i2c-algo-pca.c +index 388978775be04..edc6985c696f0 100644 +--- a/drivers/i2c/algos/i2c-algo-pca.c ++++ b/drivers/i2c/algos/i2c-algo-pca.c +@@ -41,8 +41,22 @@ static void pca_reset(struct i2c_algo_pca_data *adap) + pca_outw(adap, I2C_PCA_INDPTR, I2C_PCA_IPRESET); + pca_outw(adap, I2C_PCA_IND, 0xA5); + pca_outw(adap, I2C_PCA_IND, 0x5A); ++ ++ /* ++ * After a reset we need to re-apply any configuration ++ * (calculated in pca_init) to get the bus in a working state. ++ */ ++ pca_outw(adap, I2C_PCA_INDPTR, I2C_PCA_IMODE); ++ pca_outw(adap, I2C_PCA_IND, adap->bus_settings.mode); ++ pca_outw(adap, I2C_PCA_INDPTR, I2C_PCA_ISCLL); ++ pca_outw(adap, I2C_PCA_IND, adap->bus_settings.tlow); ++ pca_outw(adap, I2C_PCA_INDPTR, I2C_PCA_ISCLH); ++ pca_outw(adap, I2C_PCA_IND, adap->bus_settings.thi); ++ ++ pca_set_con(adap, I2C_PCA_CON_ENSIO); + } else { + adap->reset_chip(adap->data); ++ pca_set_con(adap, I2C_PCA_CON_ENSIO | adap->bus_settings.clock_freq); + } + } + +@@ -423,13 +437,14 @@ static int pca_init(struct i2c_adapter *adap) + " Use the nominal frequency.\n", adap->name); + } + +- pca_reset(pca_data); +- + clock = pca_clock(pca_data); + printk(KERN_INFO "%s: Clock frequency is %dkHz\n", + adap->name, freqs[clock]); + +- pca_set_con(pca_data, I2C_PCA_CON_ENSIO | clock); ++ /* Store settings as these will be needed when the PCA chip is reset */ ++ pca_data->bus_settings.clock_freq = clock; ++ ++ pca_reset(pca_data); + } else { + int clock; + int mode; +@@ -496,19 +511,15 @@ static int pca_init(struct i2c_adapter *adap) + thi = tlow * min_thi / min_tlow; + } + ++ /* Store settings as these will be needed when the PCA chip is reset */ ++ pca_data->bus_settings.mode = mode; ++ pca_data->bus_settings.tlow = tlow; ++ pca_data->bus_settings.thi = thi; ++ + pca_reset(pca_data); + + printk(KERN_INFO + "%s: Clock frequency is %dHz\n", adap->name, clock * 100); +- +- pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_IMODE); +- pca_outw(pca_data, I2C_PCA_IND, mode); +- pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ISCLL); +- pca_outw(pca_data, I2C_PCA_IND, tlow); +- pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ISCLH); +- pca_outw(pca_data, I2C_PCA_IND, thi); +- +- pca_set_con(pca_data, I2C_PCA_CON_ENSIO); + } + udelay(500); /* 500 us for oscillator to stabilise */ + +diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c +index f206e28af5831..3843eabeddda3 100644 +--- a/drivers/i2c/busses/i2c-i801.c ++++ b/drivers/i2c/busses/i2c-i801.c +@@ -1706,6 +1706,16 @@ static inline int i801_acpi_probe(struct i801_priv *priv) { return 0; } + static inline void i801_acpi_remove(struct i801_priv *priv) { } + #endif + ++static unsigned char i801_setup_hstcfg(struct i801_priv *priv) ++{ ++ unsigned char hstcfg = priv->original_hstcfg; ++ ++ hstcfg &= ~SMBHSTCFG_I2C_EN; /* SMBus timing */ ++ hstcfg |= SMBHSTCFG_HST_EN; ++ pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hstcfg); ++ return hstcfg; ++} ++ + static int i801_probe(struct pci_dev *dev, const struct pci_device_id *id) + { + unsigned char temp; +@@ -1826,14 +1836,10 @@ static int i801_probe(struct pci_dev *dev, const struct pci_device_id *id) + return err; + } + +- pci_read_config_byte(priv->pci_dev, SMBHSTCFG, &temp); +- priv->original_hstcfg = temp; +- temp &= ~SMBHSTCFG_I2C_EN; /* SMBus timing */ +- if (!(temp & SMBHSTCFG_HST_EN)) { ++ pci_read_config_byte(priv->pci_dev, SMBHSTCFG, &priv->original_hstcfg); ++ temp = i801_setup_hstcfg(priv); ++ if (!(priv->original_hstcfg & SMBHSTCFG_HST_EN)) + dev_info(&dev->dev, "Enabling SMBus device\n"); +- temp |= SMBHSTCFG_HST_EN; +- } +- pci_write_config_byte(priv->pci_dev, SMBHSTCFG, temp); + + if (temp & SMBHSTCFG_SMB_SMI_EN) { + dev_dbg(&dev->dev, "SMBus using interrupt SMI#\n"); +@@ -1959,6 +1965,7 @@ static int i801_resume(struct device *dev) + { + struct i801_priv *priv = dev_get_drvdata(dev); + ++ i801_setup_hstcfg(priv); + i801_enable_host_notify(&priv->adapter); + + return 0; +diff --git a/drivers/i2c/busses/i2c-mt65xx.c b/drivers/i2c/busses/i2c-mt65xx.c +index deef69e569062..b099139cbb91e 100644 +--- a/drivers/i2c/busses/i2c-mt65xx.c ++++ b/drivers/i2c/busses/i2c-mt65xx.c +@@ -658,8 +658,8 @@ static int mtk_i2c_calculate_speed(struct mtk_i2c *i2c, unsigned int clk_src, + unsigned int cnt_mul; + int ret = -EINVAL; + +- if (target_speed > I2C_MAX_FAST_MODE_PLUS_FREQ) +- target_speed = I2C_MAX_FAST_MODE_PLUS_FREQ; ++ if (target_speed > I2C_MAX_HIGH_SPEED_MODE_FREQ) ++ target_speed = I2C_MAX_HIGH_SPEED_MODE_FREQ; + + max_step_cnt = mtk_i2c_max_step_cnt(target_speed); + base_step_cnt = max_step_cnt; +diff --git a/drivers/i2c/busses/i2c-mxs.c b/drivers/i2c/busses/i2c-mxs.c +index 9587347447f0f..c4b08a9244614 100644 +--- a/drivers/i2c/busses/i2c-mxs.c ++++ b/drivers/i2c/busses/i2c-mxs.c +@@ -25,6 +25,7 @@ + #include <linux/of_device.h> + #include <linux/dma-mapping.h> + #include <linux/dmaengine.h> ++#include <linux/dma/mxs-dma.h> + + #define DRIVER_NAME "mxs-i2c" + +@@ -200,7 +201,8 @@ static int mxs_i2c_dma_setup_xfer(struct i2c_adapter *adap, + dma_map_sg(i2c->dev, &i2c->sg_io[0], 1, DMA_TO_DEVICE); + desc = dmaengine_prep_slave_sg(i2c->dmach, &i2c->sg_io[0], 1, + DMA_MEM_TO_DEV, +- DMA_PREP_INTERRUPT | DMA_CTRL_ACK); ++ DMA_PREP_INTERRUPT | ++ MXS_DMA_CTRL_WAIT4END); + if (!desc) { + dev_err(i2c->dev, + "Failed to get DMA data write descriptor.\n"); +@@ -228,7 +230,8 @@ static int mxs_i2c_dma_setup_xfer(struct i2c_adapter *adap, + dma_map_sg(i2c->dev, &i2c->sg_io[1], 1, DMA_FROM_DEVICE); + desc = dmaengine_prep_slave_sg(i2c->dmach, &i2c->sg_io[1], 1, + DMA_DEV_TO_MEM, +- DMA_PREP_INTERRUPT | DMA_CTRL_ACK); ++ DMA_PREP_INTERRUPT | ++ MXS_DMA_CTRL_WAIT4END); + if (!desc) { + dev_err(i2c->dev, + "Failed to get DMA data write descriptor.\n"); +@@ -260,7 +263,8 @@ static int mxs_i2c_dma_setup_xfer(struct i2c_adapter *adap, + dma_map_sg(i2c->dev, i2c->sg_io, 2, DMA_TO_DEVICE); + desc = dmaengine_prep_slave_sg(i2c->dmach, i2c->sg_io, 2, + DMA_MEM_TO_DEV, +- DMA_PREP_INTERRUPT | DMA_CTRL_ACK); ++ DMA_PREP_INTERRUPT | ++ MXS_DMA_CTRL_WAIT4END); + if (!desc) { + dev_err(i2c->dev, + "Failed to get DMA data write descriptor.\n"); +diff --git a/drivers/infiniband/hw/bnxt_re/qplib_sp.c b/drivers/infiniband/hw/bnxt_re/qplib_sp.c +index 4cd475ea97a24..64d44f51db4b6 100644 +--- a/drivers/infiniband/hw/bnxt_re/qplib_sp.c ++++ b/drivers/infiniband/hw/bnxt_re/qplib_sp.c +@@ -149,7 +149,7 @@ int bnxt_qplib_get_dev_attr(struct bnxt_qplib_rcfw *rcfw, + attr->max_inline_data = le32_to_cpu(sb->max_inline_data); + attr->l2_db_size = (sb->l2_db_space_size + 1) * + (0x01 << RCFW_DBR_BASE_PAGE_SHIFT); +- attr->max_sgid = le32_to_cpu(sb->max_gid); ++ attr->max_sgid = BNXT_QPLIB_NUM_GIDS_SUPPORTED; + + bnxt_qplib_query_version(rcfw, attr->fw_ver); + +diff --git a/drivers/infiniband/hw/bnxt_re/qplib_sp.h b/drivers/infiniband/hw/bnxt_re/qplib_sp.h +index 6404f0da10517..967890cd81f27 100644 +--- a/drivers/infiniband/hw/bnxt_re/qplib_sp.h ++++ b/drivers/infiniband/hw/bnxt_re/qplib_sp.h +@@ -47,6 +47,7 @@ + struct bnxt_qplib_dev_attr { + #define FW_VER_ARR_LEN 4 + u8 fw_ver[FW_VER_ARR_LEN]; ++#define BNXT_QPLIB_NUM_GIDS_SUPPORTED 256 + u16 max_sgid; + u16 max_mrw; + u32 max_qp; +diff --git a/drivers/input/mouse/trackpoint.c b/drivers/input/mouse/trackpoint.c +index 3eefee2ee2a12..854d5e7587241 100644 +--- a/drivers/input/mouse/trackpoint.c ++++ b/drivers/input/mouse/trackpoint.c +@@ -17,10 +17,12 @@ + #include "trackpoint.h" + + static const char * const trackpoint_variants[] = { +- [TP_VARIANT_IBM] = "IBM", +- [TP_VARIANT_ALPS] = "ALPS", +- [TP_VARIANT_ELAN] = "Elan", +- [TP_VARIANT_NXP] = "NXP", ++ [TP_VARIANT_IBM] = "IBM", ++ [TP_VARIANT_ALPS] = "ALPS", ++ [TP_VARIANT_ELAN] = "Elan", ++ [TP_VARIANT_NXP] = "NXP", ++ [TP_VARIANT_JYT_SYNAPTICS] = "JYT_Synaptics", ++ [TP_VARIANT_SYNAPTICS] = "Synaptics", + }; + + /* +diff --git a/drivers/input/mouse/trackpoint.h b/drivers/input/mouse/trackpoint.h +index 5cb93ed260856..eb5412904fe07 100644 +--- a/drivers/input/mouse/trackpoint.h ++++ b/drivers/input/mouse/trackpoint.h +@@ -24,10 +24,12 @@ + * 0x01 was the original IBM trackpoint, others implement very limited + * subset of trackpoint features. + */ +-#define TP_VARIANT_IBM 0x01 +-#define TP_VARIANT_ALPS 0x02 +-#define TP_VARIANT_ELAN 0x03 +-#define TP_VARIANT_NXP 0x04 ++#define TP_VARIANT_IBM 0x01 ++#define TP_VARIANT_ALPS 0x02 ++#define TP_VARIANT_ELAN 0x03 ++#define TP_VARIANT_NXP 0x04 ++#define TP_VARIANT_JYT_SYNAPTICS 0x05 ++#define TP_VARIANT_SYNAPTICS 0x06 + + /* + * Commands +diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h +index 7d7f737027264..37fb9aa88f9c3 100644 +--- a/drivers/input/serio/i8042-x86ia64io.h ++++ b/drivers/input/serio/i8042-x86ia64io.h +@@ -548,6 +548,14 @@ static const struct dmi_system_id __initconst i8042_dmi_nomux_table[] = { + DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5738"), + }, + }, ++ { ++ /* Entroware Proteus */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Entroware"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "Proteus"), ++ DMI_MATCH(DMI_PRODUCT_VERSION, "EL07R4"), ++ }, ++ }, + { } + }; + +@@ -676,6 +684,14 @@ static const struct dmi_system_id __initconst i8042_dmi_reset_table[] = { + DMI_MATCH(DMI_PRODUCT_NAME, "33474HU"), + }, + }, ++ { ++ /* Entroware Proteus */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Entroware"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "Proteus"), ++ DMI_MATCH(DMI_PRODUCT_VERSION, "EL07R4"), ++ }, ++ }, + { } + }; + +diff --git a/drivers/interconnect/core.c b/drivers/interconnect/core.c +index 9e1ab701785c7..0162a9af93237 100644 +--- a/drivers/interconnect/core.c ++++ b/drivers/interconnect/core.c +@@ -55,12 +55,18 @@ static int icc_summary_show(struct seq_file *s, void *data) + + icc_summary_show_one(s, n); + hlist_for_each_entry(r, &n->req_list, req_node) { ++ u32 avg_bw = 0, peak_bw = 0; ++ + if (!r->dev) + continue; + ++ if (r->enabled) { ++ avg_bw = r->avg_bw; ++ peak_bw = r->peak_bw; ++ } ++ + seq_printf(s, " %-27s %12u %12u %12u\n", +- dev_name(r->dev), r->tag, r->avg_bw, +- r->peak_bw); ++ dev_name(r->dev), r->tag, avg_bw, peak_bw); + } + } + } +diff --git a/drivers/iommu/amd/iommu.c b/drivers/iommu/amd/iommu.c +index 37c74c842f3a3..a51dcf26b09f2 100644 +--- a/drivers/iommu/amd/iommu.c ++++ b/drivers/iommu/amd/iommu.c +@@ -3831,14 +3831,18 @@ int amd_iommu_activate_guest_mode(void *data) + { + struct amd_ir_data *ir_data = (struct amd_ir_data *)data; + struct irte_ga *entry = (struct irte_ga *) ir_data->entry; ++ u64 valid; + + if (!AMD_IOMMU_GUEST_IR_VAPIC(amd_iommu_guest_ir) || + !entry || entry->lo.fields_vapic.guest_mode) + return 0; + ++ valid = entry->lo.fields_vapic.valid; ++ + entry->lo.val = 0; + entry->hi.val = 0; + ++ entry->lo.fields_vapic.valid = valid; + entry->lo.fields_vapic.guest_mode = 1; + entry->lo.fields_vapic.ga_log_intr = 1; + entry->hi.fields.ga_root_ptr = ir_data->ga_root_ptr; +@@ -3855,12 +3859,14 @@ int amd_iommu_deactivate_guest_mode(void *data) + struct amd_ir_data *ir_data = (struct amd_ir_data *)data; + struct irte_ga *entry = (struct irte_ga *) ir_data->entry; + struct irq_cfg *cfg = ir_data->cfg; +- u64 valid = entry->lo.fields_remap.valid; ++ u64 valid; + + if (!AMD_IOMMU_GUEST_IR_VAPIC(amd_iommu_guest_ir) || + !entry || !entry->lo.fields_vapic.guest_mode) + return 0; + ++ valid = entry->lo.fields_remap.valid; ++ + entry->lo.val = 0; + entry->hi.val = 0; + +diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c +index 8277b959e00bd..6a4057b844e24 100644 +--- a/drivers/md/dm-table.c ++++ b/drivers/md/dm-table.c +@@ -865,10 +865,14 @@ EXPORT_SYMBOL_GPL(dm_table_set_type); + int device_supports_dax(struct dm_target *ti, struct dm_dev *dev, + sector_t start, sector_t len, void *data) + { +- int blocksize = *(int *) data; ++ int blocksize = *(int *) data, id; ++ bool rc; + +- return generic_fsdax_supported(dev->dax_dev, dev->bdev, blocksize, +- start, len); ++ id = dax_read_lock(); ++ rc = dax_supported(dev->dax_dev, dev->bdev, blocksize, start, len); ++ dax_read_unlock(id); ++ ++ return rc; + } + + /* Check devices support synchronous DAX */ +diff --git a/drivers/md/dm.c b/drivers/md/dm.c +index 88b391ff9bea7..49c758fef8cb6 100644 +--- a/drivers/md/dm.c ++++ b/drivers/md/dm.c +@@ -1136,15 +1136,16 @@ static bool dm_dax_supported(struct dax_device *dax_dev, struct block_device *bd + { + struct mapped_device *md = dax_get_private(dax_dev); + struct dm_table *map; ++ bool ret = false; + int srcu_idx; +- bool ret; + + map = dm_get_live_table(md, &srcu_idx); + if (!map) +- return false; ++ goto out; + + ret = dm_table_supports_dax(map, device_supports_dax, &blocksize); + ++out: + dm_put_live_table(md, srcu_idx); + + return ret; +diff --git a/drivers/misc/habanalabs/debugfs.c b/drivers/misc/habanalabs/debugfs.c +index 6c2b9cf45e831..650922061bdc7 100644 +--- a/drivers/misc/habanalabs/debugfs.c ++++ b/drivers/misc/habanalabs/debugfs.c +@@ -982,7 +982,7 @@ static ssize_t hl_clk_gate_read(struct file *f, char __user *buf, + return 0; + + sprintf(tmp_buf, "0x%llx\n", hdev->clock_gating_mask); +- rc = simple_read_from_buffer(buf, strlen(tmp_buf) + 1, ppos, tmp_buf, ++ rc = simple_read_from_buffer(buf, count, ppos, tmp_buf, + strlen(tmp_buf) + 1); + + return rc; +diff --git a/drivers/misc/habanalabs/include/gaudi/gaudi_masks.h b/drivers/misc/habanalabs/include/gaudi/gaudi_masks.h +index 96f08050ef0fb..6c50f015eda47 100644 +--- a/drivers/misc/habanalabs/include/gaudi/gaudi_masks.h ++++ b/drivers/misc/habanalabs/include/gaudi/gaudi_masks.h +@@ -378,15 +378,15 @@ enum axi_id { + ((((y) & RAZWI_INITIATOR_Y_MASK) << RAZWI_INITIATOR_Y_SHIFT) | \ + (((x) & RAZWI_INITIATOR_X_MASK) << RAZWI_INITIATOR_X_SHIFT)) + +-#define RAZWI_INITIATOR_ID_X_Y_TPC0_NIC0 RAZWI_INITIATOR_ID_X_Y(1, 0) +-#define RAZWI_INITIATOR_ID_X_Y_TPC1 RAZWI_INITIATOR_ID_X_Y(2, 0) +-#define RAZWI_INITIATOR_ID_X_Y_MME0_0 RAZWI_INITIATOR_ID_X_Y(3, 0) +-#define RAZWI_INITIATOR_ID_X_Y_MME0_1 RAZWI_INITIATOR_ID_X_Y(4, 0) +-#define RAZWI_INITIATOR_ID_X_Y_MME1_0 RAZWI_INITIATOR_ID_X_Y(5, 0) +-#define RAZWI_INITIATOR_ID_X_Y_MME1_1 RAZWI_INITIATOR_ID_X_Y(6, 0) +-#define RAZWI_INITIATOR_ID_X_Y_TPC2 RAZWI_INITIATOR_ID_X_Y(7, 0) ++#define RAZWI_INITIATOR_ID_X_Y_TPC0_NIC0 RAZWI_INITIATOR_ID_X_Y(1, 1) ++#define RAZWI_INITIATOR_ID_X_Y_TPC1 RAZWI_INITIATOR_ID_X_Y(2, 1) ++#define RAZWI_INITIATOR_ID_X_Y_MME0_0 RAZWI_INITIATOR_ID_X_Y(3, 1) ++#define RAZWI_INITIATOR_ID_X_Y_MME0_1 RAZWI_INITIATOR_ID_X_Y(4, 1) ++#define RAZWI_INITIATOR_ID_X_Y_MME1_0 RAZWI_INITIATOR_ID_X_Y(5, 1) ++#define RAZWI_INITIATOR_ID_X_Y_MME1_1 RAZWI_INITIATOR_ID_X_Y(6, 1) ++#define RAZWI_INITIATOR_ID_X_Y_TPC2 RAZWI_INITIATOR_ID_X_Y(7, 1) + #define RAZWI_INITIATOR_ID_X_Y_TPC3_PCI_CPU_PSOC \ +- RAZWI_INITIATOR_ID_X_Y(8, 0) ++ RAZWI_INITIATOR_ID_X_Y(8, 1) + #define RAZWI_INITIATOR_ID_X_Y_DMA_IF_W_S_0 RAZWI_INITIATOR_ID_X_Y(0, 1) + #define RAZWI_INITIATOR_ID_X_Y_DMA_IF_E_S_0 RAZWI_INITIATOR_ID_X_Y(9, 1) + #define RAZWI_INITIATOR_ID_X_Y_DMA_IF_W_S_1 RAZWI_INITIATOR_ID_X_Y(0, 2) +@@ -395,14 +395,14 @@ enum axi_id { + #define RAZWI_INITIATOR_ID_X_Y_DMA_IF_E_N_0 RAZWI_INITIATOR_ID_X_Y(9, 3) + #define RAZWI_INITIATOR_ID_X_Y_DMA_IF_W_N_1 RAZWI_INITIATOR_ID_X_Y(0, 4) + #define RAZWI_INITIATOR_ID_X_Y_DMA_IF_E_N_1 RAZWI_INITIATOR_ID_X_Y(9, 4) +-#define RAZWI_INITIATOR_ID_X_Y_TPC4_NIC1_NIC2 RAZWI_INITIATOR_ID_X_Y(1, 5) +-#define RAZWI_INITIATOR_ID_X_Y_TPC5 RAZWI_INITIATOR_ID_X_Y(2, 5) +-#define RAZWI_INITIATOR_ID_X_Y_MME2_0 RAZWI_INITIATOR_ID_X_Y(3, 5) +-#define RAZWI_INITIATOR_ID_X_Y_MME2_1 RAZWI_INITIATOR_ID_X_Y(4, 5) +-#define RAZWI_INITIATOR_ID_X_Y_MME3_0 RAZWI_INITIATOR_ID_X_Y(5, 5) +-#define RAZWI_INITIATOR_ID_X_Y_MME3_1 RAZWI_INITIATOR_ID_X_Y(6, 5) +-#define RAZWI_INITIATOR_ID_X_Y_TPC6 RAZWI_INITIATOR_ID_X_Y(7, 5) +-#define RAZWI_INITIATOR_ID_X_Y_TPC7_NIC4_NIC5 RAZWI_INITIATOR_ID_X_Y(8, 5) ++#define RAZWI_INITIATOR_ID_X_Y_TPC4_NIC1_NIC2 RAZWI_INITIATOR_ID_X_Y(1, 6) ++#define RAZWI_INITIATOR_ID_X_Y_TPC5 RAZWI_INITIATOR_ID_X_Y(2, 6) ++#define RAZWI_INITIATOR_ID_X_Y_MME2_0 RAZWI_INITIATOR_ID_X_Y(3, 6) ++#define RAZWI_INITIATOR_ID_X_Y_MME2_1 RAZWI_INITIATOR_ID_X_Y(4, 6) ++#define RAZWI_INITIATOR_ID_X_Y_MME3_0 RAZWI_INITIATOR_ID_X_Y(5, 6) ++#define RAZWI_INITIATOR_ID_X_Y_MME3_1 RAZWI_INITIATOR_ID_X_Y(6, 6) ++#define RAZWI_INITIATOR_ID_X_Y_TPC6 RAZWI_INITIATOR_ID_X_Y(7, 6) ++#define RAZWI_INITIATOR_ID_X_Y_TPC7_NIC4_NIC5 RAZWI_INITIATOR_ID_X_Y(8, 6) + + #define PSOC_ETR_AXICTL_PROTCTRLBIT1_SHIFT 1 + +diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c +index 6b81c04ab5e29..47159b31e6b39 100644 +--- a/drivers/net/hyperv/netvsc_drv.c ++++ b/drivers/net/hyperv/netvsc_drv.c +@@ -367,7 +367,7 @@ static u16 netvsc_select_queue(struct net_device *ndev, struct sk_buff *skb, + } + rcu_read_unlock(); + +- while (unlikely(txq >= ndev->real_num_tx_queues)) ++ while (txq >= ndev->real_num_tx_queues) + txq -= ndev->real_num_tx_queues; + + return txq; +diff --git a/drivers/nvme/host/fc.c b/drivers/nvme/host/fc.c +index 1a2b6910509ca..92c966ac34c20 100644 +--- a/drivers/nvme/host/fc.c ++++ b/drivers/nvme/host/fc.c +@@ -2158,6 +2158,7 @@ nvme_fc_term_aen_ops(struct nvme_fc_ctrl *ctrl) + struct nvme_fc_fcp_op *aen_op; + int i; + ++ cancel_work_sync(&ctrl->ctrl.async_event_work); + aen_op = ctrl->aen_ops; + for (i = 0; i < NVME_NR_AEN_COMMANDS; i++, aen_op++) { + __nvme_fc_exit_request(ctrl, aen_op); +diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c +index 6c07bb55b0f83..4a0bc8927048a 100644 +--- a/drivers/nvme/host/rdma.c ++++ b/drivers/nvme/host/rdma.c +@@ -809,6 +809,7 @@ static void nvme_rdma_destroy_admin_queue(struct nvme_rdma_ctrl *ctrl, + blk_mq_free_tag_set(ctrl->ctrl.admin_tagset); + } + if (ctrl->async_event_sqe.data) { ++ cancel_work_sync(&ctrl->ctrl.async_event_work); + nvme_rdma_free_qe(ctrl->device->dev, &ctrl->async_event_sqe, + sizeof(struct nvme_command), DMA_TO_DEVICE); + ctrl->async_event_sqe.data = NULL; +diff --git a/drivers/nvme/host/tcp.c b/drivers/nvme/host/tcp.c +index f1f66bf96cbb9..24467eea73999 100644 +--- a/drivers/nvme/host/tcp.c ++++ b/drivers/nvme/host/tcp.c +@@ -1567,6 +1567,7 @@ static struct blk_mq_tag_set *nvme_tcp_alloc_tagset(struct nvme_ctrl *nctrl, + static void nvme_tcp_free_admin_queue(struct nvme_ctrl *ctrl) + { + if (to_tcp_ctrl(ctrl)->async_req.pdu) { ++ cancel_work_sync(&ctrl->async_event_work); + nvme_tcp_free_async_req(to_tcp_ctrl(ctrl)); + to_tcp_ctrl(ctrl)->async_req.pdu = NULL; + } +diff --git a/drivers/nvme/target/loop.c b/drivers/nvme/target/loop.c +index 6344e73c93548..9c4f257962423 100644 +--- a/drivers/nvme/target/loop.c ++++ b/drivers/nvme/target/loop.c +@@ -583,6 +583,9 @@ static struct nvme_ctrl *nvme_loop_create_ctrl(struct device *dev, + if (ret) + goto out_put_ctrl; + ++ changed = nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING); ++ WARN_ON_ONCE(!changed); ++ + ret = -ENOMEM; + + ctrl->ctrl.sqsize = opts->queue_size - 1; +diff --git a/drivers/phy/ti/phy-omap-usb2.c b/drivers/phy/ti/phy-omap-usb2.c +index cb2dd3230fa76..507f79d14adb8 100644 +--- a/drivers/phy/ti/phy-omap-usb2.c ++++ b/drivers/phy/ti/phy-omap-usb2.c +@@ -22,10 +22,15 @@ + #include <linux/mfd/syscon.h> + #include <linux/regmap.h> + #include <linux/of_platform.h> ++#include <linux/sys_soc.h> + + #define USB2PHY_ANA_CONFIG1 0x4c + #define USB2PHY_DISCON_BYP_LATCH BIT(31) + ++#define USB2PHY_CHRG_DET 0x14 ++#define USB2PHY_CHRG_DET_USE_CHG_DET_REG BIT(29) ++#define USB2PHY_CHRG_DET_DIS_CHG_DET BIT(28) ++ + /* SoC Specific USB2_OTG register definitions */ + #define AM654_USB2_OTG_PD BIT(8) + #define AM654_USB2_VBUS_DET_EN BIT(5) +@@ -43,6 +48,7 @@ + #define OMAP_USB2_HAS_START_SRP BIT(0) + #define OMAP_USB2_HAS_SET_VBUS BIT(1) + #define OMAP_USB2_CALIBRATE_FALSE_DISCONNECT BIT(2) ++#define OMAP_USB2_DISABLE_CHRG_DET BIT(3) + + struct omap_usb { + struct usb_phy phy; +@@ -236,6 +242,13 @@ static int omap_usb_init(struct phy *x) + omap_usb_writel(phy->phy_base, USB2PHY_ANA_CONFIG1, val); + } + ++ if (phy->flags & OMAP_USB2_DISABLE_CHRG_DET) { ++ val = omap_usb_readl(phy->phy_base, USB2PHY_CHRG_DET); ++ val |= USB2PHY_CHRG_DET_USE_CHG_DET_REG | ++ USB2PHY_CHRG_DET_DIS_CHG_DET; ++ omap_usb_writel(phy->phy_base, USB2PHY_CHRG_DET, val); ++ } ++ + return 0; + } + +@@ -329,6 +342,26 @@ static const struct of_device_id omap_usb2_id_table[] = { + }; + MODULE_DEVICE_TABLE(of, omap_usb2_id_table); + ++static void omap_usb2_init_errata(struct omap_usb *phy) ++{ ++ static const struct soc_device_attribute am65x_sr10_soc_devices[] = { ++ { .family = "AM65X", .revision = "SR1.0" }, ++ { /* sentinel */ } ++ }; ++ ++ /* ++ * Errata i2075: USB2PHY: USB2PHY Charger Detect is Enabled by ++ * Default Without VBUS Presence. ++ * ++ * AM654x SR1.0 has a silicon bug due to which D+ is pulled high after ++ * POR, which could cause enumeration failure with some USB hubs. ++ * Disabling the USB2_PHY Charger Detect function will put D+ ++ * into the normal state. ++ */ ++ if (soc_device_match(am65x_sr10_soc_devices)) ++ phy->flags |= OMAP_USB2_DISABLE_CHRG_DET; ++} ++ + static int omap_usb2_probe(struct platform_device *pdev) + { + struct omap_usb *phy; +@@ -366,14 +399,14 @@ static int omap_usb2_probe(struct platform_device *pdev) + phy->mask = phy_data->mask; + phy->power_on = phy_data->power_on; + phy->power_off = phy_data->power_off; ++ phy->flags = phy_data->flags; + +- if (phy_data->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT) { +- res = platform_get_resource(pdev, IORESOURCE_MEM, 0); +- phy->phy_base = devm_ioremap_resource(&pdev->dev, res); +- if (IS_ERR(phy->phy_base)) +- return PTR_ERR(phy->phy_base); +- phy->flags |= OMAP_USB2_CALIBRATE_FALSE_DISCONNECT; +- } ++ omap_usb2_init_errata(phy); ++ ++ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); ++ phy->phy_base = devm_ioremap_resource(&pdev->dev, res); ++ if (IS_ERR(phy->phy_base)) ++ return PTR_ERR(phy->phy_base); + + phy->syscon_phy_power = syscon_regmap_lookup_by_phandle(node, + "syscon-phy-power"); +diff --git a/drivers/rapidio/Kconfig b/drivers/rapidio/Kconfig +index e4c422d806bee..b9f8514909bf0 100644 +--- a/drivers/rapidio/Kconfig ++++ b/drivers/rapidio/Kconfig +@@ -37,7 +37,7 @@ config RAPIDIO_ENABLE_RX_TX_PORTS + config RAPIDIO_DMA_ENGINE + bool "DMA Engine support for RapidIO" + depends on RAPIDIO +- select DMADEVICES ++ depends on DMADEVICES + select DMA_ENGINE + help + Say Y here if you want to use DMA Engine frameork for RapidIO data +diff --git a/drivers/regulator/pwm-regulator.c b/drivers/regulator/pwm-regulator.c +index 638329bd0745e..62ad7c4e7e7c8 100644 +--- a/drivers/regulator/pwm-regulator.c ++++ b/drivers/regulator/pwm-regulator.c +@@ -279,7 +279,7 @@ static int pwm_regulator_init_table(struct platform_device *pdev, + return ret; + } + +- drvdata->state = -EINVAL; ++ drvdata->state = -ENOTRECOVERABLE; + drvdata->duty_cycle_table = duty_cycle_table; + drvdata->desc.ops = &pwm_regulator_voltage_table_ops; + drvdata->desc.n_voltages = length / sizeof(*duty_cycle_table); +diff --git a/drivers/s390/crypto/zcrypt_ccamisc.c b/drivers/s390/crypto/zcrypt_ccamisc.c +index 1b835398feec3..d1e3ee9ddf287 100644 +--- a/drivers/s390/crypto/zcrypt_ccamisc.c ++++ b/drivers/s390/crypto/zcrypt_ccamisc.c +@@ -1685,9 +1685,9 @@ int cca_findcard2(u32 **apqns, u32 *nr_apqns, u16 cardnr, u16 domain, + *nr_apqns = 0; + + /* fetch status of all crypto cards */ +- device_status = kmalloc_array(MAX_ZDEV_ENTRIES_EXT, +- sizeof(struct zcrypt_device_status_ext), +- GFP_KERNEL); ++ device_status = kvmalloc_array(MAX_ZDEV_ENTRIES_EXT, ++ sizeof(struct zcrypt_device_status_ext), ++ GFP_KERNEL); + if (!device_status) + return -ENOMEM; + zcrypt_device_status_mask_ext(device_status); +@@ -1755,7 +1755,7 @@ int cca_findcard2(u32 **apqns, u32 *nr_apqns, u16 cardnr, u16 domain, + verify = 0; + } + +- kfree(device_status); ++ kvfree(device_status); + return rc; + } + EXPORT_SYMBOL(cca_findcard2); +diff --git a/drivers/scsi/libfc/fc_disc.c b/drivers/scsi/libfc/fc_disc.c +index e00dc4693fcbd..589ddf003886e 100644 +--- a/drivers/scsi/libfc/fc_disc.c ++++ b/drivers/scsi/libfc/fc_disc.c +@@ -634,8 +634,6 @@ free_fp: + fc_frame_free(fp); + out: + kref_put(&rdata->kref, fc_rport_destroy); +- if (!IS_ERR(fp)) +- fc_frame_free(fp); + } + + /** +diff --git a/drivers/scsi/libsas/sas_discover.c b/drivers/scsi/libsas/sas_discover.c +index daf951b0b3f55..13ad2b3d314e2 100644 +--- a/drivers/scsi/libsas/sas_discover.c ++++ b/drivers/scsi/libsas/sas_discover.c +@@ -182,10 +182,11 @@ int sas_notify_lldd_dev_found(struct domain_device *dev) + pr_warn("driver on host %s cannot handle device %016llx, error:%d\n", + dev_name(sas_ha->dev), + SAS_ADDR(dev->sas_addr), res); ++ return res; + } + set_bit(SAS_DEV_FOUND, &dev->state); + kref_get(&dev->kref); +- return res; ++ return 0; + } + + +diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c +index 3d670568a2760..519c7be404e75 100644 +--- a/drivers/scsi/lpfc/lpfc_els.c ++++ b/drivers/scsi/lpfc/lpfc_els.c +@@ -3512,6 +3512,9 @@ lpfc_issue_els_rdf(struct lpfc_vport *vport, uint8_t retry) + FC_TLV_DESC_LENGTH_FROM_SZ(prdf->reg_d1)); + prdf->reg_d1.reg_desc.count = cpu_to_be32(ELS_RDF_REG_TAG_CNT); + prdf->reg_d1.desc_tags[0] = cpu_to_be32(ELS_DTAG_LNK_INTEGRITY); ++ prdf->reg_d1.desc_tags[1] = cpu_to_be32(ELS_DTAG_DELIVERY); ++ prdf->reg_d1.desc_tags[2] = cpu_to_be32(ELS_DTAG_PEER_CONGEST); ++ prdf->reg_d1.desc_tags[3] = cpu_to_be32(ELS_DTAG_CONGESTION); + + lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD, + "Issue RDF: did:x%x", +@@ -4644,7 +4647,9 @@ lpfc_cmpl_els_rsp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, + out: + if (ndlp && NLP_CHK_NODE_ACT(ndlp) && shost) { + spin_lock_irq(shost->host_lock); +- ndlp->nlp_flag &= ~(NLP_ACC_REGLOGIN | NLP_RM_DFLT_RPI); ++ if (mbox) ++ ndlp->nlp_flag &= ~NLP_ACC_REGLOGIN; ++ ndlp->nlp_flag &= ~NLP_RM_DFLT_RPI; + spin_unlock_irq(shost->host_lock); + + /* If the node is not being used by another discovery thread, +diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h +index 6dfff03765471..c7085769170d7 100644 +--- a/drivers/scsi/lpfc/lpfc_hw4.h ++++ b/drivers/scsi/lpfc/lpfc_hw4.h +@@ -4797,7 +4797,7 @@ struct send_frame_wqe { + uint32_t fc_hdr_wd5; /* word 15 */ + }; + +-#define ELS_RDF_REG_TAG_CNT 1 ++#define ELS_RDF_REG_TAG_CNT 4 + struct lpfc_els_rdf_reg_desc { + struct fc_df_desc_fpin_reg reg_desc; /* descriptor header */ + __be32 desc_tags[ELS_RDF_REG_TAG_CNT]; +diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c +index b7cbc312843e9..da9fd8a5f8cae 100644 +--- a/drivers/scsi/pm8001/pm8001_sas.c ++++ b/drivers/scsi/pm8001/pm8001_sas.c +@@ -818,7 +818,7 @@ pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha, + + res = pm8001_tag_alloc(pm8001_ha, &ccb_tag); + if (res) +- return res; ++ goto ex_err; + ccb = &pm8001_ha->ccb_info[ccb_tag]; + ccb->device = pm8001_dev; + ccb->ccb_tag = ccb_tag; +diff --git a/drivers/spi/spi-loopback-test.c b/drivers/spi/spi-loopback-test.c +index b6d79cd156fb5..da1153ec9f0e3 100644 +--- a/drivers/spi/spi-loopback-test.c ++++ b/drivers/spi/spi-loopback-test.c +@@ -90,7 +90,7 @@ static struct spi_test spi_tests[] = { + { + .description = "tx/rx-transfer - crossing PAGE_SIZE", + .fill_option = FILL_COUNT_8, +- .iterate_len = { ITERATE_MAX_LEN }, ++ .iterate_len = { ITERATE_LEN }, + .iterate_tx_align = ITERATE_ALIGN, + .iterate_rx_align = ITERATE_ALIGN, + .transfer_count = 1, +diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c +index 5c5a95792c0d3..65ca552654794 100644 +--- a/drivers/spi/spi.c ++++ b/drivers/spi/spi.c +@@ -1305,8 +1305,6 @@ out: + if (msg->status && ctlr->handle_err) + ctlr->handle_err(ctlr, msg); + +- spi_res_release(ctlr, msg); +- + spi_finalize_current_message(ctlr); + + return ret; +@@ -1694,6 +1692,13 @@ void spi_finalize_current_message(struct spi_controller *ctlr) + + spi_unmap_msg(ctlr, mesg); + ++ /* In the prepare_messages callback the spi bus has the opportunity to ++ * split a transfer to smaller chunks. ++ * Release splited transfers here since spi_map_msg is done on the ++ * splited transfers. ++ */ ++ spi_res_release(ctlr, mesg); ++ + if (ctlr->cur_msg_prepared && ctlr->unprepare_message) { + ret = ctlr->unprepare_message(ctlr, mesg); + if (ret) { +diff --git a/drivers/thunderbolt/eeprom.c b/drivers/thunderbolt/eeprom.c +index b451a5aa90b50..2db6532d39230 100644 +--- a/drivers/thunderbolt/eeprom.c ++++ b/drivers/thunderbolt/eeprom.c +@@ -7,6 +7,7 @@ + */ + + #include <linux/crc32.h> ++#include <linux/delay.h> + #include <linux/property.h> + #include <linux/slab.h> + #include "tb.h" +@@ -389,8 +390,8 @@ static int tb_drom_parse_entries(struct tb_switch *sw) + struct tb_drom_entry_header *entry = (void *) (sw->drom + pos); + if (pos + 1 == drom_size || pos + entry->len > drom_size + || !entry->len) { +- tb_sw_warn(sw, "drom buffer overrun, aborting\n"); +- return -EIO; ++ tb_sw_warn(sw, "DROM buffer overrun\n"); ++ return -EILSEQ; + } + + switch (entry->type) { +@@ -526,7 +527,8 @@ int tb_drom_read(struct tb_switch *sw) + u16 size; + u32 crc; + struct tb_drom_header *header; +- int res; ++ int res, retries = 1; ++ + if (sw->drom) + return 0; + +@@ -611,7 +613,17 @@ parse: + tb_sw_warn(sw, "drom device_rom_revision %#x unknown\n", + header->device_rom_revision); + +- return tb_drom_parse_entries(sw); ++ res = tb_drom_parse_entries(sw); ++ /* If the DROM parsing fails, wait a moment and retry once */ ++ if (res == -EILSEQ && retries--) { ++ tb_sw_warn(sw, "parsing DROM failed, retrying\n"); ++ msleep(100); ++ res = tb_drom_read_n(sw, 0, sw->drom, size); ++ if (!res) ++ goto parse; ++ } ++ ++ return res; + err: + kfree(sw->drom); + sw->drom = NULL; +diff --git a/drivers/tty/serial/8250/8250_pci.c b/drivers/tty/serial/8250/8250_pci.c +index 1a74d511b02a5..81c0b67f22640 100644 +--- a/drivers/tty/serial/8250/8250_pci.c ++++ b/drivers/tty/serial/8250/8250_pci.c +@@ -5566,6 +5566,17 @@ static const struct pci_device_id serial_pci_tbl[] = { + PCI_ANY_ID, PCI_ANY_ID, + 0, 0, pbn_wch384_4 }, + ++ /* ++ * Realtek RealManage ++ */ ++ { PCI_VENDOR_ID_REALTEK, 0x816a, ++ PCI_ANY_ID, PCI_ANY_ID, ++ 0, 0, pbn_b0_1_115200 }, ++ ++ { PCI_VENDOR_ID_REALTEK, 0x816b, ++ PCI_ANY_ID, PCI_ANY_ID, ++ 0, 0, pbn_b0_1_115200 }, ++ + /* Fintek PCI serial cards */ + { PCI_DEVICE(0x1c29, 0x1104), .driver_data = pbn_fintek_4 }, + { PCI_DEVICE(0x1c29, 0x1108), .driver_data = pbn_fintek_8 }, +diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c +index 5f3daabdc916e..ef1cdc82bc1f1 100644 +--- a/drivers/tty/serial/serial_core.c ++++ b/drivers/tty/serial/serial_core.c +@@ -1914,24 +1914,12 @@ static inline bool uart_console_enabled(struct uart_port *port) + return uart_console(port) && (port->cons->flags & CON_ENABLED); + } + +-static void __uart_port_spin_lock_init(struct uart_port *port) ++static void uart_port_spin_lock_init(struct uart_port *port) + { + spin_lock_init(&port->lock); + lockdep_set_class(&port->lock, &port_lock_key); + } + +-/* +- * Ensure that the serial console lock is initialised early. +- * If this port is a console, then the spinlock is already initialised. +- */ +-static inline void uart_port_spin_lock_init(struct uart_port *port) +-{ +- if (uart_console(port)) +- return; +- +- __uart_port_spin_lock_init(port); +-} +- + #if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(CONFIG_CONSOLE_POLL) + /** + * uart_console_write - write a console message to a serial port +@@ -2084,7 +2072,15 @@ uart_set_options(struct uart_port *port, struct console *co, + struct ktermios termios; + static struct ktermios dummy; + +- uart_port_spin_lock_init(port); ++ /* ++ * Ensure that the serial-console lock is initialised early. ++ * ++ * Note that the console-enabled check is needed because of kgdboc, ++ * which can end up calling uart_set_options() for an already enabled ++ * console via tty_find_polling_driver() and uart_poll_init(). ++ */ ++ if (!uart_console_enabled(port) && !port->console_reinit) ++ uart_port_spin_lock_init(port); + + memset(&termios, 0, sizeof(struct ktermios)); + +@@ -2375,13 +2371,6 @@ uart_configure_port(struct uart_driver *drv, struct uart_state *state, + /* Power up port for set_mctrl() */ + uart_change_pm(state, UART_PM_STATE_ON); + +- /* +- * If this driver supports console, and it hasn't been +- * successfully registered yet, initialise spin lock for it. +- */ +- if (port->cons && !(port->cons->flags & CON_ENABLED)) +- __uart_port_spin_lock_init(port); +- + /* + * Ensure that the modem control lines are de-activated. + * keep the DTR setting that is set in uart_set_options() +@@ -2798,10 +2787,12 @@ static ssize_t console_store(struct device *dev, + if (oldconsole && !newconsole) { + ret = unregister_console(uport->cons); + } else if (!oldconsole && newconsole) { +- if (uart_console(uport)) ++ if (uart_console(uport)) { ++ uport->console_reinit = 1; + register_console(uport->cons); +- else ++ } else { + ret = -ENOENT; ++ } + } + } else { + ret = -ENXIO; +@@ -2897,7 +2888,12 @@ int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport) + goto out; + } + +- uart_port_spin_lock_init(uport); ++ /* ++ * If this port is in use as a console then the spinlock is already ++ * initialised. ++ */ ++ if (!uart_console_enabled(uport)) ++ uart_port_spin_lock_init(uport); + + if (uport->cons && uport->dev) + of_console_check(uport->dev->of_node, uport->cons->name, uport->line); +diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c +index 084c48c5848fc..67cbd42421bee 100644 +--- a/drivers/usb/class/usblp.c ++++ b/drivers/usb/class/usblp.c +@@ -827,6 +827,11 @@ static ssize_t usblp_read(struct file *file, char __user *buffer, size_t len, lo + if (rv < 0) + return rv; + ++ if (!usblp->present) { ++ count = -ENODEV; ++ goto done; ++ } ++ + if ((avail = usblp->rstatus) < 0) { + printk(KERN_ERR "usblp%d: error %d reading from printer\n", + usblp->minor, (int)avail); +diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c +index 2f068e525a374..4ee8105310989 100644 +--- a/drivers/usb/core/quirks.c ++++ b/drivers/usb/core/quirks.c +@@ -397,6 +397,10 @@ static const struct usb_device_id usb_quirk_list[] = { + /* Generic RTL8153 based ethernet adapters */ + { USB_DEVICE(0x0bda, 0x8153), .driver_info = USB_QUIRK_NO_LPM }, + ++ /* SONiX USB DEVICE Touchpad */ ++ { USB_DEVICE(0x0c45, 0x7056), .driver_info = ++ USB_QUIRK_IGNORE_REMOTE_WAKEUP }, ++ + /* Action Semiconductor flash disk */ + { USB_DEVICE(0x10d6, 0x2200), .driver_info = + USB_QUIRK_STRING_FETCH_255 }, +diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c +index cf2b7ae93b7e9..0e5c56e065591 100644 +--- a/drivers/usb/host/ehci-hcd.c ++++ b/drivers/usb/host/ehci-hcd.c +@@ -22,6 +22,7 @@ + #include <linux/interrupt.h> + #include <linux/usb.h> + #include <linux/usb/hcd.h> ++#include <linux/usb/otg.h> + #include <linux/moduleparam.h> + #include <linux/dma-mapping.h> + #include <linux/debugfs.h> +diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c +index ce0eaf7d7c12a..087402aec5cbe 100644 +--- a/drivers/usb/host/ehci-hub.c ++++ b/drivers/usb/host/ehci-hub.c +@@ -14,7 +14,6 @@ + */ + + /*-------------------------------------------------------------------------*/ +-#include <linux/usb/otg.h> + + #define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E) + +diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c +index d592071119ba6..13696f03f800d 100644 +--- a/drivers/usb/storage/uas.c ++++ b/drivers/usb/storage/uas.c +@@ -662,8 +662,7 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd, + if (devinfo->resetting) { + cmnd->result = DID_ERROR << 16; + cmnd->scsi_done(cmnd); +- spin_unlock_irqrestore(&devinfo->lock, flags); +- return 0; ++ goto zombie; + } + + /* Find a free uas-tag */ +@@ -699,6 +698,16 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd, + cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB); + + err = uas_submit_urbs(cmnd, devinfo); ++ /* ++ * in case of fatal errors the SCSI layer is peculiar ++ * a command that has finished is a success for the purpose ++ * of queueing, no matter how fatal the error ++ */ ++ if (err == -ENODEV) { ++ cmnd->result = DID_ERROR << 16; ++ cmnd->scsi_done(cmnd); ++ goto zombie; ++ } + if (err) { + /* If we did nothing, give up now */ + if (cmdinfo->state & SUBMIT_STATUS_URB) { +@@ -709,6 +718,7 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd, + } + + devinfo->cmnd[idx] = cmnd; ++zombie: + spin_unlock_irqrestore(&devinfo->lock, flags); + return 0; + } +diff --git a/drivers/usb/typec/ucsi/ucsi.c b/drivers/usb/typec/ucsi/ucsi.c +index 2999217c81090..e2af10301c779 100644 +--- a/drivers/usb/typec/ucsi/ucsi.c ++++ b/drivers/usb/typec/ucsi/ucsi.c +@@ -216,14 +216,18 @@ void ucsi_altmode_update_active(struct ucsi_connector *con) + con->partner_altmode[i] == altmode); + } + +-static u8 ucsi_altmode_next_mode(struct typec_altmode **alt, u16 svid) ++static int ucsi_altmode_next_mode(struct typec_altmode **alt, u16 svid) + { + u8 mode = 1; + int i; + +- for (i = 0; alt[i]; i++) ++ for (i = 0; alt[i]; i++) { ++ if (i > MODE_DISCOVERY_MAX) ++ return -ERANGE; ++ + if (alt[i]->svid == svid) + mode++; ++ } + + return mode; + } +@@ -258,8 +262,11 @@ static int ucsi_register_altmode(struct ucsi_connector *con, + goto err; + } + +- desc->mode = ucsi_altmode_next_mode(con->port_altmode, +- desc->svid); ++ ret = ucsi_altmode_next_mode(con->port_altmode, desc->svid); ++ if (ret < 0) ++ return ret; ++ ++ desc->mode = ret; + + switch (desc->svid) { + case USB_TYPEC_DP_SID: +@@ -292,8 +299,11 @@ static int ucsi_register_altmode(struct ucsi_connector *con, + goto err; + } + +- desc->mode = ucsi_altmode_next_mode(con->partner_altmode, +- desc->svid); ++ ret = ucsi_altmode_next_mode(con->partner_altmode, desc->svid); ++ if (ret < 0) ++ return ret; ++ ++ desc->mode = ret; + + alt = typec_partner_register_altmode(con->partner, desc); + if (IS_ERR(alt)) { +diff --git a/drivers/usb/typec/ucsi/ucsi_acpi.c b/drivers/usb/typec/ucsi/ucsi_acpi.c +index c0aca2f0f23f0..fbfe8f5933af8 100644 +--- a/drivers/usb/typec/ucsi/ucsi_acpi.c ++++ b/drivers/usb/typec/ucsi/ucsi_acpi.c +@@ -78,7 +78,7 @@ static int ucsi_acpi_sync_write(struct ucsi *ucsi, unsigned int offset, + if (ret) + goto out_clear_bit; + +- if (!wait_for_completion_timeout(&ua->complete, msecs_to_jiffies(5000))) ++ if (!wait_for_completion_timeout(&ua->complete, 60 * HZ)) + ret = -ETIMEDOUT; + + out_clear_bit: +diff --git a/drivers/video/fbdev/core/fbcon.c b/drivers/video/fbdev/core/fbcon.c +index b36bfe10c712c..09cb46e94f405 100644 +--- a/drivers/video/fbdev/core/fbcon.c ++++ b/drivers/video/fbdev/core/fbcon.c +@@ -2018,7 +2018,7 @@ static int fbcon_resize(struct vc_data *vc, unsigned int width, + struct fb_var_screeninfo var = info->var; + int x_diff, y_diff, virt_w, virt_h, virt_fw, virt_fh; + +- if (ops->p && ops->p->userfont && FNTSIZE(vc->vc_font.data)) { ++ if (p->userfont && FNTSIZE(vc->vc_font.data)) { + int size; + int pitch = PITCH(vc->vc_font.width); + +diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c +index ce95801e9b664..7708175062eba 100644 +--- a/fs/cifs/inode.c ++++ b/fs/cifs/inode.c +@@ -1017,6 +1017,8 @@ handle_mnt_opt: + if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) { + rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true, + full_path, fid); ++ if (rc == -EREMOTE) ++ rc = 0; + if (rc) { + cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n", + __func__, rc); +@@ -1025,6 +1027,8 @@ handle_mnt_opt: + } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) { + rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false, + full_path, fid); ++ if (rc == -EREMOTE) ++ rc = 0; + if (rc) { + cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n", + __func__, rc); +diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c +index 6e9017e6a8197..403e8033c974b 100644 +--- a/fs/f2fs/data.c ++++ b/fs/f2fs/data.c +@@ -3463,6 +3463,9 @@ static int check_direct_IO(struct inode *inode, struct iov_iter *iter, + unsigned long align = offset | iov_iter_alignment(iter); + struct block_device *bdev = inode->i_sb->s_bdev; + ++ if (iov_iter_rw(iter) == READ && offset >= i_size_read(inode)) ++ return 1; ++ + if (align & blocksize_mask) { + if (bdev) + blkbits = blksize_bits(bdev_logical_block_size(bdev)); +diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c +index 98736d0598b8d..0fde35611df18 100644 +--- a/fs/f2fs/node.c ++++ b/fs/f2fs/node.c +@@ -2375,6 +2375,9 @@ static int __f2fs_build_free_nids(struct f2fs_sb_info *sbi, + if (unlikely(nid >= nm_i->max_nid)) + nid = 0; + ++ if (unlikely(nid % NAT_ENTRY_PER_BLOCK)) ++ nid = NAT_BLOCK_OFFSET(nid) * NAT_ENTRY_PER_BLOCK; ++ + /* Enough entries */ + if (nm_i->nid_cnt[FREE_NID] >= NAT_ENTRY_PER_BLOCK) + return 0; +diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c +index 45e0585e0667c..08b1fb0a9225a 100644 +--- a/fs/nfs/nfs4proc.c ++++ b/fs/nfs/nfs4proc.c +@@ -3272,8 +3272,10 @@ static int _nfs4_do_setattr(struct inode *inode, + + /* Servers should only apply open mode checks for file size changes */ + truncate = (arg->iap->ia_valid & ATTR_SIZE) ? true : false; +- if (!truncate) ++ if (!truncate) { ++ nfs4_inode_make_writeable(inode); + goto zero_stateid; ++ } + + if (nfs4_copy_delegation_stateid(inode, FMODE_WRITE, &arg->stateid, &delegation_cred)) { + /* Use that stateid */ +@@ -7271,7 +7273,12 @@ int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, + err = nfs4_set_lock_state(state, fl); + if (err != 0) + return err; +- err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW); ++ do { ++ err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW); ++ if (err != -NFS4ERR_DELAY) ++ break; ++ ssleep(1); ++ } while (err == -NFS4ERR_DELAY); + return nfs4_handle_delegation_recall_error(server, state, stateid, fl, err); + } + +diff --git a/include/linux/cpuhotplug.h b/include/linux/cpuhotplug.h +index 191772d4a4d7d..67ba16c7e118b 100644 +--- a/include/linux/cpuhotplug.h ++++ b/include/linux/cpuhotplug.h +@@ -141,7 +141,6 @@ enum cpuhp_state { + /* Must be the last timer callback */ + CPUHP_AP_DUMMY_TIMER_STARTING, + CPUHP_AP_ARM_XEN_STARTING, +- CPUHP_AP_ARM_KVMPV_STARTING, + CPUHP_AP_ARM_CORESIGHT_STARTING, + CPUHP_AP_ARM_CORESIGHT_CTI_STARTING, + CPUHP_AP_ARM64_ISNDEP_STARTING, +diff --git a/include/linux/dax.h b/include/linux/dax.h +index 6904d4e0b2e0a..43b39ab9de1a9 100644 +--- a/include/linux/dax.h ++++ b/include/linux/dax.h +@@ -58,6 +58,8 @@ static inline void set_dax_synchronous(struct dax_device *dax_dev) + { + __set_dax_synchronous(dax_dev); + } ++bool dax_supported(struct dax_device *dax_dev, struct block_device *bdev, ++ int blocksize, sector_t start, sector_t len); + /* + * Check if given mapping is supported by the file / underlying device. + */ +@@ -104,6 +106,12 @@ static inline bool dax_synchronous(struct dax_device *dax_dev) + static inline void set_dax_synchronous(struct dax_device *dax_dev) + { + } ++static inline bool dax_supported(struct dax_device *dax_dev, ++ struct block_device *bdev, int blocksize, sector_t start, ++ sector_t len) ++{ ++ return false; ++} + static inline bool daxdev_mapping_supported(struct vm_area_struct *vma, + struct dax_device *dax_dev) + { +@@ -189,14 +197,23 @@ static inline void dax_unlock_page(struct page *page, dax_entry_t cookie) + } + #endif + ++#if IS_ENABLED(CONFIG_DAX) + int dax_read_lock(void); + void dax_read_unlock(int id); ++#else ++static inline int dax_read_lock(void) ++{ ++ return 0; ++} ++ ++static inline void dax_read_unlock(int id) ++{ ++} ++#endif /* CONFIG_DAX */ + bool dax_alive(struct dax_device *dax_dev); + void *dax_get_private(struct dax_device *dax_dev); + long dax_direct_access(struct dax_device *dax_dev, pgoff_t pgoff, long nr_pages, + void **kaddr, pfn_t *pfn); +-bool dax_supported(struct dax_device *dax_dev, struct block_device *bdev, +- int blocksize, sector_t start, sector_t len); + size_t dax_copy_from_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr, + size_t bytes, struct iov_iter *i); + size_t dax_copy_to_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr, +diff --git a/include/linux/i2c-algo-pca.h b/include/linux/i2c-algo-pca.h +index d03071732db4a..7c522fdd9ea73 100644 +--- a/include/linux/i2c-algo-pca.h ++++ b/include/linux/i2c-algo-pca.h +@@ -53,6 +53,20 @@ + #define I2C_PCA_CON_SI 0x08 /* Serial Interrupt */ + #define I2C_PCA_CON_CR 0x07 /* Clock Rate (MASK) */ + ++/** ++ * struct pca_i2c_bus_settings - The configured PCA i2c bus settings ++ * @mode: Configured i2c bus mode ++ * @tlow: Configured SCL LOW period ++ * @thi: Configured SCL HIGH period ++ * @clock_freq: The configured clock frequency ++ */ ++struct pca_i2c_bus_settings { ++ int mode; ++ int tlow; ++ int thi; ++ int clock_freq; ++}; ++ + struct i2c_algo_pca_data { + void *data; /* private low level data */ + void (*write_byte) (void *data, int reg, int val); +@@ -64,6 +78,7 @@ struct i2c_algo_pca_data { + * For PCA9665, use the frequency you want here. */ + unsigned int i2c_clock; + unsigned int chip; ++ struct pca_i2c_bus_settings bus_settings; + }; + + int i2c_pca_add_bus(struct i2c_adapter *); +diff --git a/include/linux/percpu-rwsem.h b/include/linux/percpu-rwsem.h +index 5e033fe1ff4e9..5fda40f97fe91 100644 +--- a/include/linux/percpu-rwsem.h ++++ b/include/linux/percpu-rwsem.h +@@ -60,7 +60,7 @@ static inline void percpu_down_read(struct percpu_rw_semaphore *sem) + * anything we did within this RCU-sched read-size critical section. + */ + if (likely(rcu_sync_is_idle(&sem->rss))) +- __this_cpu_inc(*sem->read_count); ++ this_cpu_inc(*sem->read_count); + else + __percpu_down_read(sem, false); /* Unconditional memory barrier */ + /* +@@ -79,7 +79,7 @@ static inline bool percpu_down_read_trylock(struct percpu_rw_semaphore *sem) + * Same as in percpu_down_read(). + */ + if (likely(rcu_sync_is_idle(&sem->rss))) +- __this_cpu_inc(*sem->read_count); ++ this_cpu_inc(*sem->read_count); + else + ret = __percpu_down_read(sem, true); /* Unconditional memory barrier */ + preempt_enable(); +@@ -103,7 +103,7 @@ static inline void percpu_up_read(struct percpu_rw_semaphore *sem) + * Same as in percpu_down_read(). + */ + if (likely(rcu_sync_is_idle(&sem->rss))) { +- __this_cpu_dec(*sem->read_count); ++ this_cpu_dec(*sem->read_count); + } else { + /* + * slowpath; reader will only ever wake a single blocked +@@ -115,7 +115,7 @@ static inline void percpu_up_read(struct percpu_rw_semaphore *sem) + * aggregate zero, as that is the only time it matters) they + * will also see our critical section. + */ +- __this_cpu_dec(*sem->read_count); ++ this_cpu_dec(*sem->read_count); + rcuwait_wake_up(&sem->writer); + } + preempt_enable(); +diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h +index 791f4844efeb9..d3266caefe049 100644 +--- a/include/linux/serial_core.h ++++ b/include/linux/serial_core.h +@@ -248,6 +248,7 @@ struct uart_port { + + unsigned char hub6; /* this should be in the 8250 driver */ + unsigned char suspended; ++ unsigned char console_reinit; + const char *name; /* port name */ + struct attribute_group *attr_group; /* port specific attributes */ + const struct attribute_group **tty_groups; /* all attributes (serial core use only) */ +diff --git a/include/sound/soc.h b/include/sound/soc.h +index 3ce7f0f5aa929..ca765062787b0 100644 +--- a/include/sound/soc.h ++++ b/include/sound/soc.h +@@ -1205,6 +1205,8 @@ struct snd_soc_pcm_runtime { + ((i) < (rtd)->num_cpus + (rtd)->num_codecs) && \ + ((dai) = (rtd)->dais[i]); \ + (i)++) ++#define for_each_rtd_dais_rollback(rtd, i, dai) \ ++ for (; (--(i) >= 0) && ((dai) = (rtd)->dais[i]);) + + void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd); + +@@ -1373,6 +1375,8 @@ void snd_soc_unregister_dai(struct snd_soc_dai *dai); + + struct snd_soc_dai *snd_soc_find_dai( + const struct snd_soc_dai_link_component *dlc); ++struct snd_soc_dai *snd_soc_find_dai_with_mutex( ++ const struct snd_soc_dai_link_component *dlc); + + #include <sound/soc-dai.h> + +diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h +index 4fdf303165827..65fd95f9784ce 100644 +--- a/include/uapi/linux/kvm.h ++++ b/include/uapi/linux/kvm.h +@@ -789,9 +789,10 @@ struct kvm_ppc_resize_hpt { + #define KVM_VM_PPC_HV 1 + #define KVM_VM_PPC_PR 2 + +-/* on MIPS, 0 forces trap & emulate, 1 forces VZ ASE */ +-#define KVM_VM_MIPS_TE 0 ++/* on MIPS, 0 indicates auto, 1 forces VZ ASE, 2 forces trap & emulate */ ++#define KVM_VM_MIPS_AUTO 0 + #define KVM_VM_MIPS_VZ 1 ++#define KVM_VM_MIPS_TE 2 + + #define KVM_S390_SIE_PAGE_OFFSET 1 + +diff --git a/kernel/kprobes.c b/kernel/kprobes.c +index 72af5d37e9ff1..a264246ff85aa 100644 +--- a/kernel/kprobes.c ++++ b/kernel/kprobes.c +@@ -2108,6 +2108,9 @@ static void kill_kprobe(struct kprobe *p) + + lockdep_assert_held(&kprobe_mutex); + ++ if (WARN_ON_ONCE(kprobe_gone(p))) ++ return; ++ + p->flags |= KPROBE_FLAG_GONE; + if (kprobe_aggrprobe(p)) { + /* +@@ -2365,7 +2368,10 @@ static int kprobes_module_callback(struct notifier_block *nb, + mutex_lock(&kprobe_mutex); + for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + head = &kprobe_table[i]; +- hlist_for_each_entry(p, head, hlist) ++ hlist_for_each_entry(p, head, hlist) { ++ if (kprobe_gone(p)) ++ continue; ++ + if (within_module_init((unsigned long)p->addr, mod) || + (checkcore && + within_module_core((unsigned long)p->addr, mod))) { +@@ -2382,6 +2388,7 @@ static int kprobes_module_callback(struct notifier_block *nb, + */ + kill_kprobe(p); + } ++ } + } + if (val == MODULE_STATE_GOING) + remove_module_kprobe_blacklist(mod); +diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c +index 29a8de4c50b90..a611dedac7d60 100644 +--- a/kernel/locking/lockdep.c ++++ b/kernel/locking/lockdep.c +@@ -3923,13 +3923,18 @@ static int separate_irq_context(struct task_struct *curr, + static int mark_lock(struct task_struct *curr, struct held_lock *this, + enum lock_usage_bit new_bit) + { +- unsigned int new_mask = 1 << new_bit, ret = 1; ++ unsigned int old_mask, new_mask, ret = 1; + + if (new_bit >= LOCK_USAGE_STATES) { + DEBUG_LOCKS_WARN_ON(1); + return 0; + } + ++ if (new_bit == LOCK_USED && this->read) ++ new_bit = LOCK_USED_READ; ++ ++ new_mask = 1 << new_bit; ++ + /* + * If already set then do not dirty the cacheline, + * nor do any checks: +@@ -3942,13 +3947,22 @@ static int mark_lock(struct task_struct *curr, struct held_lock *this, + /* + * Make sure we didn't race: + */ +- if (unlikely(hlock_class(this)->usage_mask & new_mask)) { +- graph_unlock(); +- return 1; +- } ++ if (unlikely(hlock_class(this)->usage_mask & new_mask)) ++ goto unlock; + ++ old_mask = hlock_class(this)->usage_mask; + hlock_class(this)->usage_mask |= new_mask; + ++ /* ++ * Save one usage_traces[] entry and map both LOCK_USED and ++ * LOCK_USED_READ onto the same entry. ++ */ ++ if (new_bit == LOCK_USED || new_bit == LOCK_USED_READ) { ++ if (old_mask & (LOCKF_USED | LOCKF_USED_READ)) ++ goto unlock; ++ new_bit = LOCK_USED; ++ } ++ + if (!(hlock_class(this)->usage_traces[new_bit] = save_trace())) + return 0; + +@@ -3962,6 +3976,7 @@ static int mark_lock(struct task_struct *curr, struct held_lock *this, + return 0; + } + ++unlock: + graph_unlock(); + + /* +@@ -4896,12 +4911,20 @@ static void verify_lock_unused(struct lockdep_map *lock, struct held_lock *hlock + { + #ifdef CONFIG_PROVE_LOCKING + struct lock_class *class = look_up_lock_class(lock, subclass); ++ unsigned long mask = LOCKF_USED; + + /* if it doesn't have a class (yet), it certainly hasn't been used yet */ + if (!class) + return; + +- if (!(class->usage_mask & LOCK_USED)) ++ /* ++ * READ locks only conflict with USED, such that if we only ever use ++ * READ locks, there is no deadlock possible -- RCU. ++ */ ++ if (!hlock->read) ++ mask |= LOCKF_USED_READ; ++ ++ if (!(class->usage_mask & mask)) + return; + + hlock->class_idx = class - lock_classes; +diff --git a/kernel/locking/lockdep_internals.h b/kernel/locking/lockdep_internals.h +index baca699b94e91..b0be1560ed17a 100644 +--- a/kernel/locking/lockdep_internals.h ++++ b/kernel/locking/lockdep_internals.h +@@ -19,6 +19,7 @@ enum lock_usage_bit { + #include "lockdep_states.h" + #undef LOCKDEP_STATE + LOCK_USED, ++ LOCK_USED_READ, + LOCK_USAGE_STATES + }; + +@@ -40,6 +41,7 @@ enum { + #include "lockdep_states.h" + #undef LOCKDEP_STATE + __LOCKF(USED) ++ __LOCKF(USED_READ) + }; + + #define LOCKDEP_STATE(__STATE) LOCKF_ENABLED_##__STATE | +diff --git a/kernel/locking/percpu-rwsem.c b/kernel/locking/percpu-rwsem.c +index 8bbafe3e5203d..70a32a576f3f2 100644 +--- a/kernel/locking/percpu-rwsem.c ++++ b/kernel/locking/percpu-rwsem.c +@@ -45,7 +45,7 @@ EXPORT_SYMBOL_GPL(percpu_free_rwsem); + + static bool __percpu_down_read_trylock(struct percpu_rw_semaphore *sem) + { +- __this_cpu_inc(*sem->read_count); ++ this_cpu_inc(*sem->read_count); + + /* + * Due to having preemption disabled the decrement happens on +@@ -71,7 +71,7 @@ static bool __percpu_down_read_trylock(struct percpu_rw_semaphore *sem) + if (likely(!atomic_read_acquire(&sem->block))) + return true; + +- __this_cpu_dec(*sem->read_count); ++ this_cpu_dec(*sem->read_count); + + /* Prod writer to re-evaluate readers_active_check() */ + rcuwait_wake_up(&sem->writer); +diff --git a/mm/huge_memory.c b/mm/huge_memory.c +index 78c84bee7e294..74300e337c3c7 100644 +--- a/mm/huge_memory.c ++++ b/mm/huge_memory.c +@@ -2048,7 +2048,7 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd, + put_page(page); + add_mm_counter(mm, mm_counter_file(page), -HPAGE_PMD_NR); + return; +- } else if (is_huge_zero_pmd(*pmd)) { ++ } else if (pmd_trans_huge(*pmd) && is_huge_zero_pmd(*pmd)) { + /* + * FIXME: Do we want to invalidate secondary mmu by calling + * mmu_notifier_invalidate_range() see comments below inside +@@ -2142,30 +2142,34 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd, + pte = pte_offset_map(&_pmd, addr); + BUG_ON(!pte_none(*pte)); + set_pte_at(mm, addr, pte, entry); +- atomic_inc(&page[i]._mapcount); +- pte_unmap(pte); +- } +- +- /* +- * Set PG_double_map before dropping compound_mapcount to avoid +- * false-negative page_mapped(). +- */ +- if (compound_mapcount(page) > 1 && !TestSetPageDoubleMap(page)) { +- for (i = 0; i < HPAGE_PMD_NR; i++) ++ if (!pmd_migration) + atomic_inc(&page[i]._mapcount); ++ pte_unmap(pte); + } + +- lock_page_memcg(page); +- if (atomic_add_negative(-1, compound_mapcount_ptr(page))) { +- /* Last compound_mapcount is gone. */ +- __dec_lruvec_page_state(page, NR_ANON_THPS); +- if (TestClearPageDoubleMap(page)) { +- /* No need in mapcount reference anymore */ ++ if (!pmd_migration) { ++ /* ++ * Set PG_double_map before dropping compound_mapcount to avoid ++ * false-negative page_mapped(). ++ */ ++ if (compound_mapcount(page) > 1 && ++ !TestSetPageDoubleMap(page)) { + for (i = 0; i < HPAGE_PMD_NR; i++) +- atomic_dec(&page[i]._mapcount); ++ atomic_inc(&page[i]._mapcount); ++ } ++ ++ lock_page_memcg(page); ++ if (atomic_add_negative(-1, compound_mapcount_ptr(page))) { ++ /* Last compound_mapcount is gone. */ ++ __dec_lruvec_page_state(page, NR_ANON_THPS); ++ if (TestClearPageDoubleMap(page)) { ++ /* No need in mapcount reference anymore */ ++ for (i = 0; i < HPAGE_PMD_NR; i++) ++ atomic_dec(&page[i]._mapcount); ++ } + } ++ unlock_page_memcg(page); + } +- unlock_page_memcg(page); + + smp_wmb(); /* make pte visible before pmd */ + pmd_populate(mm, pmd, pgtable); +diff --git a/mm/ksm.c b/mm/ksm.c +index 4102034cd55a1..f16983394b228 100644 +--- a/mm/ksm.c ++++ b/mm/ksm.c +@@ -2585,6 +2585,10 @@ struct page *ksm_might_need_to_copy(struct page *page, + return page; /* let do_swap_page report the error */ + + new_page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, address); ++ if (new_page && mem_cgroup_charge(new_page, vma->vm_mm, GFP_KERNEL)) { ++ put_page(new_page); ++ new_page = NULL; ++ } + if (new_page) { + copy_user_highpage(new_page, page, address, vma); + +diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c +index 76c75a599da3f..e76de2067bfd1 100644 +--- a/mm/memory_hotplug.c ++++ b/mm/memory_hotplug.c +@@ -1557,6 +1557,20 @@ static int __ref __offline_pages(unsigned long start_pfn, + /* check again */ + ret = walk_system_ram_range(start_pfn, end_pfn - start_pfn, + NULL, check_pages_isolated_cb); ++ /* ++ * per-cpu pages are drained in start_isolate_page_range, but if ++ * there are still pages that are not free, make sure that we ++ * drain again, because when we isolated range we might ++ * have raced with another thread that was adding pages to pcp ++ * list. ++ * ++ * Forward progress should be still guaranteed because ++ * pages on the pcp list can only belong to MOVABLE_ZONE ++ * because has_unmovable_pages explicitly checks for ++ * PageBuddy on freed pages on other zones. ++ */ ++ if (ret) ++ drain_all_pages(zone); + } while (ret); + + /* Ok, all of our target is isolated. +diff --git a/mm/page_isolation.c b/mm/page_isolation.c +index f6d07c5f0d34d..5b4a28b2dbf56 100644 +--- a/mm/page_isolation.c ++++ b/mm/page_isolation.c +@@ -170,6 +170,14 @@ __first_valid_page(unsigned long pfn, unsigned long nr_pages) + * pageblocks we may have modified and return -EBUSY to caller. This + * prevents two threads from simultaneously working on overlapping ranges. + * ++ * Please note that there is no strong synchronization with the page allocator ++ * either. Pages might be freed while their page blocks are marked ISOLATED. ++ * In some cases pages might still end up on pcp lists and that would allow ++ * for their allocation even when they are in fact isolated already. Depending ++ * on how strong of a guarantee the caller needs drain_all_pages might be needed ++ * (e.g. __offline_pages will need to call it after check for isolated range for ++ * a next retry). ++ * + * Return: the number of isolated pageblocks on success and -EBUSY if any part + * of range cannot be isolated. + */ +diff --git a/mm/percpu.c b/mm/percpu.c +index 696367b182221..d83e0032cb209 100644 +--- a/mm/percpu.c ++++ b/mm/percpu.c +@@ -1300,7 +1300,7 @@ static struct pcpu_chunk * __init pcpu_alloc_first_chunk(unsigned long tmp_addr, + + /* allocate chunk */ + alloc_size = sizeof(struct pcpu_chunk) + +- BITS_TO_LONGS(region_size >> PAGE_SHIFT); ++ BITS_TO_LONGS(region_size >> PAGE_SHIFT) * sizeof(unsigned long); + chunk = memblock_alloc(alloc_size, SMP_CACHE_BYTES); + if (!chunk) + panic("%s: Failed to allocate %zu bytes\n", __func__, +diff --git a/mm/vmscan.c b/mm/vmscan.c +index 749d239c62b2b..8b97bc615d8c0 100644 +--- a/mm/vmscan.c ++++ b/mm/vmscan.c +@@ -2619,6 +2619,14 @@ static void shrink_node_memcgs(pg_data_t *pgdat, struct scan_control *sc) + unsigned long reclaimed; + unsigned long scanned; + ++ /* ++ * This loop can become CPU-bound when target memcgs ++ * aren't eligible for reclaim - either because they ++ * don't have any reclaimable pages, or because their ++ * memory is explicitly protected. Avoid soft lockups. ++ */ ++ cond_resched(); ++ + switch (mem_cgroup_protected(target_memcg, memcg)) { + case MEMCG_PROT_MIN: + /* +diff --git a/net/core/skbuff.c b/net/core/skbuff.c +index 7afe52bd038ba..c50bd7a7943ab 100644 +--- a/net/core/skbuff.c ++++ b/net/core/skbuff.c +@@ -5988,9 +5988,13 @@ static int pskb_carve_inside_nonlinear(struct sk_buff *skb, const u32 off, + if (skb_has_frag_list(skb)) + skb_clone_fraglist(skb); + +- if (k == 0) { +- /* split line is in frag list */ +- pskb_carve_frag_list(skb, shinfo, off - pos, gfp_mask); ++ /* split line is in frag list */ ++ if (k == 0 && pskb_carve_frag_list(skb, shinfo, off - pos, gfp_mask)) { ++ /* skb_frag_unref() is not needed here as shinfo->nr_frags = 0. */ ++ if (skb_has_frag_list(skb)) ++ kfree_skb_list(skb_shinfo(skb)->frag_list); ++ kfree(data); ++ return -ENOMEM; + } + skb_release_data(skb); + +diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c +index 939e445d5188c..5542e8061955f 100644 +--- a/net/mptcp/protocol.c ++++ b/net/mptcp/protocol.c +@@ -605,8 +605,10 @@ static int mptcp_sendmsg_frag(struct sock *sk, struct sock *ssk, + if (!psize) + return -EINVAL; + +- if (!sk_wmem_schedule(sk, psize + dfrag->overhead)) ++ if (!sk_wmem_schedule(sk, psize + dfrag->overhead)) { ++ iov_iter_revert(&msg->msg_iter, psize); + return -ENOMEM; ++ } + } else { + offset = dfrag->offset; + psize = min_t(size_t, dfrag->data_len, avail_size); +@@ -617,8 +619,10 @@ static int mptcp_sendmsg_frag(struct sock *sk, struct sock *ssk, + */ + ret = do_tcp_sendpages(ssk, page, offset, psize, + msg->msg_flags | MSG_SENDPAGE_NOTLAST | MSG_DONTWAIT); +- if (ret <= 0) ++ if (ret <= 0) { ++ iov_iter_revert(&msg->msg_iter, psize); + return ret; ++ } + + frag_truesize += ret; + if (!retransmission) { +diff --git a/net/sunrpc/rpcb_clnt.c b/net/sunrpc/rpcb_clnt.c +index c27123e6ba80c..4a67685c83eb4 100644 +--- a/net/sunrpc/rpcb_clnt.c ++++ b/net/sunrpc/rpcb_clnt.c +@@ -982,8 +982,8 @@ static int rpcb_dec_getaddr(struct rpc_rqst *req, struct xdr_stream *xdr, + p = xdr_inline_decode(xdr, len); + if (unlikely(p == NULL)) + goto out_fail; +- dprintk("RPC: %5u RPCB_%s reply: %s\n", req->rq_task->tk_pid, +- req->rq_task->tk_msg.rpc_proc->p_name, (char *)p); ++ dprintk("RPC: %5u RPCB_%s reply: %*pE\n", req->rq_task->tk_pid, ++ req->rq_task->tk_msg.rpc_proc->p_name, len, (char *)p); + + if (rpc_uaddr2sockaddr(req->rq_xprt->xprt_net, (char *)p, len, + sap, sizeof(address)) == 0) +diff --git a/net/sunrpc/xprtrdma/verbs.c b/net/sunrpc/xprtrdma/verbs.c +index 75c646743df3e..ca89f24a1590b 100644 +--- a/net/sunrpc/xprtrdma/verbs.c ++++ b/net/sunrpc/xprtrdma/verbs.c +@@ -933,6 +933,8 @@ static void rpcrdma_req_reset(struct rpcrdma_req *req) + + rpcrdma_regbuf_dma_unmap(req->rl_sendbuf); + rpcrdma_regbuf_dma_unmap(req->rl_recvbuf); ++ ++ frwr_reset(req); + } + + /* ASSUMPTION: the rb_allreqs list is stable for the duration, +diff --git a/scripts/kconfig/qconf.cc b/scripts/kconfig/qconf.cc +index 5ceb93010a973..aedcc3343719e 100644 +--- a/scripts/kconfig/qconf.cc ++++ b/scripts/kconfig/qconf.cc +@@ -1263,7 +1263,7 @@ void ConfigInfoView::clicked(const QUrl &url) + } + + free(result); +- delete data; ++ delete[] data; + } + + QMenu* ConfigInfoView::createStandardContextMenu(const QPoint & pos) +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index 0b9907c9cd84f..77e2e6ede31dc 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -2467,7 +2467,6 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { + SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD), +- SND_PCI_QUIRK(0x1462, 0x9c37, "MSI X570-A PRO", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), + SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3), + SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX), +@@ -6005,6 +6004,40 @@ static void alc_fixup_disable_mic_vref(struct hda_codec *codec, + snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); + } + ++ ++static void alc294_gx502_toggle_output(struct hda_codec *codec, ++ struct hda_jack_callback *cb) ++{ ++ /* The Windows driver sets the codec up in a very different way where ++ * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it ++ */ ++ if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT) ++ alc_write_coef_idx(codec, 0x10, 0x8a20); ++ else ++ alc_write_coef_idx(codec, 0x10, 0x0a20); ++} ++ ++static void alc294_fixup_gx502_hp(struct hda_codec *codec, ++ const struct hda_fixup *fix, int action) ++{ ++ /* Pin 0x21: headphones/headset mic */ ++ if (!is_jack_detectable(codec, 0x21)) ++ return; ++ ++ switch (action) { ++ case HDA_FIXUP_ACT_PRE_PROBE: ++ snd_hda_jack_detect_enable_callback(codec, 0x21, ++ alc294_gx502_toggle_output); ++ break; ++ case HDA_FIXUP_ACT_INIT: ++ /* Make sure to start in a correct state, i.e. if ++ * headphones have been plugged in before powering up the system ++ */ ++ alc294_gx502_toggle_output(codec, NULL); ++ break; ++ } ++} ++ + static void alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec, + const struct hda_fixup *fix, int action) + { +@@ -6185,6 +6218,9 @@ enum { + ALC285_FIXUP_THINKPAD_HEADSET_JACK, + ALC294_FIXUP_ASUS_HPE, + ALC294_FIXUP_ASUS_COEF_1B, ++ ALC294_FIXUP_ASUS_GX502_HP, ++ ALC294_FIXUP_ASUS_GX502_PINS, ++ ALC294_FIXUP_ASUS_GX502_VERBS, + ALC285_FIXUP_HP_GPIO_LED, + ALC285_FIXUP_HP_MUTE_LED, + ALC236_FIXUP_HP_MUTE_LED, +@@ -6203,6 +6239,7 @@ enum { + ALC269_FIXUP_LEMOTE_A1802, + ALC269_FIXUP_LEMOTE_A190X, + ALC256_FIXUP_INTEL_NUC8_RUGGED, ++ ALC255_FIXUP_XIAOMI_HEADSET_MIC, + }; + + static const struct hda_fixup alc269_fixups[] = { +@@ -7350,6 +7387,33 @@ static const struct hda_fixup alc269_fixups[] = { + .chained = true, + .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC + }, ++ [ALC294_FIXUP_ASUS_GX502_PINS] = { ++ .type = HDA_FIXUP_PINS, ++ .v.pins = (const struct hda_pintbl[]) { ++ { 0x19, 0x03a11050 }, /* front HP mic */ ++ { 0x1a, 0x01a11830 }, /* rear external mic */ ++ { 0x21, 0x03211020 }, /* front HP out */ ++ { } ++ }, ++ .chained = true, ++ .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS ++ }, ++ [ALC294_FIXUP_ASUS_GX502_VERBS] = { ++ .type = HDA_FIXUP_VERBS, ++ .v.verbs = (const struct hda_verb[]) { ++ /* set 0x15 to HP-OUT ctrl */ ++ { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, ++ /* unmute the 0x15 amp */ ++ { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 }, ++ { } ++ }, ++ .chained = true, ++ .chain_id = ALC294_FIXUP_ASUS_GX502_HP ++ }, ++ [ALC294_FIXUP_ASUS_GX502_HP] = { ++ .type = HDA_FIXUP_FUNC, ++ .v.func = alc294_fixup_gx502_hp, ++ }, + [ALC294_FIXUP_ASUS_COEF_1B] = { + .type = HDA_FIXUP_VERBS, + .v.verbs = (const struct hda_verb[]) { +@@ -7539,6 +7603,16 @@ static const struct hda_fixup alc269_fixups[] = { + .chained = true, + .chain_id = ALC269_FIXUP_HEADSET_MODE + }, ++ [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = { ++ .type = HDA_FIXUP_VERBS, ++ .v.verbs = (const struct hda_verb[]) { ++ { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, ++ { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, ++ { } ++ }, ++ .chained = true, ++ .chain_id = ALC289_FIXUP_ASUS_GA401 ++ }, + }; + + static const struct snd_pci_quirk alc269_fixup_tbl[] = { +@@ -7723,6 +7797,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC), + SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502), + SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401), ++ SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS), + SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2), + SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC), + SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC), +@@ -7835,6 +7910,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI), + SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101), + SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */ ++ SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC), + SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC), + SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE), + SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802), +@@ -8012,6 +8088,7 @@ static const struct hda_model_fixup alc269_fixup_models[] = { + {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"}, + {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"}, + {.id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc298-samsung-headphone"}, ++ {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"}, + {} + }; + #define ALC225_STANDARD_PINS \ +diff --git a/sound/soc/codecs/rt1308-sdw.c b/sound/soc/codecs/rt1308-sdw.c +index b0ba0d2acbdd6..56e952a904a39 100644 +--- a/sound/soc/codecs/rt1308-sdw.c ++++ b/sound/soc/codecs/rt1308-sdw.c +@@ -684,8 +684,8 @@ static int rt1308_sdw_probe(struct sdw_slave *slave, + + /* Regmap Initialization */ + regmap = devm_regmap_init_sdw(slave, &rt1308_sdw_regmap); +- if (!regmap) +- return -EINVAL; ++ if (IS_ERR(regmap)) ++ return PTR_ERR(regmap); + + rt1308_sdw_init(&slave->dev, regmap, slave); + +diff --git a/sound/soc/codecs/rt700-sdw.c b/sound/soc/codecs/rt700-sdw.c +index 4d14048d11976..1d24bf0407182 100644 +--- a/sound/soc/codecs/rt700-sdw.c ++++ b/sound/soc/codecs/rt700-sdw.c +@@ -452,8 +452,8 @@ static int rt700_sdw_probe(struct sdw_slave *slave, + + /* Regmap Initialization */ + sdw_regmap = devm_regmap_init_sdw(slave, &rt700_sdw_regmap); +- if (!sdw_regmap) +- return -EINVAL; ++ if (IS_ERR(sdw_regmap)) ++ return PTR_ERR(sdw_regmap); + + regmap = devm_regmap_init(&slave->dev, NULL, + &slave->dev, &rt700_regmap); +diff --git a/sound/soc/codecs/rt711-sdw.c b/sound/soc/codecs/rt711-sdw.c +index 45b928954b580..7efff130a638c 100644 +--- a/sound/soc/codecs/rt711-sdw.c ++++ b/sound/soc/codecs/rt711-sdw.c +@@ -452,8 +452,8 @@ static int rt711_sdw_probe(struct sdw_slave *slave, + + /* Regmap Initialization */ + sdw_regmap = devm_regmap_init_sdw(slave, &rt711_sdw_regmap); +- if (!sdw_regmap) +- return -EINVAL; ++ if (IS_ERR(sdw_regmap)) ++ return PTR_ERR(sdw_regmap); + + regmap = devm_regmap_init(&slave->dev, NULL, + &slave->dev, &rt711_regmap); +diff --git a/sound/soc/codecs/rt715-sdw.c b/sound/soc/codecs/rt715-sdw.c +index d11b23d6b240a..68a36739f1b0d 100644 +--- a/sound/soc/codecs/rt715-sdw.c ++++ b/sound/soc/codecs/rt715-sdw.c +@@ -527,8 +527,8 @@ static int rt715_sdw_probe(struct sdw_slave *slave, + + /* Regmap Initialization */ + sdw_regmap = devm_regmap_init_sdw(slave, &rt715_sdw_regmap); +- if (!sdw_regmap) +- return -EINVAL; ++ if (IS_ERR(sdw_regmap)) ++ return PTR_ERR(sdw_regmap); + + regmap = devm_regmap_init(&slave->dev, NULL, &slave->dev, + &rt715_regmap); +diff --git a/sound/soc/codecs/tlv320adcx140.c b/sound/soc/codecs/tlv320adcx140.c +index 35fe8ee5bce9f..03fb50175d876 100644 +--- a/sound/soc/codecs/tlv320adcx140.c ++++ b/sound/soc/codecs/tlv320adcx140.c +@@ -930,6 +930,8 @@ static int adcx140_i2c_probe(struct i2c_client *i2c, + if (!adcx140) + return -ENOMEM; + ++ adcx140->dev = &i2c->dev; ++ + adcx140->gpio_reset = devm_gpiod_get_optional(adcx140->dev, + "reset", GPIOD_OUT_LOW); + if (IS_ERR(adcx140->gpio_reset)) +@@ -957,7 +959,7 @@ static int adcx140_i2c_probe(struct i2c_client *i2c, + ret); + return ret; + } +- adcx140->dev = &i2c->dev; ++ + i2c_set_clientdata(i2c, adcx140); + + return devm_snd_soc_register_component(&i2c->dev, +diff --git a/sound/soc/intel/boards/skl_hda_dsp_generic.c b/sound/soc/intel/boards/skl_hda_dsp_generic.c +index ca4900036ead9..bc50eda297ab7 100644 +--- a/sound/soc/intel/boards/skl_hda_dsp_generic.c ++++ b/sound/soc/intel/boards/skl_hda_dsp_generic.c +@@ -181,7 +181,7 @@ static void skl_set_hda_codec_autosuspend_delay(struct snd_soc_card *card) + struct snd_soc_dai *dai; + + for_each_card_rtds(card, rtd) { +- if (!strstr(rtd->dai_link->codecs->name, "ehdaudio")) ++ if (!strstr(rtd->dai_link->codecs->name, "ehdaudio0D0")) + continue; + dai = asoc_rtd_to_codec(rtd, 0); + hda_pvt = snd_soc_component_get_drvdata(dai->component); +diff --git a/sound/soc/intel/haswell/sst-haswell-dsp.c b/sound/soc/intel/haswell/sst-haswell-dsp.c +index de80e19454c13..88c3f63bded90 100644 +--- a/sound/soc/intel/haswell/sst-haswell-dsp.c ++++ b/sound/soc/intel/haswell/sst-haswell-dsp.c +@@ -243,92 +243,45 @@ static irqreturn_t hsw_irq(int irq, void *context) + return ret; + } + +-#define CSR_DEFAULT_VALUE 0x8480040E +-#define ISC_DEFAULT_VALUE 0x0 +-#define ISD_DEFAULT_VALUE 0x0 +-#define IMC_DEFAULT_VALUE 0x7FFF0003 +-#define IMD_DEFAULT_VALUE 0x7FFF0003 +-#define IPCC_DEFAULT_VALUE 0x0 +-#define IPCD_DEFAULT_VALUE 0x0 +-#define CLKCTL_DEFAULT_VALUE 0x7FF +-#define CSR2_DEFAULT_VALUE 0x0 +-#define LTR_CTRL_DEFAULT_VALUE 0x0 +-#define HMD_CTRL_DEFAULT_VALUE 0x0 +- +-static void hsw_set_shim_defaults(struct sst_dsp *sst) +-{ +- sst_dsp_shim_write_unlocked(sst, SST_CSR, CSR_DEFAULT_VALUE); +- sst_dsp_shim_write_unlocked(sst, SST_ISRX, ISC_DEFAULT_VALUE); +- sst_dsp_shim_write_unlocked(sst, SST_ISRD, ISD_DEFAULT_VALUE); +- sst_dsp_shim_write_unlocked(sst, SST_IMRX, IMC_DEFAULT_VALUE); +- sst_dsp_shim_write_unlocked(sst, SST_IMRD, IMD_DEFAULT_VALUE); +- sst_dsp_shim_write_unlocked(sst, SST_IPCX, IPCC_DEFAULT_VALUE); +- sst_dsp_shim_write_unlocked(sst, SST_IPCD, IPCD_DEFAULT_VALUE); +- sst_dsp_shim_write_unlocked(sst, SST_CLKCTL, CLKCTL_DEFAULT_VALUE); +- sst_dsp_shim_write_unlocked(sst, SST_CSR2, CSR2_DEFAULT_VALUE); +- sst_dsp_shim_write_unlocked(sst, SST_LTRC, LTR_CTRL_DEFAULT_VALUE); +- sst_dsp_shim_write_unlocked(sst, SST_HMDC, HMD_CTRL_DEFAULT_VALUE); +-} +- +-/* all clock-gating minus DCLCGE and DTCGE */ +-#define SST_VDRTCL2_CG_OTHER 0xB7D +- + static void hsw_set_dsp_D3(struct sst_dsp *sst) + { ++ u32 val; + u32 reg; + +- /* disable clock core gating */ ++ /* Disable core clock gating (VDRTCTL2.DCLCGE = 0) */ + reg = readl(sst->addr.pci_cfg + SST_VDRTCTL2); +- reg &= ~(SST_VDRTCL2_DCLCGE); ++ reg &= ~(SST_VDRTCL2_DCLCGE | SST_VDRTCL2_DTCGE); + writel(reg, sst->addr.pci_cfg + SST_VDRTCTL2); + +- /* stall, reset and set 24MHz XOSC */ +- sst_dsp_shim_update_bits_unlocked(sst, SST_CSR, +- SST_CSR_24MHZ_LPCS | SST_CSR_STALL | SST_CSR_RST, +- SST_CSR_24MHZ_LPCS | SST_CSR_STALL | SST_CSR_RST); +- +- /* DRAM power gating all */ +- reg = readl(sst->addr.pci_cfg + SST_VDRTCTL0); +- reg |= SST_VDRTCL0_ISRAMPGE_MASK | +- SST_VDRTCL0_DSRAMPGE_MASK; +- reg &= ~(SST_VDRTCL0_D3SRAMPGD); +- reg |= SST_VDRTCL0_D3PGD; +- writel(reg, sst->addr.pci_cfg + SST_VDRTCTL0); +- udelay(50); ++ /* enable power gating and switch off DRAM & IRAM blocks */ ++ val = readl(sst->addr.pci_cfg + SST_VDRTCTL0); ++ val |= SST_VDRTCL0_DSRAMPGE_MASK | ++ SST_VDRTCL0_ISRAMPGE_MASK; ++ val &= ~(SST_VDRTCL0_D3PGD | SST_VDRTCL0_D3SRAMPGD); ++ writel(val, sst->addr.pci_cfg + SST_VDRTCTL0); + +- /* PLL shutdown enable */ +- reg = readl(sst->addr.pci_cfg + SST_VDRTCTL2); +- reg |= SST_VDRTCL2_APLLSE_MASK; +- writel(reg, sst->addr.pci_cfg + SST_VDRTCTL2); ++ /* switch off audio PLL */ ++ val = readl(sst->addr.pci_cfg + SST_VDRTCTL2); ++ val |= SST_VDRTCL2_APLLSE_MASK; ++ writel(val, sst->addr.pci_cfg + SST_VDRTCTL2); + +- /* disable MCLK */ ++ /* disable MCLK(clkctl.smos = 0) */ + sst_dsp_shim_update_bits_unlocked(sst, SST_CLKCTL, +- SST_CLKCTL_MASK, 0); +- +- /* switch clock gating */ +- reg = readl(sst->addr.pci_cfg + SST_VDRTCTL2); +- reg |= SST_VDRTCL2_CG_OTHER; +- reg &= ~(SST_VDRTCL2_DTCGE); +- writel(reg, sst->addr.pci_cfg + SST_VDRTCTL2); +- /* enable DTCGE separatelly */ +- reg = readl(sst->addr.pci_cfg + SST_VDRTCTL2); +- reg |= SST_VDRTCL2_DTCGE; +- writel(reg, sst->addr.pci_cfg + SST_VDRTCTL2); ++ SST_CLKCTL_MASK, 0); + +- /* set shim defaults */ +- hsw_set_shim_defaults(sst); +- +- /* set D3 */ +- reg = readl(sst->addr.pci_cfg + SST_PMCS); +- reg |= SST_PMCS_PS_MASK; +- writel(reg, sst->addr.pci_cfg + SST_PMCS); ++ /* Set D3 state, delay 50 us */ ++ val = readl(sst->addr.pci_cfg + SST_PMCS); ++ val |= SST_PMCS_PS_MASK; ++ writel(val, sst->addr.pci_cfg + SST_PMCS); + udelay(50); + +- /* enable clock core gating */ ++ /* Enable core clock gating (VDRTCTL2.DCLCGE = 1), delay 50 us */ + reg = readl(sst->addr.pci_cfg + SST_VDRTCTL2); +- reg |= SST_VDRTCL2_DCLCGE; ++ reg |= SST_VDRTCL2_DCLCGE | SST_VDRTCL2_DTCGE; + writel(reg, sst->addr.pci_cfg + SST_VDRTCTL2); ++ + udelay(50); ++ + } + + static void hsw_reset(struct sst_dsp *sst) +@@ -346,62 +299,75 @@ static void hsw_reset(struct sst_dsp *sst) + SST_CSR_RST | SST_CSR_STALL, SST_CSR_STALL); + } + +-/* recommended CSR state for power-up */ +-#define SST_CSR_D0_MASK (0x18A09C0C | SST_CSR_DCS_MASK) +- + static int hsw_set_dsp_D0(struct sst_dsp *sst) + { +- u32 reg; ++ int tries = 10; ++ u32 reg, fw_dump_bit; + +- /* disable clock core gating */ ++ /* Disable core clock gating (VDRTCTL2.DCLCGE = 0) */ + reg = readl(sst->addr.pci_cfg + SST_VDRTCTL2); +- reg &= ~(SST_VDRTCL2_DCLCGE); ++ reg &= ~(SST_VDRTCL2_DCLCGE | SST_VDRTCL2_DTCGE); + writel(reg, sst->addr.pci_cfg + SST_VDRTCTL2); + +- /* switch clock gating */ +- reg = readl(sst->addr.pci_cfg + SST_VDRTCTL2); +- reg |= SST_VDRTCL2_CG_OTHER; +- reg &= ~(SST_VDRTCL2_DTCGE); +- writel(reg, sst->addr.pci_cfg + SST_VDRTCTL2); ++ /* Disable D3PG (VDRTCTL0.D3PGD = 1) */ ++ reg = readl(sst->addr.pci_cfg + SST_VDRTCTL0); ++ reg |= SST_VDRTCL0_D3PGD; ++ writel(reg, sst->addr.pci_cfg + SST_VDRTCTL0); + +- /* set D0 */ ++ /* Set D0 state */ + reg = readl(sst->addr.pci_cfg + SST_PMCS); +- reg &= ~(SST_PMCS_PS_MASK); ++ reg &= ~SST_PMCS_PS_MASK; + writel(reg, sst->addr.pci_cfg + SST_PMCS); + +- /* DRAM power gating none */ +- reg = readl(sst->addr.pci_cfg + SST_VDRTCTL0); +- reg &= ~(SST_VDRTCL0_ISRAMPGE_MASK | +- SST_VDRTCL0_DSRAMPGE_MASK); +- reg |= SST_VDRTCL0_D3SRAMPGD; +- reg |= SST_VDRTCL0_D3PGD; +- writel(reg, sst->addr.pci_cfg + SST_VDRTCTL0); +- mdelay(10); ++ /* check that ADSP shim is enabled */ ++ while (tries--) { ++ reg = readl(sst->addr.pci_cfg + SST_PMCS) & SST_PMCS_PS_MASK; ++ if (reg == 0) ++ goto finish; ++ ++ msleep(1); ++ } ++ ++ return -ENODEV; + +- /* set shim defaults */ +- hsw_set_shim_defaults(sst); ++finish: ++ /* select SSP1 19.2MHz base clock, SSP clock 0, turn off Low Power Clock */ ++ sst_dsp_shim_update_bits_unlocked(sst, SST_CSR, ++ SST_CSR_S1IOCS | SST_CSR_SBCS1 | SST_CSR_LPCS, 0x0); ++ ++ /* stall DSP core, set clk to 192/96Mhz */ ++ sst_dsp_shim_update_bits_unlocked(sst, ++ SST_CSR, SST_CSR_STALL | SST_CSR_DCS_MASK, ++ SST_CSR_STALL | SST_CSR_DCS(4)); + +- /* restore MCLK */ ++ /* Set 24MHz MCLK, prevent local clock gating, enable SSP0 clock */ + sst_dsp_shim_update_bits_unlocked(sst, SST_CLKCTL, +- SST_CLKCTL_MASK, SST_CLKCTL_MASK); ++ SST_CLKCTL_MASK | SST_CLKCTL_DCPLCG | SST_CLKCTL_SCOE0, ++ SST_CLKCTL_MASK | SST_CLKCTL_DCPLCG | SST_CLKCTL_SCOE0); + +- /* PLL shutdown disable */ ++ /* Stall and reset core, set CSR */ ++ hsw_reset(sst); ++ ++ /* Enable core clock gating (VDRTCTL2.DCLCGE = 1), delay 50 us */ + reg = readl(sst->addr.pci_cfg + SST_VDRTCTL2); +- reg &= ~(SST_VDRTCL2_APLLSE_MASK); ++ reg |= SST_VDRTCL2_DCLCGE | SST_VDRTCL2_DTCGE; + writel(reg, sst->addr.pci_cfg + SST_VDRTCTL2); + +- sst_dsp_shim_update_bits_unlocked(sst, SST_CSR, +- SST_CSR_D0_MASK, SST_CSR_SBCS0 | SST_CSR_SBCS1 | +- SST_CSR_STALL | SST_CSR_DCS(4)); + udelay(50); + +- /* enable clock core gating */ ++ /* switch on audio PLL */ + reg = readl(sst->addr.pci_cfg + SST_VDRTCTL2); +- reg |= SST_VDRTCL2_DCLCGE; ++ reg &= ~SST_VDRTCL2_APLLSE_MASK; + writel(reg, sst->addr.pci_cfg + SST_VDRTCTL2); + +- /* clear reset */ +- sst_dsp_shim_update_bits_unlocked(sst, SST_CSR, SST_CSR_RST, 0); ++ /* set default power gating control, enable power gating control for all blocks. that is, ++ can't be accessed, please enable each block before accessing. */ ++ reg = readl(sst->addr.pci_cfg + SST_VDRTCTL0); ++ reg |= SST_VDRTCL0_DSRAMPGE_MASK | SST_VDRTCL0_ISRAMPGE_MASK; ++ /* for D0, always enable the block(DSRAM[0]) used for FW dump */ ++ fw_dump_bit = 1 << SST_VDRTCL0_DSRAMPGE_SHIFT; ++ writel(reg & ~fw_dump_bit, sst->addr.pci_cfg + SST_VDRTCTL0); ++ + + /* disable DMA finish function for SSP0 & SSP1 */ + sst_dsp_shim_update_bits_unlocked(sst, SST_CSR2, SST_CSR2_SDFD_SSP1, +@@ -418,6 +384,12 @@ static int hsw_set_dsp_D0(struct sst_dsp *sst) + sst_dsp_shim_update_bits(sst, SST_IMRD, (SST_IMRD_DONE | SST_IMRD_BUSY | + SST_IMRD_SSP0 | SST_IMRD_DMAC), 0x0); + ++ /* clear IPC registers */ ++ sst_dsp_shim_write(sst, SST_IPCX, 0x0); ++ sst_dsp_shim_write(sst, SST_IPCD, 0x0); ++ sst_dsp_shim_write(sst, 0x80, 0x6); ++ sst_dsp_shim_write(sst, 0xe0, 0x300a); ++ + return 0; + } + +@@ -443,6 +415,11 @@ static void hsw_sleep(struct sst_dsp *sst) + { + dev_dbg(sst->dev, "HSW_PM dsp runtime suspend\n"); + ++ /* put DSP into reset and stall */ ++ sst_dsp_shim_update_bits(sst, SST_CSR, ++ SST_CSR_24MHZ_LPCS | SST_CSR_RST | SST_CSR_STALL, ++ SST_CSR_RST | SST_CSR_STALL | SST_CSR_24MHZ_LPCS); ++ + hsw_set_dsp_D3(sst); + dev_dbg(sst->dev, "HSW_PM dsp runtime suspend exit\n"); + } +diff --git a/sound/soc/meson/axg-toddr.c b/sound/soc/meson/axg-toddr.c +index e711abcf8c124..d6adf7edea41f 100644 +--- a/sound/soc/meson/axg-toddr.c ++++ b/sound/soc/meson/axg-toddr.c +@@ -18,6 +18,7 @@ + #define CTRL0_TODDR_SEL_RESAMPLE BIT(30) + #define CTRL0_TODDR_EXT_SIGNED BIT(29) + #define CTRL0_TODDR_PP_MODE BIT(28) ++#define CTRL0_TODDR_SYNC_CH BIT(27) + #define CTRL0_TODDR_TYPE_MASK GENMASK(15, 13) + #define CTRL0_TODDR_TYPE(x) ((x) << 13) + #define CTRL0_TODDR_MSB_POS_MASK GENMASK(12, 8) +@@ -189,10 +190,31 @@ static const struct axg_fifo_match_data axg_toddr_match_data = { + .dai_drv = &axg_toddr_dai_drv + }; + ++static int g12a_toddr_dai_startup(struct snd_pcm_substream *substream, ++ struct snd_soc_dai *dai) ++{ ++ struct axg_fifo *fifo = snd_soc_dai_get_drvdata(dai); ++ int ret; ++ ++ ret = axg_toddr_dai_startup(substream, dai); ++ if (ret) ++ return ret; ++ ++ /* ++ * Make sure the first channel ends up in the at beginning of the output ++ * As weird as it looks, without this the first channel may be misplaced ++ * in memory, with a random shift of 2 channels. ++ */ ++ regmap_update_bits(fifo->map, FIFO_CTRL0, CTRL0_TODDR_SYNC_CH, ++ CTRL0_TODDR_SYNC_CH); ++ ++ return 0; ++} ++ + static const struct snd_soc_dai_ops g12a_toddr_ops = { + .prepare = g12a_toddr_dai_prepare, + .hw_params = axg_toddr_dai_hw_params, +- .startup = axg_toddr_dai_startup, ++ .startup = g12a_toddr_dai_startup, + .shutdown = axg_toddr_dai_shutdown, + }; + +diff --git a/sound/soc/qcom/apq8016_sbc.c b/sound/soc/qcom/apq8016_sbc.c +index 2ef090f4af9e9..8abc1a95184b2 100644 +--- a/sound/soc/qcom/apq8016_sbc.c ++++ b/sound/soc/qcom/apq8016_sbc.c +@@ -234,6 +234,7 @@ static int apq8016_sbc_platform_probe(struct platform_device *pdev) + return -ENOMEM; + + card->dev = dev; ++ card->owner = THIS_MODULE; + card->dapm_widgets = apq8016_sbc_dapm_widgets; + card->num_dapm_widgets = ARRAY_SIZE(apq8016_sbc_dapm_widgets); + data = apq8016_sbc_parse_of(card); +diff --git a/sound/soc/qcom/apq8096.c b/sound/soc/qcom/apq8096.c +index 287ad2aa27f37..d47bedc259c59 100644 +--- a/sound/soc/qcom/apq8096.c ++++ b/sound/soc/qcom/apq8096.c +@@ -114,6 +114,7 @@ static int apq8096_platform_probe(struct platform_device *pdev) + return -ENOMEM; + + card->dev = dev; ++ card->owner = THIS_MODULE; + dev_set_drvdata(dev, card); + ret = qcom_snd_parse_of(card); + if (ret) +diff --git a/sound/soc/qcom/common.c b/sound/soc/qcom/common.c +index 8ada4ecba8472..10322690c0eaa 100644 +--- a/sound/soc/qcom/common.c ++++ b/sound/soc/qcom/common.c +@@ -45,8 +45,10 @@ int qcom_snd_parse_of(struct snd_soc_card *card) + + for_each_child_of_node(dev->of_node, np) { + dlc = devm_kzalloc(dev, 2 * sizeof(*dlc), GFP_KERNEL); +- if (!dlc) +- return -ENOMEM; ++ if (!dlc) { ++ ret = -ENOMEM; ++ goto err; ++ } + + link->cpus = &dlc[0]; + link->platforms = &dlc[1]; +diff --git a/sound/soc/qcom/sdm845.c b/sound/soc/qcom/sdm845.c +index 68e9388ff46f1..b5b8465caf56f 100644 +--- a/sound/soc/qcom/sdm845.c ++++ b/sound/soc/qcom/sdm845.c +@@ -557,6 +557,7 @@ static int sdm845_snd_platform_probe(struct platform_device *pdev) + card->dapm_widgets = sdm845_snd_widgets; + card->num_dapm_widgets = ARRAY_SIZE(sdm845_snd_widgets); + card->dev = dev; ++ card->owner = THIS_MODULE; + dev_set_drvdata(dev, card); + ret = qcom_snd_parse_of(card); + if (ret) +diff --git a/sound/soc/qcom/storm.c b/sound/soc/qcom/storm.c +index 3a6e18709b9e2..4ba111c841375 100644 +--- a/sound/soc/qcom/storm.c ++++ b/sound/soc/qcom/storm.c +@@ -96,6 +96,7 @@ static int storm_platform_probe(struct platform_device *pdev) + return -ENOMEM; + + card->dev = &pdev->dev; ++ card->owner = THIS_MODULE; + + ret = snd_soc_of_parse_card_name(card, "qcom,model"); + if (ret) { +diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c +index f1d641cd48da9..20ca1d38b4b87 100644 +--- a/sound/soc/soc-core.c ++++ b/sound/soc/soc-core.c +@@ -834,6 +834,19 @@ struct snd_soc_dai *snd_soc_find_dai( + } + EXPORT_SYMBOL_GPL(snd_soc_find_dai); + ++struct snd_soc_dai *snd_soc_find_dai_with_mutex( ++ const struct snd_soc_dai_link_component *dlc) ++{ ++ struct snd_soc_dai *dai; ++ ++ mutex_lock(&client_mutex); ++ dai = snd_soc_find_dai(dlc); ++ mutex_unlock(&client_mutex); ++ ++ return dai; ++} ++EXPORT_SYMBOL_GPL(snd_soc_find_dai_with_mutex); ++ + static int soc_dai_link_sanity_check(struct snd_soc_card *card, + struct snd_soc_dai_link *link) + { +diff --git a/sound/soc/soc-dai.c b/sound/soc/soc-dai.c +index cecbbed2de9d5..0e04ad7689cd9 100644 +--- a/sound/soc/soc-dai.c ++++ b/sound/soc/soc-dai.c +@@ -410,14 +410,14 @@ void snd_soc_dai_link_set_capabilities(struct snd_soc_dai_link *dai_link) + supported_codec = false; + + for_each_link_cpus(dai_link, i, cpu) { +- dai = snd_soc_find_dai(cpu); ++ dai = snd_soc_find_dai_with_mutex(cpu); + if (dai && snd_soc_dai_stream_valid(dai, direction)) { + supported_cpu = true; + break; + } + } + for_each_link_codecs(dai_link, i, codec) { +- dai = snd_soc_find_dai(codec); ++ dai = snd_soc_find_dai_with_mutex(codec); + if (dai && snd_soc_dai_stream_valid(dai, direction)) { + supported_codec = true; + break; +diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c +index 74baf1fce053f..918ed77726cc0 100644 +--- a/sound/soc/soc-pcm.c ++++ b/sound/soc/soc-pcm.c +@@ -811,7 +811,7 @@ dynamic: + return 0; + + config_err: +- for_each_rtd_dais(rtd, i, dai) ++ for_each_rtd_dais_rollback(rtd, i, dai) + snd_soc_dai_shutdown(dai, substream); + + snd_soc_link_shutdown(substream); +diff --git a/tools/perf/tests/bp_signal.c b/tools/perf/tests/bp_signal.c +index da8ec1e8e0648..cc9fbcedb3646 100644 +--- a/tools/perf/tests/bp_signal.c ++++ b/tools/perf/tests/bp_signal.c +@@ -45,10 +45,13 @@ volatile long the_var; + #if defined (__x86_64__) + extern void __test_function(volatile long *ptr); + asm ( ++ ".pushsection .text;" + ".globl __test_function\n" ++ ".type __test_function, @function;" + "__test_function:\n" + "incq (%rdi)\n" +- "ret\n"); ++ "ret\n" ++ ".popsection\n"); + #else + static void __test_function(volatile long *ptr) + { +diff --git a/tools/perf/tests/pmu-events.c b/tools/perf/tests/pmu-events.c +index ab64b4a4e2848..343d36965836a 100644 +--- a/tools/perf/tests/pmu-events.c ++++ b/tools/perf/tests/pmu-events.c +@@ -274,6 +274,7 @@ static int __test__pmu_event_aliases(char *pmu_name, int *count) + int res = 0; + bool use_uncore_table; + struct pmu_events_map *map = __test_pmu_get_events_map(); ++ struct perf_pmu_alias *a, *tmp; + + if (!map) + return -1; +@@ -347,6 +348,10 @@ static int __test__pmu_event_aliases(char *pmu_name, int *count) + pmu_name, alias->name); + } + ++ list_for_each_entry_safe(a, tmp, &aliases, list) { ++ list_del(&a->list); ++ perf_pmu_free_alias(a); ++ } + free(pmu); + return res; + } +diff --git a/tools/perf/tests/pmu.c b/tools/perf/tests/pmu.c +index 5c11fe2b30406..714e6830a758f 100644 +--- a/tools/perf/tests/pmu.c ++++ b/tools/perf/tests/pmu.c +@@ -173,6 +173,7 @@ int test__pmu(struct test *test __maybe_unused, int subtest __maybe_unused) + ret = 0; + } while (0); + ++ perf_pmu__del_formats(&formats); + test_format_dir_put(format); + return ret; + } +diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c +index ab48be4cf2584..b279888bb1aab 100644 +--- a/tools/perf/util/evlist.c ++++ b/tools/perf/util/evlist.c +@@ -946,6 +946,10 @@ int perf_evlist__create_maps(struct evlist *evlist, struct target *target) + + perf_evlist__set_maps(&evlist->core, cpus, threads); + ++ /* as evlist now has references, put count here */ ++ perf_cpu_map__put(cpus); ++ perf_thread_map__put(threads); ++ + return 0; + + out_delete_threads: +@@ -1273,11 +1277,12 @@ static int perf_evlist__create_syswide_maps(struct evlist *evlist) + goto out_put; + + perf_evlist__set_maps(&evlist->core, cpus, threads); +-out: +- return err; ++ ++ perf_thread_map__put(threads); + out_put: + perf_cpu_map__put(cpus); +- goto out; ++out: ++ return err; + } + + int evlist__open(struct evlist *evlist) +diff --git a/tools/perf/util/metricgroup.c b/tools/perf/util/metricgroup.c +index 9e21aa767e417..344a75718afc3 100644 +--- a/tools/perf/util/metricgroup.c ++++ b/tools/perf/util/metricgroup.c +@@ -443,6 +443,9 @@ void metricgroup__print(bool metrics, bool metricgroups, char *filter, + continue; + strlist__add(me->metrics, s); + } ++ ++ if (!raw) ++ free(s); + } + free(omg); + } +@@ -726,7 +729,7 @@ int metricgroup__parse_groups(const struct option *opt, + ret = metricgroup__add_metric_list(str, metric_no_group, + &extra_events, &group_list); + if (ret) +- return ret; ++ goto out; + pr_debug("adding %s\n", extra_events.buf); + bzero(&parse_error, sizeof(parse_error)); + ret = parse_events(perf_evlist, extra_events.buf, &parse_error); +@@ -734,11 +737,11 @@ int metricgroup__parse_groups(const struct option *opt, + parse_events_print_error(&parse_error, extra_events.buf); + goto out; + } +- strbuf_release(&extra_events); + ret = metricgroup__setup_events(&group_list, metric_no_merge, + perf_evlist, metric_events); + out: + metricgroup__free_egroups(&group_list); ++ strbuf_release(&extra_events); + return ret; + } + +diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c +index 4476de0e678aa..c1120d8196fae 100644 +--- a/tools/perf/util/parse-events.c ++++ b/tools/perf/util/parse-events.c +@@ -410,7 +410,7 @@ static int add_event_tool(struct list_head *list, int *idx, + return -ENOMEM; + evsel->tool_event = tool_event; + if (tool_event == PERF_TOOL_DURATION_TIME) +- evsel->unit = strdup("ns"); ++ evsel->unit = "ns"; + return 0; + } + +diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c +index 93fe72a9dc0b2..483da97ac4459 100644 +--- a/tools/perf/util/pmu.c ++++ b/tools/perf/util/pmu.c +@@ -272,7 +272,7 @@ static void perf_pmu_update_alias(struct perf_pmu_alias *old, + } + + /* Delete an alias entry. */ +-static void perf_pmu_free_alias(struct perf_pmu_alias *newalias) ++void perf_pmu_free_alias(struct perf_pmu_alias *newalias) + { + zfree(&newalias->name); + zfree(&newalias->desc); +@@ -1352,6 +1352,17 @@ void perf_pmu__set_format(unsigned long *bits, long from, long to) + set_bit(b, bits); + } + ++void perf_pmu__del_formats(struct list_head *formats) ++{ ++ struct perf_pmu_format *fmt, *tmp; ++ ++ list_for_each_entry_safe(fmt, tmp, formats, list) { ++ list_del(&fmt->list); ++ free(fmt->name); ++ free(fmt); ++ } ++} ++ + static int sub_non_neg(int a, int b) + { + if (b > a) +diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h +index f971d9aa4570a..28778b47fb4b7 100644 +--- a/tools/perf/util/pmu.h ++++ b/tools/perf/util/pmu.h +@@ -92,6 +92,7 @@ int perf_pmu__new_format(struct list_head *list, char *name, + int config, unsigned long *bits); + void perf_pmu__set_format(unsigned long *bits, long from, long to); + int perf_pmu__format_parse(char *dir, struct list_head *head); ++void perf_pmu__del_formats(struct list_head *formats); + + struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu); + +@@ -111,6 +112,7 @@ void pmu_add_cpu_aliases_map(struct list_head *head, struct perf_pmu *pmu, + + struct pmu_events_map *perf_pmu__find_map(struct perf_pmu *pmu); + bool pmu_uncore_alias_match(const char *pmu_name, const char *name); ++void perf_pmu_free_alias(struct perf_pmu_alias *alias); + + int perf_pmu__convert_scale(const char *scale, char **end, double *sval); + +diff --git a/tools/perf/util/record.c b/tools/perf/util/record.c +index a4cc11592f6b3..ea9aa1d7cf501 100644 +--- a/tools/perf/util/record.c ++++ b/tools/perf/util/record.c +@@ -2,6 +2,7 @@ + #include "debug.h" + #include "evlist.h" + #include "evsel.h" ++#include "evsel_config.h" + #include "parse-events.h" + #include <errno.h> + #include <limits.h> +@@ -33,11 +34,24 @@ static struct evsel *evsel__read_sampler(struct evsel *evsel, struct evlist *evl + return leader; + } + ++static u64 evsel__config_term_mask(struct evsel *evsel) ++{ ++ struct evsel_config_term *term; ++ struct list_head *config_terms = &evsel->config_terms; ++ u64 term_types = 0; ++ ++ list_for_each_entry(term, config_terms, list) { ++ term_types |= 1 << term->type; ++ } ++ return term_types; ++} ++ + static void evsel__config_leader_sampling(struct evsel *evsel, struct evlist *evlist) + { + struct perf_event_attr *attr = &evsel->core.attr; + struct evsel *leader = evsel->leader; + struct evsel *read_sampler; ++ u64 term_types, freq_mask; + + if (!leader->sample_read) + return; +@@ -47,16 +61,20 @@ static void evsel__config_leader_sampling(struct evsel *evsel, struct evlist *ev + if (evsel == read_sampler) + return; + ++ term_types = evsel__config_term_mask(evsel); + /* +- * Disable sampling for all group members other than the leader in +- * case the leader 'leads' the sampling, except when the leader is an +- * AUX area event, in which case the 2nd event in the group is the one +- * that 'leads' the sampling. ++ * Disable sampling for all group members except those with explicit ++ * config terms or the leader. In the case of an AUX area event, the 2nd ++ * event in the group is the one that 'leads' the sampling. + */ +- attr->freq = 0; +- attr->sample_freq = 0; +- attr->sample_period = 0; +- attr->write_backward = 0; ++ freq_mask = (1 << EVSEL__CONFIG_TERM_FREQ) | (1 << EVSEL__CONFIG_TERM_PERIOD); ++ if ((term_types & freq_mask) == 0) { ++ attr->freq = 0; ++ attr->sample_freq = 0; ++ attr->sample_period = 0; ++ } ++ if ((term_types & (1 << EVSEL__CONFIG_TERM_OVERWRITE)) == 0) ++ attr->write_backward = 0; + + /* + * We don't get a sample for slave events, we make them when delivering +diff --git a/tools/testing/selftests/vm/map_hugetlb.c b/tools/testing/selftests/vm/map_hugetlb.c +index 6af951900aa39..312889edb84ab 100644 +--- a/tools/testing/selftests/vm/map_hugetlb.c ++++ b/tools/testing/selftests/vm/map_hugetlb.c +@@ -83,7 +83,7 @@ int main(int argc, char **argv) + } + + if (shift) +- printf("%u kB hugepages\n", 1 << shift); ++ printf("%u kB hugepages\n", 1 << (shift - 10)); + else + printf("Default size hugepages\n"); + printf("Mapping %lu Mbytes\n", (unsigned long)length >> 20);
