diff options
| author |   Mike Pagano <mpagano@gentoo.org> | 2020-07-29 08:43:33 -0400 |
|---|---|---|
| committer | Mike Pagano <mpagano@gentoo.org> | 2020-07-29 08:43:33 -0400 |
| commit | 356150888a3720b32bbeb80bf06dab3a89c2e10b (patch) | |
| tree | 20f797dac1d33d9f17c84cf3eb00efd7d34fe6cd | |
| parent | Linux patch 5.7.10 (diff) | |
| download | linux-patches-356150888a3720b32bbeb80bf06dab3a89c2e10b.tar.gz linux-patches-356150888a3720b32bbeb80bf06dab3a89c2e10b.tar.bz2 linux-patches-356150888a3720b32bbeb80bf06dab3a89c2e10b.zip | |
Linux patch 5.7.115.7-12
Signed-off-by: Mike Pagano <mpagano@gentoo.org>
| -rw-r--r-- | 0000_README | 4 | ||||
| -rw-r--r-- | 1010_linux-5.7.11.patch | 6182 |
2 files changed, 6186 insertions, 0 deletions
diff --git a/0000_README b/0000_README index c2d1f0ca..6409a512 100644 --- a/0000_README +++ b/0000_README @@ -83,6 +83,10 @@ Patch: 1009_linux-5.7.10.patch From: http://www.kernel.org Desc: Linux 5.7.10 +Patch: 1010_linux-5.7.11.patch +From: http://www.kernel.org +Desc: Linux 5.7.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.7.11.patch b/1010_linux-5.7.11.patch new file mode 100644 index 00000000..f2f04163 --- /dev/null +++ b/1010_linux-5.7.11.patch @@ -0,0 +1,6182 @@ +diff --git a/Makefile b/Makefile +index e622e084e7e2..12777a95833f 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 7 +-SUBLEVEL = 10 ++SUBLEVEL = 11 + EXTRAVERSION = + NAME = Kleptomaniac Octopus + +@@ -549,7 +549,7 @@ ifneq ($(shell $(CC) --version 2>&1 | head -n 1 | grep clang),) + ifneq ($(CROSS_COMPILE),) + CLANG_FLAGS += --target=$(notdir $(CROSS_COMPILE:%-=%)) + GCC_TOOLCHAIN_DIR := $(dir $(shell which $(CROSS_COMPILE)elfedit)) +-CLANG_FLAGS += --prefix=$(GCC_TOOLCHAIN_DIR) ++CLANG_FLAGS += --prefix=$(GCC_TOOLCHAIN_DIR)$(notdir $(CROSS_COMPILE)) + GCC_TOOLCHAIN := $(realpath $(GCC_TOOLCHAIN_DIR)/..) + endif + ifneq ($(GCC_TOOLCHAIN),) +@@ -1730,7 +1730,7 @@ PHONY += descend $(build-dirs) + descend: $(build-dirs) + $(build-dirs): prepare + $(Q)$(MAKE) $(build)=$@ \ +- single-build=$(if $(filter-out $@/, $(filter $@/%, $(single-no-ko))),1) \ ++ single-build=$(if $(filter-out $@/, $(filter $@/%, $(KBUILD_SINGLE_TARGETS))),1) \ + need-builtin=1 need-modorder=1 + + clean-dirs := $(addprefix _clean_, $(clean-dirs)) +diff --git a/arch/arm/boot/dts/omap3-n900.dts b/arch/arm/boot/dts/omap3-n900.dts +index 4089d97405c9..3dbcae3d60d2 100644 +--- a/arch/arm/boot/dts/omap3-n900.dts ++++ b/arch/arm/boot/dts/omap3-n900.dts +@@ -105,6 +105,14 @@ + linux,code = <SW_FRONT_PROXIMITY>; + linux,can-disable; + }; ++ ++ machine_cover { ++ label = "Machine Cover"; ++ gpios = <&gpio6 0 GPIO_ACTIVE_LOW>; /* 160 */ ++ linux,input-type = <EV_SW>; ++ linux,code = <SW_MACHINE_COVER>; ++ linux,can-disable; ++ }; + }; + + isp1707: isp1707 { +@@ -819,10 +827,6 @@ + pinctrl-0 = <&mmc1_pins>; + vmmc-supply = <&vmmc1>; + bus-width = <4>; +- /* For debugging, it is often good idea to remove this GPIO. +- It means you can remove back cover (to reboot by removing +- battery) and still use the MMC card. */ +- cd-gpios = <&gpio6 0 GPIO_ACTIVE_LOW>; /* 160 */ + }; + + /* most boards use vaux3, only some old versions use vmmc2 instead */ +diff --git a/arch/arm64/boot/dts/marvell/armada-8040-clearfog-gt-8k.dts b/arch/arm64/boot/dts/marvell/armada-8040-clearfog-gt-8k.dts +index b90d78a5724b..e32a491e909f 100644 +--- a/arch/arm64/boot/dts/marvell/armada-8040-clearfog-gt-8k.dts ++++ b/arch/arm64/boot/dts/marvell/armada-8040-clearfog-gt-8k.dts +@@ -454,10 +454,7 @@ + status = "okay"; + phy-mode = "2500base-x"; + phys = <&cp1_comphy5 2>; +- fixed-link { +- speed = <2500>; +- full-duplex; +- }; ++ managed = "in-band-status"; + }; + + &cp1_spi1 { +diff --git a/arch/arm64/kernel/debug-monitors.c b/arch/arm64/kernel/debug-monitors.c +index 7569deb1eac1..d64a3c1e1b6b 100644 +--- a/arch/arm64/kernel/debug-monitors.c ++++ b/arch/arm64/kernel/debug-monitors.c +@@ -396,14 +396,14 @@ void user_rewind_single_step(struct task_struct *task) + * If single step is active for this thread, then set SPSR.SS + * to 1 to avoid returning to the active-pending state. + */ +- if (test_ti_thread_flag(task_thread_info(task), TIF_SINGLESTEP)) ++ if (test_tsk_thread_flag(task, TIF_SINGLESTEP)) + set_regs_spsr_ss(task_pt_regs(task)); + } + NOKPROBE_SYMBOL(user_rewind_single_step); + + void user_fastforward_single_step(struct task_struct *task) + { +- if (test_ti_thread_flag(task_thread_info(task), TIF_SINGLESTEP)) ++ if (test_tsk_thread_flag(task, TIF_SINGLESTEP)) + clear_regs_spsr_ss(task_pt_regs(task)); + } + +diff --git a/arch/arm64/kernel/vdso32/Makefile b/arch/arm64/kernel/vdso32/Makefile +index 3964738ebbde..0433bb58ce52 100644 +--- a/arch/arm64/kernel/vdso32/Makefile ++++ b/arch/arm64/kernel/vdso32/Makefile +@@ -14,7 +14,7 @@ COMPAT_GCC_TOOLCHAIN_DIR := $(dir $(shell which $(CROSS_COMPILE_COMPAT)elfedit)) + COMPAT_GCC_TOOLCHAIN := $(realpath $(COMPAT_GCC_TOOLCHAIN_DIR)/..) + + CC_COMPAT_CLANG_FLAGS := --target=$(notdir $(CROSS_COMPILE_COMPAT:%-=%)) +-CC_COMPAT_CLANG_FLAGS += --prefix=$(COMPAT_GCC_TOOLCHAIN_DIR) ++CC_COMPAT_CLANG_FLAGS += --prefix=$(COMPAT_GCC_TOOLCHAIN_DIR)$(notdir $(CROSS_COMPILE_COMPAT)) + CC_COMPAT_CLANG_FLAGS += -no-integrated-as -Qunused-arguments + ifneq ($(COMPAT_GCC_TOOLCHAIN),) + CC_COMPAT_CLANG_FLAGS += --gcc-toolchain=$(COMPAT_GCC_TOOLCHAIN) +diff --git a/arch/mips/pci/pci-xtalk-bridge.c b/arch/mips/pci/pci-xtalk-bridge.c +index 3b2552fb7735..5958217861b8 100644 +--- a/arch/mips/pci/pci-xtalk-bridge.c ++++ b/arch/mips/pci/pci-xtalk-bridge.c +@@ -627,9 +627,10 @@ static int bridge_probe(struct platform_device *pdev) + return -ENOMEM; + domain = irq_domain_create_hierarchy(parent, 0, 8, fn, + &bridge_domain_ops, NULL); +- irq_domain_free_fwnode(fn); +- if (!domain) ++ if (!domain) { ++ irq_domain_free_fwnode(fn); + return -ENOMEM; ++ } + + pci_set_flags(PCI_PROBE_ONLY); + +diff --git a/arch/parisc/include/asm/atomic.h b/arch/parisc/include/asm/atomic.h +index 118953d41763..6dd4171c9530 100644 +--- a/arch/parisc/include/asm/atomic.h ++++ b/arch/parisc/include/asm/atomic.h +@@ -212,6 +212,8 @@ atomic64_set(atomic64_t *v, s64 i) + _atomic_spin_unlock_irqrestore(v, flags); + } + ++#define atomic64_set_release(v, i) atomic64_set((v), (i)) ++ + static __inline__ s64 + atomic64_read(const atomic64_t *v) + { +diff --git a/arch/riscv/include/asm/barrier.h b/arch/riscv/include/asm/barrier.h +index 3f1737f301cc..d0e24aaa2aa0 100644 +--- a/arch/riscv/include/asm/barrier.h ++++ b/arch/riscv/include/asm/barrier.h +@@ -58,8 +58,16 @@ do { \ + * The AQ/RL pair provides a RCpc critical section, but there's not really any + * way we can take advantage of that here because the ordering is only enforced + * on that one lock. Thus, we're just doing a full fence. ++ * ++ * Since we allow writeX to be called from preemptive regions we need at least ++ * an "o" in the predecessor set to ensure device writes are visible before the ++ * task is marked as available for scheduling on a new hart. While I don't see ++ * any concrete reason we need a full IO fence, it seems safer to just upgrade ++ * this in order to avoid any IO crossing a scheduling boundary. In both ++ * instances the scheduler pairs this with an mb(), so nothing is necessary on ++ * the new hart. + */ +-#define smp_mb__after_spinlock() RISCV_FENCE(rw,rw) ++#define smp_mb__after_spinlock() RISCV_FENCE(iorw,iorw) + + #include <asm-generic/barrier.h> + +diff --git a/arch/riscv/mm/init.c b/arch/riscv/mm/init.c +index fdc772f57edc..81493cee0a16 100644 +--- a/arch/riscv/mm/init.c ++++ b/arch/riscv/mm/init.c +@@ -94,19 +94,40 @@ void __init mem_init(void) + #ifdef CONFIG_BLK_DEV_INITRD + static void __init setup_initrd(void) + { ++ phys_addr_t start; + unsigned long size; + +- if (initrd_start >= initrd_end) { +- pr_info("initrd not found or empty"); ++ /* Ignore the virtul address computed during device tree parsing */ ++ initrd_start = initrd_end = 0; ++ ++ if (!phys_initrd_size) ++ return; ++ /* ++ * Round the memory region to page boundaries as per free_initrd_mem() ++ * This allows us to detect whether the pages overlapping the initrd ++ * are in use, but more importantly, reserves the entire set of pages ++ * as we don't want these pages allocated for other purposes. ++ */ ++ start = round_down(phys_initrd_start, PAGE_SIZE); ++ size = phys_initrd_size + (phys_initrd_start - start); ++ size = round_up(size, PAGE_SIZE); ++ ++ if (!memblock_is_region_memory(start, size)) { ++ pr_err("INITRD: 0x%08llx+0x%08lx is not a memory region", ++ (u64)start, size); + goto disable; + } +- if (__pa_symbol(initrd_end) > PFN_PHYS(max_low_pfn)) { +- pr_err("initrd extends beyond end of memory"); ++ ++ if (memblock_is_region_reserved(start, size)) { ++ pr_err("INITRD: 0x%08llx+0x%08lx overlaps in-use memory region\n", ++ (u64)start, size); + goto disable; + } + +- size = initrd_end - initrd_start; +- memblock_reserve(__pa_symbol(initrd_start), size); ++ memblock_reserve(start, size); ++ /* Now convert initrd to virtual addresses */ ++ initrd_start = (unsigned long)__va(phys_initrd_start); ++ initrd_end = initrd_start + phys_initrd_size; + initrd_below_start_ok = 1; + + pr_info("Initial ramdisk at: 0x%p (%lu bytes)\n", +diff --git a/arch/s390/kernel/perf_cpum_cf_events.c b/arch/s390/kernel/perf_cpum_cf_events.c +index 1e3df52b2b65..37265f551a11 100644 +--- a/arch/s390/kernel/perf_cpum_cf_events.c ++++ b/arch/s390/kernel/perf_cpum_cf_events.c +@@ -292,7 +292,7 @@ CPUMF_EVENT_ATTR(cf_z15, TX_C_TABORT_SPECIAL, 0x00f5); + CPUMF_EVENT_ATTR(cf_z15, DFLT_ACCESS, 0x00f7); + CPUMF_EVENT_ATTR(cf_z15, DFLT_CYCLES, 0x00fc); + CPUMF_EVENT_ATTR(cf_z15, DFLT_CC, 0x00108); +-CPUMF_EVENT_ATTR(cf_z15, DFLT_CCERROR, 0x00109); ++CPUMF_EVENT_ATTR(cf_z15, DFLT_CCFINISH, 0x00109); + CPUMF_EVENT_ATTR(cf_z15, MT_DIAG_CYCLES_ONE_THR_ACTIVE, 0x01c0); + CPUMF_EVENT_ATTR(cf_z15, MT_DIAG_CYCLES_TWO_THR_ACTIVE, 0x01c1); + +@@ -629,7 +629,7 @@ static struct attribute *cpumcf_z15_pmu_event_attr[] __initdata = { + CPUMF_EVENT_PTR(cf_z15, DFLT_ACCESS), + CPUMF_EVENT_PTR(cf_z15, DFLT_CYCLES), + CPUMF_EVENT_PTR(cf_z15, DFLT_CC), +- CPUMF_EVENT_PTR(cf_z15, DFLT_CCERROR), ++ CPUMF_EVENT_PTR(cf_z15, DFLT_CCFINISH), + CPUMF_EVENT_PTR(cf_z15, MT_DIAG_CYCLES_ONE_THR_ACTIVE), + CPUMF_EVENT_PTR(cf_z15, MT_DIAG_CYCLES_TWO_THR_ACTIVE), + NULL, +diff --git a/arch/x86/boot/compressed/Makefile b/arch/x86/boot/compressed/Makefile +index 5f7c262bcc99..20aac9968315 100644 +--- a/arch/x86/boot/compressed/Makefile ++++ b/arch/x86/boot/compressed/Makefile +@@ -88,8 +88,8 @@ endif + + vmlinux-objs-$(CONFIG_ACPI) += $(obj)/acpi.o + +-vmlinux-objs-$(CONFIG_EFI_STUB) += $(objtree)/drivers/firmware/efi/libstub/lib.a + vmlinux-objs-$(CONFIG_EFI_MIXED) += $(obj)/efi_thunk_$(BITS).o ++efi-obj-$(CONFIG_EFI_STUB) = $(objtree)/drivers/firmware/efi/libstub/lib.a + + # The compressed kernel is built with -fPIC/-fPIE so that a boot loader + # can place it anywhere in memory and it will still run. However, since +@@ -113,7 +113,7 @@ endef + quiet_cmd_check-and-link-vmlinux = LD $@ + cmd_check-and-link-vmlinux = $(cmd_check_data_rel); $(cmd_ld) + +-$(obj)/vmlinux: $(vmlinux-objs-y) FORCE ++$(obj)/vmlinux: $(vmlinux-objs-y) $(efi-obj-y) FORCE + $(call if_changed,check-and-link-vmlinux) + + OBJCOPYFLAGS_vmlinux.bin := -R .comment -S +diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c +index 913c88617848..57447f03ee87 100644 +--- a/arch/x86/kernel/apic/io_apic.c ++++ b/arch/x86/kernel/apic/io_apic.c +@@ -2329,12 +2329,12 @@ static int mp_irqdomain_create(int ioapic) + ip->irqdomain = irq_domain_create_linear(fn, hwirqs, cfg->ops, + (void *)(long)ioapic); + +- /* Release fw handle if it was allocated above */ +- if (!cfg->dev) +- irq_domain_free_fwnode(fn); +- +- if (!ip->irqdomain) ++ if (!ip->irqdomain) { ++ /* Release fw handle if it was allocated above */ ++ if (!cfg->dev) ++ irq_domain_free_fwnode(fn); + return -ENOMEM; ++ } + + ip->irqdomain->parent = parent; + +diff --git a/arch/x86/kernel/apic/msi.c b/arch/x86/kernel/apic/msi.c +index 159bd0cb8548..a20873bbbed6 100644 +--- a/arch/x86/kernel/apic/msi.c ++++ b/arch/x86/kernel/apic/msi.c +@@ -262,12 +262,13 @@ void __init arch_init_msi_domain(struct irq_domain *parent) + msi_default_domain = + pci_msi_create_irq_domain(fn, &pci_msi_domain_info, + parent); +- irq_domain_free_fwnode(fn); + } +- if (!msi_default_domain) ++ if (!msi_default_domain) { ++ irq_domain_free_fwnode(fn); + pr_warn("failed to initialize irqdomain for MSI/MSI-x.\n"); +- else ++ } else { + msi_default_domain->flags |= IRQ_DOMAIN_MSI_NOMASK_QUIRK; ++ } + } + + #ifdef CONFIG_IRQ_REMAP +@@ -300,7 +301,8 @@ struct irq_domain *arch_create_remap_msi_irq_domain(struct irq_domain *parent, + if (!fn) + return NULL; + d = pci_msi_create_irq_domain(fn, &pci_msi_ir_domain_info, parent); +- irq_domain_free_fwnode(fn); ++ if (!d) ++ irq_domain_free_fwnode(fn); + return d; + } + #endif +@@ -363,7 +365,8 @@ static struct irq_domain *dmar_get_irq_domain(void) + if (fn) { + dmar_domain = msi_create_irq_domain(fn, &dmar_msi_domain_info, + x86_vector_domain); +- irq_domain_free_fwnode(fn); ++ if (!dmar_domain) ++ irq_domain_free_fwnode(fn); + } + out: + mutex_unlock(&dmar_lock); +@@ -488,7 +491,10 @@ struct irq_domain *hpet_create_irq_domain(int hpet_id) + } + + d = msi_create_irq_domain(fn, domain_info, parent); +- irq_domain_free_fwnode(fn); ++ if (!d) { ++ irq_domain_free_fwnode(fn); ++ kfree(domain_info); ++ } + return d; + } + +diff --git a/arch/x86/kernel/apic/vector.c b/arch/x86/kernel/apic/vector.c +index cf8b6ebc6031..410363e60968 100644 +--- a/arch/x86/kernel/apic/vector.c ++++ b/arch/x86/kernel/apic/vector.c +@@ -707,7 +707,6 @@ int __init arch_early_irq_init(void) + x86_vector_domain = irq_domain_create_tree(fn, &x86_vector_domain_ops, + NULL); + BUG_ON(x86_vector_domain == NULL); +- irq_domain_free_fwnode(fn); + irq_set_default_host(x86_vector_domain); + + arch_init_msi_domain(x86_vector_domain); +diff --git a/arch/x86/kernel/vmlinux.lds.S b/arch/x86/kernel/vmlinux.lds.S +index 7c35556c7827..1b165813892f 100644 +--- a/arch/x86/kernel/vmlinux.lds.S ++++ b/arch/x86/kernel/vmlinux.lds.S +@@ -359,6 +359,7 @@ SECTIONS + .bss : AT(ADDR(.bss) - LOAD_OFFSET) { + __bss_start = .; + *(.bss..page_aligned) ++ . = ALIGN(PAGE_SIZE); + *(BSS_MAIN) + BSS_DECRYPTED + . = ALIGN(PAGE_SIZE); +diff --git a/arch/x86/math-emu/wm_sqrt.S b/arch/x86/math-emu/wm_sqrt.S +index 3b2b58164ec1..40526dd85137 100644 +--- a/arch/x86/math-emu/wm_sqrt.S ++++ b/arch/x86/math-emu/wm_sqrt.S +@@ -209,7 +209,7 @@ sqrt_stage_2_finish: + + #ifdef PARANOID + /* It should be possible to get here only if the arg is ffff....ffff */ +- cmp $0xffffffff,FPU_fsqrt_arg_1 ++ cmpl $0xffffffff,FPU_fsqrt_arg_1 + jnz sqrt_stage_2_error + #endif /* PARANOID */ + +diff --git a/arch/x86/platform/uv/uv_irq.c b/arch/x86/platform/uv/uv_irq.c +index fc13cbbb2dce..abb6075397f0 100644 +--- a/arch/x86/platform/uv/uv_irq.c ++++ b/arch/x86/platform/uv/uv_irq.c +@@ -167,9 +167,10 @@ static struct irq_domain *uv_get_irq_domain(void) + goto out; + + uv_domain = irq_domain_create_tree(fn, &uv_domain_ops, NULL); +- irq_domain_free_fwnode(fn); + if (uv_domain) + uv_domain->parent = x86_vector_domain; ++ else ++ irq_domain_free_fwnode(fn); + out: + mutex_unlock(&uv_lock); + +diff --git a/arch/xtensa/kernel/setup.c b/arch/xtensa/kernel/setup.c +index 3880c765d448..0271e2e47bcd 100644 +--- a/arch/xtensa/kernel/setup.c ++++ b/arch/xtensa/kernel/setup.c +@@ -725,7 +725,8 @@ c_start(struct seq_file *f, loff_t *pos) + static void * + c_next(struct seq_file *f, void *v, loff_t *pos) + { +- return NULL; ++ ++*pos; ++ return c_start(f, pos); + } + + static void +diff --git a/arch/xtensa/kernel/xtensa_ksyms.c b/arch/xtensa/kernel/xtensa_ksyms.c +index 4092555828b1..24cf6972eace 100644 +--- a/arch/xtensa/kernel/xtensa_ksyms.c ++++ b/arch/xtensa/kernel/xtensa_ksyms.c +@@ -87,13 +87,13 @@ void __xtensa_libgcc_window_spill(void) + } + EXPORT_SYMBOL(__xtensa_libgcc_window_spill); + +-unsigned long __sync_fetch_and_and_4(unsigned long *p, unsigned long v) ++unsigned int __sync_fetch_and_and_4(volatile void *p, unsigned int v) + { + BUG(); + } + EXPORT_SYMBOL(__sync_fetch_and_and_4); + +-unsigned long __sync_fetch_and_or_4(unsigned long *p, unsigned long v) ++unsigned int __sync_fetch_and_or_4(volatile void *p, unsigned int v) + { + BUG(); + } +diff --git a/drivers/android/binder_alloc.c b/drivers/android/binder_alloc.c +index 2d8b9b91dee0..1dadca3d381e 100644 +--- a/drivers/android/binder_alloc.c ++++ b/drivers/android/binder_alloc.c +@@ -947,7 +947,7 @@ enum lru_status binder_alloc_free_page(struct list_head *item, + trace_binder_unmap_user_end(alloc, index); + } + up_read(&mm->mmap_sem); +- mmput(mm); ++ mmput_async(mm); + + trace_binder_unmap_kernel_start(alloc, index); + +diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c +index 320d23de02c2..927ebde1607b 100644 +--- a/drivers/base/regmap/regmap.c ++++ b/drivers/base/regmap/regmap.c +@@ -1363,7 +1363,7 @@ static int dev_get_regmap_match(struct device *dev, void *res, void *data) + + /* If the user didn't specify a name match any */ + if (data) +- return (*r)->name == data; ++ return !strcmp((*r)->name, data); + else + return 1; + } +diff --git a/drivers/char/mem.c b/drivers/char/mem.c +index 31cae88a730b..6b56bff9b68c 100644 +--- a/drivers/char/mem.c ++++ b/drivers/char/mem.c +@@ -814,7 +814,8 @@ static struct inode *devmem_inode; + #ifdef CONFIG_IO_STRICT_DEVMEM + void revoke_devmem(struct resource *res) + { +- struct inode *inode = READ_ONCE(devmem_inode); ++ /* pairs with smp_store_release() in devmem_init_inode() */ ++ struct inode *inode = smp_load_acquire(&devmem_inode); + + /* + * Check that the initialization has completed. Losing the race +@@ -1028,8 +1029,11 @@ static int devmem_init_inode(void) + return rc; + } + +- /* publish /dev/mem initialized */ +- WRITE_ONCE(devmem_inode, inode); ++ /* ++ * Publish /dev/mem initialized. ++ * Pairs with smp_load_acquire() in revoke_devmem(). ++ */ ++ smp_store_release(&devmem_inode, inode); + + return 0; + } +diff --git a/drivers/crypto/chelsio/chtls/chtls_io.c b/drivers/crypto/chelsio/chtls/chtls_io.c +index e1401d9cc756..2e9acae1cba3 100644 +--- a/drivers/crypto/chelsio/chtls/chtls_io.c ++++ b/drivers/crypto/chelsio/chtls/chtls_io.c +@@ -1052,14 +1052,15 @@ int chtls_sendmsg(struct sock *sk, struct msghdr *msg, size_t size) + &record_type); + if (err) + goto out_err; ++ ++ /* Avoid appending tls handshake, alert to tls data */ ++ if (skb) ++ tx_skb_finalize(skb); + } + + recordsz = size; + csk->tlshws.txleft = recordsz; + csk->tlshws.type = record_type; +- +- if (skb) +- ULP_SKB_CB(skb)->ulp.tls.type = record_type; + } + + if (!skb || (ULP_SKB_CB(skb)->flags & ULPCB_FLAG_NO_APPEND) || +diff --git a/drivers/dma/fsl-edma-common.c b/drivers/dma/fsl-edma-common.c +index 5697c3622699..9285884758b2 100644 +--- a/drivers/dma/fsl-edma-common.c ++++ b/drivers/dma/fsl-edma-common.c +@@ -352,26 +352,28 @@ static void fsl_edma_set_tcd_regs(struct fsl_edma_chan *fsl_chan, + /* + * TCD parameters are stored in struct fsl_edma_hw_tcd in little + * endian format. However, we need to load the TCD registers in +- * big- or little-endian obeying the eDMA engine model endian. ++ * big- or little-endian obeying the eDMA engine model endian, ++ * and this is performed from specific edma_write functions + */ + edma_writew(edma, 0, ®s->tcd[ch].csr); +- edma_writel(edma, le32_to_cpu(tcd->saddr), ®s->tcd[ch].saddr); +- edma_writel(edma, le32_to_cpu(tcd->daddr), ®s->tcd[ch].daddr); + +- edma_writew(edma, le16_to_cpu(tcd->attr), ®s->tcd[ch].attr); +- edma_writew(edma, le16_to_cpu(tcd->soff), ®s->tcd[ch].soff); ++ edma_writel(edma, (s32)tcd->saddr, ®s->tcd[ch].saddr); ++ edma_writel(edma, (s32)tcd->daddr, ®s->tcd[ch].daddr); + +- edma_writel(edma, le32_to_cpu(tcd->nbytes), ®s->tcd[ch].nbytes); +- edma_writel(edma, le32_to_cpu(tcd->slast), ®s->tcd[ch].slast); ++ edma_writew(edma, (s16)tcd->attr, ®s->tcd[ch].attr); ++ edma_writew(edma, tcd->soff, ®s->tcd[ch].soff); + +- edma_writew(edma, le16_to_cpu(tcd->citer), ®s->tcd[ch].citer); +- edma_writew(edma, le16_to_cpu(tcd->biter), ®s->tcd[ch].biter); +- edma_writew(edma, le16_to_cpu(tcd->doff), ®s->tcd[ch].doff); ++ edma_writel(edma, (s32)tcd->nbytes, ®s->tcd[ch].nbytes); ++ edma_writel(edma, (s32)tcd->slast, ®s->tcd[ch].slast); + +- edma_writel(edma, le32_to_cpu(tcd->dlast_sga), ++ edma_writew(edma, (s16)tcd->citer, ®s->tcd[ch].citer); ++ edma_writew(edma, (s16)tcd->biter, ®s->tcd[ch].biter); ++ edma_writew(edma, (s16)tcd->doff, ®s->tcd[ch].doff); ++ ++ edma_writel(edma, (s32)tcd->dlast_sga, + ®s->tcd[ch].dlast_sga); + +- edma_writew(edma, le16_to_cpu(tcd->csr), ®s->tcd[ch].csr); ++ edma_writew(edma, (s16)tcd->csr, ®s->tcd[ch].csr); + } + + static inline +diff --git a/drivers/dma/ioat/dma.c b/drivers/dma/ioat/dma.c +index 18c011e57592..8e2a4d1f0be5 100644 +--- a/drivers/dma/ioat/dma.c ++++ b/drivers/dma/ioat/dma.c +@@ -26,6 +26,18 @@ + + #include "../dmaengine.h" + ++int completion_timeout = 200; ++module_param(completion_timeout, int, 0644); ++MODULE_PARM_DESC(completion_timeout, ++ "set ioat completion timeout [msec] (default 200 [msec])"); ++int idle_timeout = 2000; ++module_param(idle_timeout, int, 0644); ++MODULE_PARM_DESC(idle_timeout, ++ "set ioat idel timeout [msec] (default 2000 [msec])"); ++ ++#define IDLE_TIMEOUT msecs_to_jiffies(idle_timeout) ++#define COMPLETION_TIMEOUT msecs_to_jiffies(completion_timeout) ++ + static char *chanerr_str[] = { + "DMA Transfer Source Address Error", + "DMA Transfer Destination Address Error", +diff --git a/drivers/dma/ioat/dma.h b/drivers/dma/ioat/dma.h +index b8e8e0b9693c..4ac9134962f3 100644 +--- a/drivers/dma/ioat/dma.h ++++ b/drivers/dma/ioat/dma.h +@@ -99,8 +99,6 @@ struct ioatdma_chan { + #define IOAT_RUN 5 + #define IOAT_CHAN_ACTIVE 6 + struct timer_list timer; +- #define COMPLETION_TIMEOUT msecs_to_jiffies(100) +- #define IDLE_TIMEOUT msecs_to_jiffies(2000) + #define RESET_DELAY msecs_to_jiffies(100) + struct ioatdma_device *ioat_dma; + dma_addr_t completion_dma; +diff --git a/drivers/dma/tegra210-adma.c b/drivers/dma/tegra210-adma.c +index db58d7e4f9fe..c5fa2ef74abc 100644 +--- a/drivers/dma/tegra210-adma.c ++++ b/drivers/dma/tegra210-adma.c +@@ -658,6 +658,7 @@ static int tegra_adma_alloc_chan_resources(struct dma_chan *dc) + + ret = pm_runtime_get_sync(tdc2dev(tdc)); + if (ret < 0) { ++ pm_runtime_put_noidle(tdc2dev(tdc)); + free_irq(tdc->irq, tdc); + return ret; + } +@@ -869,8 +870,10 @@ static int tegra_adma_probe(struct platform_device *pdev) + pm_runtime_enable(&pdev->dev); + + ret = pm_runtime_get_sync(&pdev->dev); +- if (ret < 0) ++ if (ret < 0) { ++ pm_runtime_put_noidle(&pdev->dev); + goto rpm_disable; ++ } + + ret = tegra_adma_init(tdma); + if (ret) +diff --git a/drivers/dma/ti/k3-udma-private.c b/drivers/dma/ti/k3-udma-private.c +index 0b8f3dd6b146..77e8e67d995b 100644 +--- a/drivers/dma/ti/k3-udma-private.c ++++ b/drivers/dma/ti/k3-udma-private.c +@@ -42,6 +42,7 @@ struct udma_dev *of_xudma_dev_get(struct device_node *np, const char *property) + ud = platform_get_drvdata(pdev); + if (!ud) { + pr_debug("UDMA has not been probed\n"); ++ put_device(&pdev->dev); + return ERR_PTR(-EPROBE_DEFER); + } + +diff --git a/drivers/dma/ti/k3-udma.c b/drivers/dma/ti/k3-udma.c +index 7cab23fe5c73..b777f1924968 100644 +--- a/drivers/dma/ti/k3-udma.c ++++ b/drivers/dma/ti/k3-udma.c +@@ -1773,7 +1773,8 @@ static int udma_alloc_chan_resources(struct dma_chan *chan) + dev_err(ud->ddev.dev, + "Descriptor pool allocation failed\n"); + uc->use_dma_pool = false; +- return -ENOMEM; ++ ret = -ENOMEM; ++ goto err_cleanup; + } + } + +@@ -1793,16 +1794,18 @@ static int udma_alloc_chan_resources(struct dma_chan *chan) + + ret = udma_get_chan_pair(uc); + if (ret) +- return ret; ++ goto err_cleanup; + + ret = udma_alloc_tx_resources(uc); +- if (ret) +- return ret; ++ if (ret) { ++ udma_put_rchan(uc); ++ goto err_cleanup; ++ } + + ret = udma_alloc_rx_resources(uc); + if (ret) { + udma_free_tx_resources(uc); +- return ret; ++ goto err_cleanup; + } + + uc->config.src_thread = ud->psil_base + uc->tchan->id; +@@ -1820,10 +1823,8 @@ static int udma_alloc_chan_resources(struct dma_chan *chan) + uc->id); + + ret = udma_alloc_tx_resources(uc); +- if (ret) { +- uc->config.remote_thread_id = -1; +- return ret; +- } ++ if (ret) ++ goto err_cleanup; + + uc->config.src_thread = ud->psil_base + uc->tchan->id; + uc->config.dst_thread = uc->config.remote_thread_id; +@@ -1840,10 +1841,8 @@ static int udma_alloc_chan_resources(struct dma_chan *chan) + uc->id); + + ret = udma_alloc_rx_resources(uc); +- if (ret) { +- uc->config.remote_thread_id = -1; +- return ret; +- } ++ if (ret) ++ goto err_cleanup; + + uc->config.src_thread = uc->config.remote_thread_id; + uc->config.dst_thread = (ud->psil_base + uc->rchan->id) | +@@ -1858,7 +1857,9 @@ static int udma_alloc_chan_resources(struct dma_chan *chan) + /* Can not happen */ + dev_err(uc->ud->dev, "%s: chan%d invalid direction (%u)\n", + __func__, uc->id, uc->config.dir); +- return -EINVAL; ++ ret = -EINVAL; ++ goto err_cleanup; ++ + } + + /* check if the channel configuration was successful */ +@@ -1867,7 +1868,7 @@ static int udma_alloc_chan_resources(struct dma_chan *chan) + + if (udma_is_chan_running(uc)) { + dev_warn(ud->dev, "chan%d: is running!\n", uc->id); +- udma_stop(uc); ++ udma_reset_chan(uc, false); + if (udma_is_chan_running(uc)) { + dev_err(ud->dev, "chan%d: won't stop!\n", uc->id); + goto err_res_free; +@@ -1936,7 +1937,7 @@ err_psi_free: + err_res_free: + udma_free_tx_resources(uc); + udma_free_rx_resources(uc); +- ++err_cleanup: + udma_reset_uchan(uc); + + if (uc->use_dma_pool) { +diff --git a/drivers/firmware/efi/efi-pstore.c b/drivers/firmware/efi/efi-pstore.c +index c2f1d4e6630b..feb7fe6f2da7 100644 +--- a/drivers/firmware/efi/efi-pstore.c ++++ b/drivers/firmware/efi/efi-pstore.c +@@ -356,10 +356,7 @@ static struct pstore_info efi_pstore_info = { + + static __init int efivars_pstore_init(void) + { +- if (!efi_rt_services_supported(EFI_RT_SUPPORTED_VARIABLE_SERVICES)) +- return 0; +- +- if (!efivars_kobject()) ++ if (!efivars_kobject() || !efivar_supports_writes()) + return 0; + + if (efivars_pstore_disable) +diff --git a/drivers/firmware/efi/efi.c b/drivers/firmware/efi/efi.c +index 20a7ba47a792..99446b384726 100644 +--- a/drivers/firmware/efi/efi.c ++++ b/drivers/firmware/efi/efi.c +@@ -176,11 +176,13 @@ static struct efivar_operations generic_ops; + static int generic_ops_register(void) + { + generic_ops.get_variable = efi.get_variable; +- generic_ops.set_variable = efi.set_variable; +- generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking; + generic_ops.get_next_variable = efi.get_next_variable; + generic_ops.query_variable_store = efi_query_variable_store; + ++ if (efi_rt_services_supported(EFI_RT_SUPPORTED_SET_VARIABLE)) { ++ generic_ops.set_variable = efi.set_variable; ++ generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking; ++ } + return efivars_register(&generic_efivars, &generic_ops, efi_kobj); + } + +@@ -382,7 +384,8 @@ static int __init efisubsys_init(void) + return -ENOMEM; + } + +- if (efi_rt_services_supported(EFI_RT_SUPPORTED_VARIABLE_SERVICES)) { ++ if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE | ++ EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME)) { + efivar_ssdt_load(); + error = generic_ops_register(); + if (error) +@@ -416,7 +419,8 @@ static int __init efisubsys_init(void) + err_remove_group: + sysfs_remove_group(efi_kobj, &efi_subsys_attr_group); + err_unregister: +- if (efi_rt_services_supported(EFI_RT_SUPPORTED_VARIABLE_SERVICES)) ++ if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE | ++ EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME)) + generic_ops_unregister(); + err_put: + kobject_put(efi_kobj); +diff --git a/drivers/firmware/efi/efivars.c b/drivers/firmware/efi/efivars.c +index 26528a46d99e..dcea137142b3 100644 +--- a/drivers/firmware/efi/efivars.c ++++ b/drivers/firmware/efi/efivars.c +@@ -680,11 +680,8 @@ int efivars_sysfs_init(void) + struct kobject *parent_kobj = efivars_kobject(); + int error = 0; + +- if (!efi_rt_services_supported(EFI_RT_SUPPORTED_VARIABLE_SERVICES)) +- return -ENODEV; +- + /* No efivars has been registered yet */ +- if (!parent_kobj) ++ if (!parent_kobj || !efivar_supports_writes()) + return 0; + + printk(KERN_INFO "EFI Variables Facility v%s %s\n", EFIVARS_VERSION, +diff --git a/drivers/firmware/efi/vars.c b/drivers/firmware/efi/vars.c +index 5f2a4d162795..973eef234b36 100644 +--- a/drivers/firmware/efi/vars.c ++++ b/drivers/firmware/efi/vars.c +@@ -1229,3 +1229,9 @@ out: + return rv; + } + EXPORT_SYMBOL_GPL(efivars_unregister); ++ ++int efivar_supports_writes(void) ++{ ++ return __efivars && __efivars->ops->set_variable; ++} ++EXPORT_SYMBOL_GPL(efivar_supports_writes); +diff --git a/drivers/firmware/psci/psci_checker.c b/drivers/firmware/psci/psci_checker.c +index 873841af8d57..d9b1a2d71223 100644 +--- a/drivers/firmware/psci/psci_checker.c ++++ b/drivers/firmware/psci/psci_checker.c +@@ -157,8 +157,10 @@ static int alloc_init_cpu_groups(cpumask_var_t **pcpu_groups) + + cpu_groups = kcalloc(nb_available_cpus, sizeof(cpu_groups), + GFP_KERNEL); +- if (!cpu_groups) ++ if (!cpu_groups) { ++ free_cpumask_var(tmp); + return -ENOMEM; ++ } + + cpumask_copy(tmp, cpu_online_mask); + +@@ -167,6 +169,7 @@ static int alloc_init_cpu_groups(cpumask_var_t **pcpu_groups) + topology_core_cpumask(cpumask_any(tmp)); + + if (!alloc_cpumask_var(&cpu_groups[num_groups], GFP_KERNEL)) { ++ free_cpumask_var(tmp); + free_cpu_groups(num_groups, &cpu_groups); + return -ENOMEM; + } +diff --git a/drivers/fpga/dfl-afu-main.c b/drivers/fpga/dfl-afu-main.c +index 65437b6a6842..77e257c88a1d 100644 +--- a/drivers/fpga/dfl-afu-main.c ++++ b/drivers/fpga/dfl-afu-main.c +@@ -83,7 +83,8 @@ int __afu_port_disable(struct platform_device *pdev) + * on this port and minimum soft reset pulse width has elapsed. + * Driver polls port_soft_reset_ack to determine if reset done by HW. + */ +- if (readq_poll_timeout(base + PORT_HDR_CTRL, v, v & PORT_CTRL_SFTRST, ++ if (readq_poll_timeout(base + PORT_HDR_CTRL, v, ++ v & PORT_CTRL_SFTRST_ACK, + RST_POLL_INVL, RST_POLL_TIMEOUT)) { + dev_err(&pdev->dev, "timeout, fail to reset device\n"); + return -ETIMEDOUT; +diff --git a/drivers/fpga/dfl-pci.c b/drivers/fpga/dfl-pci.c +index 538755062ab7..a78c409bf2c4 100644 +--- a/drivers/fpga/dfl-pci.c ++++ b/drivers/fpga/dfl-pci.c +@@ -227,7 +227,6 @@ static int cci_pci_sriov_configure(struct pci_dev *pcidev, int num_vfs) + { + struct cci_drvdata *drvdata = pci_get_drvdata(pcidev); + struct dfl_fpga_cdev *cdev = drvdata->cdev; +- int ret = 0; + + if (!num_vfs) { + /* +@@ -239,6 +238,8 @@ static int cci_pci_sriov_configure(struct pci_dev *pcidev, int num_vfs) + dfl_fpga_cdev_config_ports_pf(cdev); + + } else { ++ int ret; ++ + /* + * before enable SRIOV, put released ports into VF access mode + * first of all. +diff --git a/drivers/gpio/gpio-arizona.c b/drivers/gpio/gpio-arizona.c +index 5640efe5e750..5bda38e0780f 100644 +--- a/drivers/gpio/gpio-arizona.c ++++ b/drivers/gpio/gpio-arizona.c +@@ -64,6 +64,7 @@ static int arizona_gpio_get(struct gpio_chip *chip, unsigned offset) + ret = pm_runtime_get_sync(chip->parent); + if (ret < 0) { + dev_err(chip->parent, "Failed to resume: %d\n", ret); ++ pm_runtime_put_autosuspend(chip->parent); + return ret; + } + +@@ -72,12 +73,15 @@ static int arizona_gpio_get(struct gpio_chip *chip, unsigned offset) + if (ret < 0) { + dev_err(chip->parent, "Failed to drop cache: %d\n", + ret); ++ pm_runtime_put_autosuspend(chip->parent); + return ret; + } + + ret = regmap_read(arizona->regmap, reg, &val); +- if (ret < 0) ++ if (ret < 0) { ++ pm_runtime_put_autosuspend(chip->parent); + return ret; ++ } + + pm_runtime_mark_last_busy(chip->parent); + pm_runtime_put_autosuspend(chip->parent); +@@ -106,6 +110,7 @@ static int arizona_gpio_direction_out(struct gpio_chip *chip, + ret = pm_runtime_get_sync(chip->parent); + if (ret < 0) { + dev_err(chip->parent, "Failed to resume: %d\n", ret); ++ pm_runtime_put(chip->parent); + return ret; + } + } +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c +index c0f9a651dc06..92b18c4760e5 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c +@@ -1156,27 +1156,37 @@ static void amdgpu_ib_preempt_job_recovery(struct drm_gpu_scheduler *sched) + static void amdgpu_ib_preempt_mark_partial_job(struct amdgpu_ring *ring) + { + struct amdgpu_job *job; +- struct drm_sched_job *s_job; ++ struct drm_sched_job *s_job, *tmp; + uint32_t preempt_seq; + struct dma_fence *fence, **ptr; + struct amdgpu_fence_driver *drv = &ring->fence_drv; + struct drm_gpu_scheduler *sched = &ring->sched; ++ bool preempted = true; + + if (ring->funcs->type != AMDGPU_RING_TYPE_GFX) + return; + + preempt_seq = le32_to_cpu(*(drv->cpu_addr + 2)); +- if (preempt_seq <= atomic_read(&drv->last_seq)) +- return; ++ if (preempt_seq <= atomic_read(&drv->last_seq)) { ++ preempted = false; ++ goto no_preempt; ++ } + + preempt_seq &= drv->num_fences_mask; + ptr = &drv->fences[preempt_seq]; + fence = rcu_dereference_protected(*ptr, 1); + ++no_preempt: + spin_lock(&sched->job_list_lock); +- list_for_each_entry(s_job, &sched->ring_mirror_list, node) { ++ list_for_each_entry_safe(s_job, tmp, &sched->ring_mirror_list, node) { ++ if (dma_fence_is_signaled(&s_job->s_fence->finished)) { ++ /* remove job from ring_mirror_list */ ++ list_del_init(&s_job->node); ++ sched->ops->free_job(s_job); ++ continue; ++ } + job = to_amdgpu_job(s_job); +- if (job->fence == fence) ++ if (preempted && job->fence == fence) + /* mark the job as preempted */ + job->preemption_status |= AMDGPU_IB_PREEMPTED; + } +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c +index 96b8feb77b15..b14b0b4ffeb2 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c +@@ -775,8 +775,7 @@ static ssize_t amdgpu_set_pp_od_clk_voltage(struct device *dev, + tmp_str++; + while (isspace(*++tmp_str)); + +- while (tmp_str[0]) { +- sub_str = strsep(&tmp_str, delimiter); ++ while ((sub_str = strsep(&tmp_str, delimiter)) != NULL) { + ret = kstrtol(sub_str, 0, ¶meter[parameter_size]); + if (ret) + return -EINVAL; +@@ -1036,8 +1035,7 @@ static ssize_t amdgpu_read_mask(const char *buf, size_t count, uint32_t *mask) + memcpy(buf_cpy, buf, bytes); + buf_cpy[bytes] = '\0'; + tmp = buf_cpy; +- while (tmp[0]) { +- sub_str = strsep(&tmp, delimiter); ++ while ((sub_str = strsep(&tmp, delimiter)) != NULL) { + if (strlen(sub_str)) { + ret = kstrtol(sub_str, 0, &level); + if (ret) +@@ -1634,8 +1632,7 @@ static ssize_t amdgpu_set_pp_power_profile_mode(struct device *dev, + i++; + memcpy(buf_cpy, buf, count-i); + tmp_str = buf_cpy; +- while (tmp_str[0]) { +- sub_str = strsep(&tmp_str, delimiter); ++ while ((sub_str = strsep(&tmp_str, delimiter)) != NULL) { + ret = kstrtol(sub_str, 0, ¶meter[parameter_size]); + if (ret) + return -EINVAL; +diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c +index 0e0daf0021b6..ff94f756978d 100644 +--- a/drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c ++++ b/drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c +@@ -4746,12 +4746,17 @@ static int gfx_v10_0_ring_preempt_ib(struct amdgpu_ring *ring) + struct amdgpu_device *adev = ring->adev; + struct amdgpu_kiq *kiq = &adev->gfx.kiq; + struct amdgpu_ring *kiq_ring = &kiq->ring; ++ unsigned long flags; + + if (!kiq->pmf || !kiq->pmf->kiq_unmap_queues) + return -EINVAL; + +- if (amdgpu_ring_alloc(kiq_ring, kiq->pmf->unmap_queues_size)) ++ spin_lock_irqsave(&kiq->ring_lock, flags); ++ ++ if (amdgpu_ring_alloc(kiq_ring, kiq->pmf->unmap_queues_size)) { ++ spin_unlock_irqrestore(&kiq->ring_lock, flags); + return -ENOMEM; ++ } + + /* assert preemption condition */ + amdgpu_ring_set_preempt_cond_exec(ring, false); +@@ -4762,6 +4767,8 @@ static int gfx_v10_0_ring_preempt_ib(struct amdgpu_ring *ring) + ++ring->trail_seq); + amdgpu_ring_commit(kiq_ring); + ++ spin_unlock_irqrestore(&kiq->ring_lock, flags); ++ + /* poll the trailing fence */ + for (i = 0; i < adev->usec_timeout; i++) { + if (ring->trail_seq == +diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +index d06fa6380179..837a286469ec 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -1342,9 +1342,14 @@ static int dm_late_init(void *handle) + struct dmcu_iram_parameters params; + unsigned int linear_lut[16]; + int i; +- struct dmcu *dmcu = adev->dm.dc->res_pool->dmcu; ++ struct dmcu *dmcu = NULL; + bool ret; + ++ if (!adev->dm.fw_dmcu && !adev->dm.dmub_fw) ++ return detect_mst_link_for_all_connectors(adev->ddev); ++ ++ dmcu = adev->dm.dc->res_pool->dmcu; ++ + for (i = 0; i < 16; i++) + linear_lut[i] = 0xFFFF * i / 15; + +diff --git a/drivers/gpu/drm/amd/powerplay/smumgr/vegam_smumgr.c b/drivers/gpu/drm/amd/powerplay/smumgr/vegam_smumgr.c +index b0e0d67cd54b..2a081a792c6b 100644 +--- a/drivers/gpu/drm/amd/powerplay/smumgr/vegam_smumgr.c ++++ b/drivers/gpu/drm/amd/powerplay/smumgr/vegam_smumgr.c +@@ -642,9 +642,6 @@ static int vegam_get_dependency_volt_by_clk(struct pp_hwmgr *hwmgr, + + /* sclk is bigger than max sclk in the dependence table */ + *voltage |= (dep_table->entries[i - 1].vddc * VOLTAGE_SCALE) << VDDC_SHIFT; +- vddci = phm_find_closest_vddci(&(data->vddci_voltage_table), +- (dep_table->entries[i - 1].vddc - +- (uint16_t)VDDC_VDDCI_DELTA)); + + if (SMU7_VOLTAGE_CONTROL_NONE == data->vddci_control) + *voltage |= (data->vbios_boot_state.vddci_bootup_value * +@@ -652,8 +649,13 @@ static int vegam_get_dependency_volt_by_clk(struct pp_hwmgr *hwmgr, + else if (dep_table->entries[i - 1].vddci) + *voltage |= (dep_table->entries[i - 1].vddci * + VOLTAGE_SCALE) << VDDC_SHIFT; +- else ++ else { ++ vddci = phm_find_closest_vddci(&(data->vddci_voltage_table), ++ (dep_table->entries[i - 1].vddc - ++ (uint16_t)VDDC_VDDCI_DELTA)); ++ + *voltage |= (vddci * VOLTAGE_SCALE) << VDDCI_SHIFT; ++ } + + if (SMU7_VOLTAGE_CONTROL_NONE == data->mvdd_control) + *mvdd = data->vbios_boot_state.mvdd_bootup_value * VOLTAGE_SCALE; +diff --git a/drivers/gpu/drm/nouveau/nouveau_svm.c b/drivers/gpu/drm/nouveau/nouveau_svm.c +index 645fedd77e21..a9ce86740799 100644 +--- a/drivers/gpu/drm/nouveau/nouveau_svm.c ++++ b/drivers/gpu/drm/nouveau/nouveau_svm.c +@@ -534,6 +534,7 @@ static int nouveau_range_fault(struct nouveau_svmm *svmm, + .flags = nouveau_svm_pfn_flags, + .values = nouveau_svm_pfn_values, + .pfn_shift = NVIF_VMM_PFNMAP_V0_ADDR_SHIFT, ++ .dev_private_owner = drm->dev, + }; + struct mm_struct *mm = notifier->notifier.mm; + long ret; +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxg94.c b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxg94.c +index c8ab1b5741a3..db7769cb33eb 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxg94.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxg94.c +@@ -118,10 +118,10 @@ g94_i2c_aux_xfer(struct nvkm_i2c_aux *obj, bool retry, + if (retries) + udelay(400); + +- /* transaction request, wait up to 1ms for it to complete */ ++ /* transaction request, wait up to 2ms for it to complete */ + nvkm_wr32(device, 0x00e4e4 + base, 0x00010000 | ctrl); + +- timeout = 1000; ++ timeout = 2000; + do { + ctrl = nvkm_rd32(device, 0x00e4e4 + base); + udelay(1); +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxgm200.c b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxgm200.c +index 7ef60895f43a..edb6148cbca0 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxgm200.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxgm200.c +@@ -118,10 +118,10 @@ gm200_i2c_aux_xfer(struct nvkm_i2c_aux *obj, bool retry, + if (retries) + udelay(400); + +- /* transaction request, wait up to 1ms for it to complete */ ++ /* transaction request, wait up to 2ms for it to complete */ + nvkm_wr32(device, 0x00d954 + base, 0x00010000 | ctrl); + +- timeout = 1000; ++ timeout = 2000; + do { + ctrl = nvkm_rd32(device, 0x00d954 + base); + udelay(1); +diff --git a/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c b/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c +index f07e0c32b93a..4c5072a578bf 100644 +--- a/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c ++++ b/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c +@@ -263,7 +263,7 @@ sun4i_hdmi_connector_detect(struct drm_connector *connector, bool force) + unsigned long reg; + + reg = readl(hdmi->base + SUN4I_HDMI_HPD_REG); +- if (reg & SUN4I_HDMI_HPD_HIGH) { ++ if (!(reg & SUN4I_HDMI_HPD_HIGH)) { + cec_phys_addr_invalidate(hdmi->cec_adap); + return connector_status_disconnected; + } +diff --git a/drivers/hid/hid-alps.c b/drivers/hid/hid-alps.c +index b2ad319a74b9..d33f5abc8f64 100644 +--- a/drivers/hid/hid-alps.c ++++ b/drivers/hid/hid-alps.c +@@ -25,6 +25,7 @@ + + #define U1_MOUSE_REPORT_ID 0x01 /* Mouse data ReportID */ + #define U1_ABSOLUTE_REPORT_ID 0x03 /* Absolute data ReportID */ ++#define U1_ABSOLUTE_REPORT_ID_SECD 0x02 /* FW-PTP Absolute data ReportID */ + #define U1_FEATURE_REPORT_ID 0x05 /* Feature ReportID */ + #define U1_SP_ABSOLUTE_REPORT_ID 0x06 /* Feature ReportID */ + +@@ -368,6 +369,7 @@ static int u1_raw_event(struct alps_dev *hdata, u8 *data, int size) + case U1_FEATURE_REPORT_ID: + break; + case U1_ABSOLUTE_REPORT_ID: ++ case U1_ABSOLUTE_REPORT_ID_SECD: + for (i = 0; i < hdata->max_fingers; i++) { + u8 *contact = &data[i * 5]; + +diff --git a/drivers/hid/hid-apple.c b/drivers/hid/hid-apple.c +index d732d1d10caf..6909c045fece 100644 +--- a/drivers/hid/hid-apple.c ++++ b/drivers/hid/hid-apple.c +@@ -54,6 +54,7 @@ MODULE_PARM_DESC(swap_opt_cmd, "Swap the Option (\"Alt\") and Command (\"Flag\") + struct apple_sc { + unsigned long quirks; + unsigned int fn_on; ++ unsigned int fn_found; + DECLARE_BITMAP(pressed_numlock, KEY_CNT); + }; + +@@ -339,12 +340,15 @@ static int apple_input_mapping(struct hid_device *hdev, struct hid_input *hi, + struct hid_field *field, struct hid_usage *usage, + unsigned long **bit, int *max) + { ++ struct apple_sc *asc = hid_get_drvdata(hdev); ++ + if (usage->hid == (HID_UP_CUSTOM | 0x0003) || + usage->hid == (HID_UP_MSVENDOR | 0x0003) || + usage->hid == (HID_UP_HPVENDOR2 | 0x0003)) { + /* The fn key on Apple USB keyboards */ + set_bit(EV_REP, hi->input->evbit); + hid_map_usage_clear(hi, usage, bit, max, EV_KEY, KEY_FN); ++ asc->fn_found = true; + apple_setup_input(hi->input); + return 1; + } +@@ -371,6 +375,19 @@ static int apple_input_mapped(struct hid_device *hdev, struct hid_input *hi, + return 0; + } + ++static int apple_input_configured(struct hid_device *hdev, ++ struct hid_input *hidinput) ++{ ++ struct apple_sc *asc = hid_get_drvdata(hdev); ++ ++ if ((asc->quirks & APPLE_HAS_FN) && !asc->fn_found) { ++ hid_info(hdev, "Fn key not found (Apple Wireless Keyboard clone?), disabling Fn key handling\n"); ++ asc->quirks = 0; ++ } ++ ++ return 0; ++} ++ + static int apple_probe(struct hid_device *hdev, + const struct hid_device_id *id) + { +@@ -585,6 +602,7 @@ static struct hid_driver apple_driver = { + .event = apple_event, + .input_mapping = apple_input_mapping, + .input_mapped = apple_input_mapped, ++ .input_configured = apple_input_configured, + }; + module_hid_driver(apple_driver); + +diff --git a/drivers/hid/hid-steam.c b/drivers/hid/hid-steam.c +index 6286204d4c56..a3b151b29bd7 100644 +--- a/drivers/hid/hid-steam.c ++++ b/drivers/hid/hid-steam.c +@@ -526,7 +526,8 @@ static int steam_register(struct steam_device *steam) + steam_battery_register(steam); + + mutex_lock(&steam_devices_lock); +- list_add(&steam->list, &steam_devices); ++ if (list_empty(&steam->list)) ++ list_add(&steam->list, &steam_devices); + mutex_unlock(&steam_devices_lock); + } + +@@ -552,7 +553,7 @@ static void steam_unregister(struct steam_device *steam) + hid_info(steam->hdev, "Steam Controller '%s' disconnected", + steam->serial_no); + mutex_lock(&steam_devices_lock); +- list_del(&steam->list); ++ list_del_init(&steam->list); + mutex_unlock(&steam_devices_lock); + steam->serial_no[0] = 0; + } +@@ -738,6 +739,7 @@ static int steam_probe(struct hid_device *hdev, + mutex_init(&steam->mutex); + steam->quirks = id->driver_data; + INIT_WORK(&steam->work_connect, steam_work_connect_cb); ++ INIT_LIST_HEAD(&steam->list); + + steam->client_hdev = steam_create_client_hid(hdev); + if (IS_ERR(steam->client_hdev)) { +diff --git a/drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c b/drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c +index ec142bc8c1da..35f3bfc3e6f5 100644 +--- a/drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c ++++ b/drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c +@@ -373,6 +373,14 @@ static const struct dmi_system_id i2c_hid_dmi_desc_override_table[] = { + }, + .driver_data = (void *)&sipodev_desc + }, ++ { ++ .ident = "Mediacom FlexBook edge 13", ++ .matches = { ++ DMI_EXACT_MATCH(DMI_SYS_VENDOR, "MEDIACOM"), ++ DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "FlexBook_edge13-M-FBE13"), ++ }, ++ .driver_data = (void *)&sipodev_desc ++ }, + { + .ident = "Odys Winbook 13", + .matches = { +diff --git a/drivers/hwmon/aspeed-pwm-tacho.c b/drivers/hwmon/aspeed-pwm-tacho.c +index 33fb54845bf6..3d8239fd66ed 100644 +--- a/drivers/hwmon/aspeed-pwm-tacho.c ++++ b/drivers/hwmon/aspeed-pwm-tacho.c +@@ -851,6 +851,8 @@ static int aspeed_create_fan(struct device *dev, + ret = of_property_read_u32(child, "reg", &pwm_port); + if (ret) + return ret; ++ if (pwm_port >= ARRAY_SIZE(pwm_port_params)) ++ return -EINVAL; + aspeed_create_pwm_port(priv, (u8)pwm_port); + + ret = of_property_count_u8_elems(child, "cooling-levels"); +diff --git a/drivers/hwmon/nct6775.c b/drivers/hwmon/nct6775.c +index 7efa6bfef060..ba9b96973e80 100644 +--- a/drivers/hwmon/nct6775.c ++++ b/drivers/hwmon/nct6775.c +@@ -786,13 +786,13 @@ static const char *const nct6798_temp_label[] = { + "Agent1 Dimm1", + "BYTE_TEMP0", + "BYTE_TEMP1", +- "", +- "", ++ "PECI Agent 0 Calibration", /* undocumented */ ++ "PECI Agent 1 Calibration", /* undocumented */ + "", + "Virtual_TEMP" + }; + +-#define NCT6798_TEMP_MASK 0x8fff0ffe ++#define NCT6798_TEMP_MASK 0xbfff0ffe + #define NCT6798_VIRT_TEMP_MASK 0x80000c00 + + /* NCT6102D/NCT6106D specific data */ +diff --git a/drivers/hwmon/pmbus/adm1275.c b/drivers/hwmon/pmbus/adm1275.c +index e25f541227da..19317575d1c6 100644 +--- a/drivers/hwmon/pmbus/adm1275.c ++++ b/drivers/hwmon/pmbus/adm1275.c +@@ -465,6 +465,7 @@ MODULE_DEVICE_TABLE(i2c, adm1275_id); + static int adm1275_probe(struct i2c_client *client, + const struct i2c_device_id *id) + { ++ s32 (*config_read_fn)(const struct i2c_client *client, u8 reg); + u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1]; + int config, device_config; + int ret; +@@ -510,11 +511,16 @@ static int adm1275_probe(struct i2c_client *client, + "Device mismatch: Configured %s, detected %s\n", + id->name, mid->name); + +- config = i2c_smbus_read_byte_data(client, ADM1275_PMON_CONFIG); ++ if (mid->driver_data == adm1272 || mid->driver_data == adm1278 || ++ mid->driver_data == adm1293 || mid->driver_data == adm1294) ++ config_read_fn = i2c_smbus_read_word_data; ++ else ++ config_read_fn = i2c_smbus_read_byte_data; ++ config = config_read_fn(client, ADM1275_PMON_CONFIG); + if (config < 0) + return config; + +- device_config = i2c_smbus_read_byte_data(client, ADM1275_DEVICE_CONFIG); ++ device_config = config_read_fn(client, ADM1275_DEVICE_CONFIG); + if (device_config < 0) + return device_config; + +diff --git a/drivers/hwmon/scmi-hwmon.c b/drivers/hwmon/scmi-hwmon.c +index 286d3cfda7de..d421e691318b 100644 +--- a/drivers/hwmon/scmi-hwmon.c ++++ b/drivers/hwmon/scmi-hwmon.c +@@ -147,7 +147,7 @@ static enum hwmon_sensor_types scmi_types[] = { + [ENERGY] = hwmon_energy, + }; + +-static u32 hwmon_attributes[] = { ++static u32 hwmon_attributes[hwmon_max] = { + [hwmon_chip] = HWMON_C_REGISTER_TZ, + [hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL, + [hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL, +diff --git a/drivers/i2c/busses/i2c-qcom-geni.c b/drivers/i2c/busses/i2c-qcom-geni.c +index 18d1e4fd4cf3..7f130829bf01 100644 +--- a/drivers/i2c/busses/i2c-qcom-geni.c ++++ b/drivers/i2c/busses/i2c-qcom-geni.c +@@ -367,7 +367,6 @@ static int geni_i2c_rx_one_msg(struct geni_i2c_dev *gi2c, struct i2c_msg *msg, + geni_se_select_mode(se, GENI_SE_FIFO); + + writel_relaxed(len, se->base + SE_I2C_RX_TRANS_LEN); +- geni_se_setup_m_cmd(se, I2C_READ, m_param); + + if (dma_buf && geni_se_rx_dma_prep(se, dma_buf, len, &rx_dma)) { + geni_se_select_mode(se, GENI_SE_FIFO); +@@ -375,6 +374,8 @@ static int geni_i2c_rx_one_msg(struct geni_i2c_dev *gi2c, struct i2c_msg *msg, + dma_buf = NULL; + } + ++ geni_se_setup_m_cmd(se, I2C_READ, m_param); ++ + time_left = wait_for_completion_timeout(&gi2c->done, XFER_TIMEOUT); + if (!time_left) + geni_i2c_abort_xfer(gi2c); +@@ -408,7 +409,6 @@ static int geni_i2c_tx_one_msg(struct geni_i2c_dev *gi2c, struct i2c_msg *msg, + geni_se_select_mode(se, GENI_SE_FIFO); + + writel_relaxed(len, se->base + SE_I2C_TX_TRANS_LEN); +- geni_se_setup_m_cmd(se, I2C_WRITE, m_param); + + if (dma_buf && geni_se_tx_dma_prep(se, dma_buf, len, &tx_dma)) { + geni_se_select_mode(se, GENI_SE_FIFO); +@@ -416,6 +416,8 @@ static int geni_i2c_tx_one_msg(struct geni_i2c_dev *gi2c, struct i2c_msg *msg, + dma_buf = NULL; + } + ++ geni_se_setup_m_cmd(se, I2C_WRITE, m_param); ++ + if (!dma_buf) /* Get FIFO IRQ */ + writel_relaxed(1, se->base + SE_GENI_TX_WATERMARK_REG); + +diff --git a/drivers/i2c/busses/i2c-rcar.c b/drivers/i2c/busses/i2c-rcar.c +index 3b5397aa4ca6..50dd98803ca0 100644 +--- a/drivers/i2c/busses/i2c-rcar.c ++++ b/drivers/i2c/busses/i2c-rcar.c +@@ -868,6 +868,7 @@ static int rcar_unreg_slave(struct i2c_client *slave) + /* disable irqs and ensure none is running before clearing ptr */ + rcar_i2c_write(priv, ICSIER, 0); + rcar_i2c_write(priv, ICSCR, 0); ++ rcar_i2c_write(priv, ICSAR, 0); /* Gen2: must be 0 if not using slave */ + + synchronize_irq(priv->irq); + priv->slave = NULL; +@@ -971,6 +972,8 @@ static int rcar_i2c_probe(struct platform_device *pdev) + if (ret < 0) + goto out_pm_put; + ++ rcar_i2c_write(priv, ICSAR, 0); /* Gen2: must be 0 if not using slave */ ++ + if (priv->devtype == I2C_RCAR_GEN3) { + priv->rstc = devm_reset_control_get_exclusive(&pdev->dev, NULL); + if (!IS_ERR(priv->rstc)) { +diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c +index 1c2bf18cda9f..83b66757c7ae 100644 +--- a/drivers/infiniband/core/cm.c ++++ b/drivers/infiniband/core/cm.c +@@ -3723,10 +3723,12 @@ static int cm_send_sidr_rep_locked(struct cm_id_private *cm_id_priv, + return ret; + } + cm_id_priv->id.state = IB_CM_IDLE; ++ spin_lock_irq(&cm.lock); + if (!RB_EMPTY_NODE(&cm_id_priv->sidr_id_node)) { + rb_erase(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table); + RB_CLEAR_NODE(&cm_id_priv->sidr_id_node); + } ++ spin_unlock_irq(&cm.lock); + return 0; + } + +diff --git a/drivers/infiniband/core/rdma_core.c b/drivers/infiniband/core/rdma_core.c +index 75bcbc625616..3ab84fcbaade 100644 +--- a/drivers/infiniband/core/rdma_core.c ++++ b/drivers/infiniband/core/rdma_core.c +@@ -638,9 +638,6 @@ void rdma_alloc_commit_uobject(struct ib_uobject *uobj, + { + struct ib_uverbs_file *ufile = attrs->ufile; + +- /* alloc_commit consumes the uobj kref */ +- uobj->uapi_object->type_class->alloc_commit(uobj); +- + /* kref is held so long as the uobj is on the uobj list. */ + uverbs_uobject_get(uobj); + spin_lock_irq(&ufile->uobjects_lock); +@@ -650,6 +647,9 @@ void rdma_alloc_commit_uobject(struct ib_uobject *uobj, + /* matches atomic_set(-1) in alloc_uobj */ + atomic_set(&uobj->usecnt, 0); + ++ /* alloc_commit consumes the uobj kref */ ++ uobj->uapi_object->type_class->alloc_commit(uobj); ++ + /* Matches the down_read in rdma_alloc_begin_uobject */ + up_read(&ufile->hw_destroy_rwsem); + } +diff --git a/drivers/infiniband/hw/mlx5/odp.c b/drivers/infiniband/hw/mlx5/odp.c +index 3de7606d4a1a..bdeb6500a919 100644 +--- a/drivers/infiniband/hw/mlx5/odp.c ++++ b/drivers/infiniband/hw/mlx5/odp.c +@@ -601,6 +601,23 @@ void mlx5_ib_free_implicit_mr(struct mlx5_ib_mr *imr) + */ + synchronize_srcu(&dev->odp_srcu); + ++ /* ++ * All work on the prefetch list must be completed, xa_erase() prevented ++ * new work from being created. ++ */ ++ wait_event(imr->q_deferred_work, !atomic_read(&imr->num_deferred_work)); ++ ++ /* ++ * At this point it is forbidden for any other thread to enter ++ * pagefault_mr() on this imr. It is already forbidden to call ++ * pagefault_mr() on an implicit child. Due to this additions to ++ * implicit_children are prevented. ++ */ ++ ++ /* ++ * Block destroy_unused_implicit_child_mr() from incrementing ++ * num_deferred_work. ++ */ + xa_lock(&imr->implicit_children); + xa_for_each (&imr->implicit_children, idx, mtt) { + __xa_erase(&imr->implicit_children, idx); +@@ -609,9 +626,8 @@ void mlx5_ib_free_implicit_mr(struct mlx5_ib_mr *imr) + xa_unlock(&imr->implicit_children); + + /* +- * num_deferred_work can only be incremented inside the odp_srcu, or +- * under xa_lock while the child is in the xarray. Thus at this point +- * it is only decreasing, and all work holding it is now on the wq. ++ * Wait for any concurrent destroy_unused_implicit_child_mr() to ++ * complete. + */ + wait_event(imr->q_deferred_work, !atomic_read(&imr->num_deferred_work)); + +diff --git a/drivers/infiniband/hw/mlx5/srq_cmd.c b/drivers/infiniband/hw/mlx5/srq_cmd.c +index 8fc3630a9d4c..0224231a2e6f 100644 +--- a/drivers/infiniband/hw/mlx5/srq_cmd.c ++++ b/drivers/infiniband/hw/mlx5/srq_cmd.c +@@ -83,11 +83,11 @@ struct mlx5_core_srq *mlx5_cmd_get_srq(struct mlx5_ib_dev *dev, u32 srqn) + struct mlx5_srq_table *table = &dev->srq_table; + struct mlx5_core_srq *srq; + +- xa_lock(&table->array); ++ xa_lock_irq(&table->array); + srq = xa_load(&table->array, srqn); + if (srq) + refcount_inc(&srq->common.refcount); +- xa_unlock(&table->array); ++ xa_unlock_irq(&table->array); + + return srq; + } +diff --git a/drivers/input/mouse/elan_i2c_core.c b/drivers/input/mouse/elan_i2c_core.c +index 8719da540383..196e8505dd8d 100644 +--- a/drivers/input/mouse/elan_i2c_core.c ++++ b/drivers/input/mouse/elan_i2c_core.c +@@ -951,6 +951,8 @@ static void elan_report_absolute(struct elan_tp_data *data, u8 *packet) + u8 hover_info = packet[ETP_HOVER_INFO_OFFSET]; + bool contact_valid, hover_event; + ++ pm_wakeup_event(&data->client->dev, 0); ++ + hover_event = hover_info & 0x40; + for (i = 0; i < ETP_MAX_FINGERS; i++) { + contact_valid = tp_info & (1U << (3 + i)); +@@ -974,6 +976,8 @@ static void elan_report_trackpoint(struct elan_tp_data *data, u8 *report) + u8 *packet = &report[ETP_REPORT_ID_OFFSET + 1]; + int x, y; + ++ pm_wakeup_event(&data->client->dev, 0); ++ + if (!data->tp_input) { + dev_warn_once(&data->client->dev, + "received a trackpoint report while no trackpoint device has been created. Please report upstream.\n"); +@@ -998,7 +1002,6 @@ static void elan_report_trackpoint(struct elan_tp_data *data, u8 *report) + static irqreturn_t elan_isr(int irq, void *dev_id) + { + struct elan_tp_data *data = dev_id; +- struct device *dev = &data->client->dev; + int error; + u8 report[ETP_MAX_REPORT_LEN]; + +@@ -1016,8 +1019,6 @@ static irqreturn_t elan_isr(int irq, void *dev_id) + if (error) + goto out; + +- pm_wakeup_event(dev, 0); +- + switch (report[ETP_REPORT_ID_OFFSET]) { + case ETP_REPORT_ID: + elan_report_absolute(data, report); +@@ -1026,7 +1027,7 @@ static irqreturn_t elan_isr(int irq, void *dev_id) + elan_report_trackpoint(data, report); + break; + default: +- dev_err(dev, "invalid report id data (%x)\n", ++ dev_err(&data->client->dev, "invalid report id data (%x)\n", + report[ETP_REPORT_ID_OFFSET]); + } + +diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c +index 758dae8d6500..4b81b2d0fe06 100644 +--- a/drivers/input/mouse/synaptics.c ++++ b/drivers/input/mouse/synaptics.c +@@ -179,6 +179,7 @@ static const char * const smbus_pnp_ids[] = { + "LEN0093", /* T480 */ + "LEN0096", /* X280 */ + "LEN0097", /* X280 -> ALPS trackpoint */ ++ "LEN0099", /* X1 Extreme 1st */ + "LEN009b", /* T580 */ + "LEN200f", /* T450s */ + "LEN2044", /* L470 */ +diff --git a/drivers/interconnect/qcom/msm8916.c b/drivers/interconnect/qcom/msm8916.c +index e94f3c5228b7..42c6c5581662 100644 +--- a/drivers/interconnect/qcom/msm8916.c ++++ b/drivers/interconnect/qcom/msm8916.c +@@ -197,13 +197,13 @@ DEFINE_QNODE(pcnoc_int_0, MSM8916_PNOC_INT_0, 8, -1, -1, MSM8916_PNOC_SNOC_MAS, + DEFINE_QNODE(pcnoc_int_1, MSM8916_PNOC_INT_1, 8, -1, -1, MSM8916_PNOC_SNOC_MAS); + DEFINE_QNODE(pcnoc_m_0, MSM8916_PNOC_MAS_0, 8, -1, -1, MSM8916_PNOC_INT_0); + DEFINE_QNODE(pcnoc_m_1, MSM8916_PNOC_MAS_1, 8, -1, -1, MSM8916_PNOC_SNOC_MAS); +-DEFINE_QNODE(pcnoc_s_0, MSM8916_PNOC_SLV_0, 8, -1, -1, MSM8916_SLAVE_CLK_CTL, MSM8916_SLAVE_TLMM, MSM8916_SLAVE_TCSR, MSM8916_SLAVE_SECURITY, MSM8916_SLAVE_MSS); +-DEFINE_QNODE(pcnoc_s_1, MSM8916_PNOC_SLV_1, 8, -1, -1, MSM8916_SLAVE_IMEM_CFG, MSM8916_SLAVE_CRYPTO_0_CFG, MSM8916_SLAVE_MSG_RAM, MSM8916_SLAVE_PDM, MSM8916_SLAVE_PRNG); +-DEFINE_QNODE(pcnoc_s_2, MSM8916_PNOC_SLV_2, 8, -1, -1, MSM8916_SLAVE_SPDM, MSM8916_SLAVE_BOOT_ROM, MSM8916_SLAVE_BIMC_CFG, MSM8916_SLAVE_PNOC_CFG, MSM8916_SLAVE_PMIC_ARB); +-DEFINE_QNODE(pcnoc_s_3, MSM8916_PNOC_SLV_3, 8, -1, -1, MSM8916_SLAVE_MPM, MSM8916_SLAVE_SNOC_CFG, MSM8916_SLAVE_RBCPR_CFG, MSM8916_SLAVE_QDSS_CFG, MSM8916_SLAVE_DEHR_CFG); +-DEFINE_QNODE(pcnoc_s_4, MSM8916_PNOC_SLV_4, 8, -1, -1, MSM8916_SLAVE_VENUS_CFG, MSM8916_SLAVE_CAMERA_CFG, MSM8916_SLAVE_DISPLAY_CFG); +-DEFINE_QNODE(pcnoc_s_8, MSM8916_PNOC_SLV_8, 8, -1, -1, MSM8916_SLAVE_USB_HS, MSM8916_SLAVE_SDCC_1, MSM8916_SLAVE_BLSP_1); +-DEFINE_QNODE(pcnoc_s_9, MSM8916_PNOC_SLV_9, 8, -1, -1, MSM8916_SLAVE_SDCC_2, MSM8916_SLAVE_LPASS, MSM8916_SLAVE_GRAPHICS_3D_CFG); ++DEFINE_QNODE(pcnoc_s_0, MSM8916_PNOC_SLV_0, 4, -1, -1, MSM8916_SLAVE_CLK_CTL, MSM8916_SLAVE_TLMM, MSM8916_SLAVE_TCSR, MSM8916_SLAVE_SECURITY, MSM8916_SLAVE_MSS); ++DEFINE_QNODE(pcnoc_s_1, MSM8916_PNOC_SLV_1, 4, -1, -1, MSM8916_SLAVE_IMEM_CFG, MSM8916_SLAVE_CRYPTO_0_CFG, MSM8916_SLAVE_MSG_RAM, MSM8916_SLAVE_PDM, MSM8916_SLAVE_PRNG); ++DEFINE_QNODE(pcnoc_s_2, MSM8916_PNOC_SLV_2, 4, -1, -1, MSM8916_SLAVE_SPDM, MSM8916_SLAVE_BOOT_ROM, MSM8916_SLAVE_BIMC_CFG, MSM8916_SLAVE_PNOC_CFG, MSM8916_SLAVE_PMIC_ARB); ++DEFINE_QNODE(pcnoc_s_3, MSM8916_PNOC_SLV_3, 4, -1, -1, MSM8916_SLAVE_MPM, MSM8916_SLAVE_SNOC_CFG, MSM8916_SLAVE_RBCPR_CFG, MSM8916_SLAVE_QDSS_CFG, MSM8916_SLAVE_DEHR_CFG); ++DEFINE_QNODE(pcnoc_s_4, MSM8916_PNOC_SLV_4, 4, -1, -1, MSM8916_SLAVE_VENUS_CFG, MSM8916_SLAVE_CAMERA_CFG, MSM8916_SLAVE_DISPLAY_CFG); ++DEFINE_QNODE(pcnoc_s_8, MSM8916_PNOC_SLV_8, 4, -1, -1, MSM8916_SLAVE_USB_HS, MSM8916_SLAVE_SDCC_1, MSM8916_SLAVE_BLSP_1); ++DEFINE_QNODE(pcnoc_s_9, MSM8916_PNOC_SLV_9, 4, -1, -1, MSM8916_SLAVE_SDCC_2, MSM8916_SLAVE_LPASS, MSM8916_SLAVE_GRAPHICS_3D_CFG); + DEFINE_QNODE(pcnoc_snoc_mas, MSM8916_PNOC_SNOC_MAS, 8, 29, -1, MSM8916_PNOC_SNOC_SLV); + DEFINE_QNODE(pcnoc_snoc_slv, MSM8916_PNOC_SNOC_SLV, 8, -1, 45, MSM8916_SNOC_INT_0, MSM8916_SNOC_INT_BIMC, MSM8916_SNOC_INT_1); + DEFINE_QNODE(qdss_int, MSM8916_SNOC_QDSS_INT, 8, -1, -1, MSM8916_SNOC_INT_0, MSM8916_SNOC_INT_BIMC); +diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c +index 2883ac389abb..9c2e2ed82826 100644 +--- a/drivers/iommu/amd_iommu.c ++++ b/drivers/iommu/amd_iommu.c +@@ -4090,9 +4090,10 @@ int amd_iommu_create_irq_domain(struct amd_iommu *iommu) + if (!fn) + return -ENOMEM; + iommu->ir_domain = irq_domain_create_tree(fn, &amd_ir_domain_ops, iommu); +- irq_domain_free_fwnode(fn); +- if (!iommu->ir_domain) ++ if (!iommu->ir_domain) { ++ irq_domain_free_fwnode(fn); + return -ENOMEM; ++ } + + iommu->ir_domain->parent = arch_get_ir_parent_domain(); + iommu->msi_domain = arch_create_remap_msi_irq_domain(iommu->ir_domain, +diff --git a/drivers/iommu/hyperv-iommu.c b/drivers/iommu/hyperv-iommu.c +index a386b83e0e34..f0fe5030acd3 100644 +--- a/drivers/iommu/hyperv-iommu.c ++++ b/drivers/iommu/hyperv-iommu.c +@@ -155,7 +155,10 @@ static int __init hyperv_prepare_irq_remapping(void) + 0, IOAPIC_REMAPPING_ENTRY, fn, + &hyperv_ir_domain_ops, NULL); + +- irq_domain_free_fwnode(fn); ++ if (!ioapic_ir_domain) { ++ irq_domain_free_fwnode(fn); ++ return -ENOMEM; ++ } + + /* + * Hyper-V doesn't provide irq remapping function for +diff --git a/drivers/iommu/intel_irq_remapping.c b/drivers/iommu/intel_irq_remapping.c +index 81e43c1df7ec..982d796b686b 100644 +--- a/drivers/iommu/intel_irq_remapping.c ++++ b/drivers/iommu/intel_irq_remapping.c +@@ -563,8 +563,8 @@ static int intel_setup_irq_remapping(struct intel_iommu *iommu) + 0, INTR_REMAP_TABLE_ENTRIES, + fn, &intel_ir_domain_ops, + iommu); +- irq_domain_free_fwnode(fn); + if (!iommu->ir_domain) { ++ irq_domain_free_fwnode(fn); + pr_err("IR%d: failed to allocate irqdomain\n", iommu->seq_id); + goto out_free_bitmap; + } +diff --git a/drivers/iommu/qcom_iommu.c b/drivers/iommu/qcom_iommu.c +index 5b3b270972f8..c6277d7398f3 100644 +--- a/drivers/iommu/qcom_iommu.c ++++ b/drivers/iommu/qcom_iommu.c +@@ -65,6 +65,7 @@ struct qcom_iommu_domain { + struct mutex init_mutex; /* Protects iommu pointer */ + struct iommu_domain domain; + struct qcom_iommu_dev *iommu; ++ struct iommu_fwspec *fwspec; + }; + + static struct qcom_iommu_domain *to_qcom_iommu_domain(struct iommu_domain *dom) +@@ -84,9 +85,9 @@ static struct qcom_iommu_dev * to_iommu(struct device *dev) + return dev_iommu_priv_get(dev); + } + +-static struct qcom_iommu_ctx * to_ctx(struct device *dev, unsigned asid) ++static struct qcom_iommu_ctx * to_ctx(struct qcom_iommu_domain *d, unsigned asid) + { +- struct qcom_iommu_dev *qcom_iommu = to_iommu(dev); ++ struct qcom_iommu_dev *qcom_iommu = d->iommu; + if (!qcom_iommu) + return NULL; + return qcom_iommu->ctxs[asid - 1]; +@@ -118,14 +119,12 @@ iommu_readq(struct qcom_iommu_ctx *ctx, unsigned reg) + + static void qcom_iommu_tlb_sync(void *cookie) + { +- struct iommu_fwspec *fwspec; +- struct device *dev = cookie; ++ struct qcom_iommu_domain *qcom_domain = cookie; ++ struct iommu_fwspec *fwspec = qcom_domain->fwspec; + unsigned i; + +- fwspec = dev_iommu_fwspec_get(dev); +- + for (i = 0; i < fwspec->num_ids; i++) { +- struct qcom_iommu_ctx *ctx = to_ctx(dev, fwspec->ids[i]); ++ struct qcom_iommu_ctx *ctx = to_ctx(qcom_domain, fwspec->ids[i]); + unsigned int val, ret; + + iommu_writel(ctx, ARM_SMMU_CB_TLBSYNC, 0); +@@ -139,14 +138,12 @@ static void qcom_iommu_tlb_sync(void *cookie) + + static void qcom_iommu_tlb_inv_context(void *cookie) + { +- struct device *dev = cookie; +- struct iommu_fwspec *fwspec; ++ struct qcom_iommu_domain *qcom_domain = cookie; ++ struct iommu_fwspec *fwspec = qcom_domain->fwspec; + unsigned i; + +- fwspec = dev_iommu_fwspec_get(dev); +- + for (i = 0; i < fwspec->num_ids; i++) { +- struct qcom_iommu_ctx *ctx = to_ctx(dev, fwspec->ids[i]); ++ struct qcom_iommu_ctx *ctx = to_ctx(qcom_domain, fwspec->ids[i]); + iommu_writel(ctx, ARM_SMMU_CB_S1_TLBIASID, ctx->asid); + } + +@@ -156,16 +153,14 @@ static void qcom_iommu_tlb_inv_context(void *cookie) + static void qcom_iommu_tlb_inv_range_nosync(unsigned long iova, size_t size, + size_t granule, bool leaf, void *cookie) + { +- struct device *dev = cookie; +- struct iommu_fwspec *fwspec; ++ struct qcom_iommu_domain *qcom_domain = cookie; ++ struct iommu_fwspec *fwspec = qcom_domain->fwspec; + unsigned i, reg; + + reg = leaf ? ARM_SMMU_CB_S1_TLBIVAL : ARM_SMMU_CB_S1_TLBIVA; + +- fwspec = dev_iommu_fwspec_get(dev); +- + for (i = 0; i < fwspec->num_ids; i++) { +- struct qcom_iommu_ctx *ctx = to_ctx(dev, fwspec->ids[i]); ++ struct qcom_iommu_ctx *ctx = to_ctx(qcom_domain, fwspec->ids[i]); + size_t s = size; + + iova = (iova >> 12) << 12; +@@ -256,7 +251,9 @@ static int qcom_iommu_init_domain(struct iommu_domain *domain, + }; + + qcom_domain->iommu = qcom_iommu; +- pgtbl_ops = alloc_io_pgtable_ops(ARM_32_LPAE_S1, &pgtbl_cfg, dev); ++ qcom_domain->fwspec = fwspec; ++ ++ pgtbl_ops = alloc_io_pgtable_ops(ARM_32_LPAE_S1, &pgtbl_cfg, qcom_domain); + if (!pgtbl_ops) { + dev_err(qcom_iommu->dev, "failed to allocate pagetable ops\n"); + ret = -ENOMEM; +@@ -269,7 +266,7 @@ static int qcom_iommu_init_domain(struct iommu_domain *domain, + domain->geometry.force_aperture = true; + + for (i = 0; i < fwspec->num_ids; i++) { +- struct qcom_iommu_ctx *ctx = to_ctx(dev, fwspec->ids[i]); ++ struct qcom_iommu_ctx *ctx = to_ctx(qcom_domain, fwspec->ids[i]); + + if (!ctx->secure_init) { + ret = qcom_scm_restore_sec_cfg(qcom_iommu->sec_id, ctx->asid); +@@ -419,7 +416,7 @@ static void qcom_iommu_detach_dev(struct iommu_domain *domain, struct device *de + + pm_runtime_get_sync(qcom_iommu->dev); + for (i = 0; i < fwspec->num_ids; i++) { +- struct qcom_iommu_ctx *ctx = to_ctx(dev, fwspec->ids[i]); ++ struct qcom_iommu_ctx *ctx = to_ctx(qcom_domain, fwspec->ids[i]); + + /* Disable the context bank: */ + iommu_writel(ctx, ARM_SMMU_CB_SCTLR, 0); +diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c +index 4094c47eca7f..8588fb59a3ed 100644 +--- a/drivers/md/dm-integrity.c ++++ b/drivers/md/dm-integrity.c +@@ -2424,7 +2424,7 @@ static void integrity_writer(struct work_struct *w) + unsigned prev_free_sectors; + + /* the following test is not needed, but it tests the replay code */ +- if (unlikely(dm_suspended(ic->ti)) && !ic->meta_dev) ++ if (unlikely(dm_post_suspending(ic->ti)) && !ic->meta_dev) + return; + + spin_lock_irq(&ic->endio_wait.lock); +@@ -2485,7 +2485,7 @@ static void integrity_recalc(struct work_struct *w) + + next_chunk: + +- if (unlikely(dm_suspended(ic->ti))) ++ if (unlikely(dm_post_suspending(ic->ti))) + goto unlock_ret; + + range.logical_sector = le64_to_cpu(ic->sb->recalc_sector); +diff --git a/drivers/md/dm.c b/drivers/md/dm.c +index 05333fc2f8d2..fabcc51b468c 100644 +--- a/drivers/md/dm.c ++++ b/drivers/md/dm.c +@@ -142,6 +142,7 @@ EXPORT_SYMBOL_GPL(dm_bio_get_target_bio_nr); + #define DMF_NOFLUSH_SUSPENDING 5 + #define DMF_DEFERRED_REMOVE 6 + #define DMF_SUSPENDED_INTERNALLY 7 ++#define DMF_POST_SUSPENDING 8 + + #define DM_NUMA_NODE NUMA_NO_NODE + static int dm_numa_node = DM_NUMA_NODE; +@@ -1446,9 +1447,6 @@ static int __send_empty_flush(struct clone_info *ci) + BUG_ON(bio_has_data(ci->bio)); + while ((ti = dm_table_get_target(ci->map, target_nr++))) + __send_duplicate_bios(ci, ti, ti->num_flush_bios, NULL); +- +- bio_disassociate_blkg(ci->bio); +- + return 0; + } + +@@ -1636,6 +1634,7 @@ static blk_qc_t __split_and_process_bio(struct mapped_device *md, + ci.bio = &flush_bio; + ci.sector_count = 0; + error = __send_empty_flush(&ci); ++ bio_uninit(ci.bio); + /* dec_pending submits any data associated with flush */ + } else if (op_is_zone_mgmt(bio_op(bio))) { + ci.bio = bio; +@@ -1710,6 +1709,7 @@ static blk_qc_t __process_bio(struct mapped_device *md, struct dm_table *map, + ci.bio = &flush_bio; + ci.sector_count = 0; + error = __send_empty_flush(&ci); ++ bio_uninit(ci.bio); + /* dec_pending submits any data associated with flush */ + } else { + struct dm_target_io *tio; +@@ -2399,6 +2399,7 @@ static void __dm_destroy(struct mapped_device *md, bool wait) + if (!dm_suspended_md(md)) { + dm_table_presuspend_targets(map); + set_bit(DMF_SUSPENDED, &md->flags); ++ set_bit(DMF_POST_SUSPENDING, &md->flags); + dm_table_postsuspend_targets(map); + } + /* dm_put_live_table must be before msleep, otherwise deadlock is possible */ +@@ -2721,7 +2722,9 @@ retry: + if (r) + goto out_unlock; + ++ set_bit(DMF_POST_SUSPENDING, &md->flags); + dm_table_postsuspend_targets(map); ++ clear_bit(DMF_POST_SUSPENDING, &md->flags); + + out_unlock: + mutex_unlock(&md->suspend_lock); +@@ -2818,7 +2821,9 @@ static void __dm_internal_suspend(struct mapped_device *md, unsigned suspend_fla + (void) __dm_suspend(md, map, suspend_flags, TASK_UNINTERRUPTIBLE, + DMF_SUSPENDED_INTERNALLY); + ++ set_bit(DMF_POST_SUSPENDING, &md->flags); + dm_table_postsuspend_targets(map); ++ clear_bit(DMF_POST_SUSPENDING, &md->flags); + } + + static void __dm_internal_resume(struct mapped_device *md) +@@ -2979,6 +2984,11 @@ int dm_suspended_md(struct mapped_device *md) + return test_bit(DMF_SUSPENDED, &md->flags); + } + ++static int dm_post_suspending_md(struct mapped_device *md) ++{ ++ return test_bit(DMF_POST_SUSPENDING, &md->flags); ++} ++ + int dm_suspended_internally_md(struct mapped_device *md) + { + return test_bit(DMF_SUSPENDED_INTERNALLY, &md->flags); +@@ -2995,6 +3005,12 @@ int dm_suspended(struct dm_target *ti) + } + EXPORT_SYMBOL_GPL(dm_suspended); + ++int dm_post_suspending(struct dm_target *ti) ++{ ++ return dm_post_suspending_md(dm_table_get_md(ti->table)); ++} ++EXPORT_SYMBOL_GPL(dm_post_suspending); ++ + int dm_noflush_suspending(struct dm_target *ti) + { + return __noflush_suspending(dm_table_get_md(ti->table)); +diff --git a/drivers/mfd/ioc3.c b/drivers/mfd/ioc3.c +index 02998d4eb74b..74cee7cb0afc 100644 +--- a/drivers/mfd/ioc3.c ++++ b/drivers/mfd/ioc3.c +@@ -142,10 +142,11 @@ static int ioc3_irq_domain_setup(struct ioc3_priv_data *ipd, int irq) + goto err; + + domain = irq_domain_create_linear(fn, 24, &ioc3_irq_domain_ops, ipd); +- if (!domain) ++ if (!domain) { ++ irq_domain_free_fwnode(fn); + goto err; ++ } + +- irq_domain_free_fwnode(fn); + ipd->domain = domain; + + irq_set_chained_handler_and_data(irq, ioc3_irq_handler, domain); +diff --git a/drivers/mmc/host/sdhci-of-aspeed.c b/drivers/mmc/host/sdhci-of-aspeed.c +index 56912e30c47e..a1bcc0f4ba9e 100644 +--- a/drivers/mmc/host/sdhci-of-aspeed.c ++++ b/drivers/mmc/host/sdhci-of-aspeed.c +@@ -68,7 +68,7 @@ static void aspeed_sdhci_set_clock(struct sdhci_host *host, unsigned int clock) + if (WARN_ON(clock > host->max_clk)) + clock = host->max_clk; + +- for (div = 1; div < 256; div *= 2) { ++ for (div = 2; div < 256; div *= 2) { + if ((parent / div) <= clock) + break; + } +diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c +index 2e70e43c5df5..6b40b5ab143a 100644 +--- a/drivers/net/bonding/bond_main.c ++++ b/drivers/net/bonding/bond_main.c +@@ -4953,15 +4953,19 @@ int bond_create(struct net *net, const char *name) + bond_dev->rtnl_link_ops = &bond_link_ops; + + res = register_netdevice(bond_dev); ++ if (res < 0) { ++ free_netdev(bond_dev); ++ rtnl_unlock(); ++ ++ return res; ++ } + + netif_carrier_off(bond_dev); + + bond_work_init_all(bond); + + rtnl_unlock(); +- if (res < 0) +- free_netdev(bond_dev); +- return res; ++ return 0; + } + + static int __net_init bond_net_init(struct net *net) +diff --git a/drivers/net/bonding/bond_netlink.c b/drivers/net/bonding/bond_netlink.c +index b43b51646b11..f0f9138e967f 100644 +--- a/drivers/net/bonding/bond_netlink.c ++++ b/drivers/net/bonding/bond_netlink.c +@@ -456,11 +456,10 @@ static int bond_newlink(struct net *src_net, struct net_device *bond_dev, + return err; + + err = register_netdevice(bond_dev); +- +- netif_carrier_off(bond_dev); + if (!err) { + struct bonding *bond = netdev_priv(bond_dev); + ++ netif_carrier_off(bond_dev); + bond_work_init_all(bond); + } + +diff --git a/drivers/net/dsa/microchip/ksz9477.c b/drivers/net/dsa/microchip/ksz9477.c +index 65701e65b6c2..95a406e2e373 100644 +--- a/drivers/net/dsa/microchip/ksz9477.c ++++ b/drivers/net/dsa/microchip/ksz9477.c +@@ -977,23 +977,6 @@ static void ksz9477_port_mirror_del(struct dsa_switch *ds, int port, + PORT_MIRROR_SNIFFER, false); + } + +-static void ksz9477_phy_setup(struct ksz_device *dev, int port, +- struct phy_device *phy) +-{ +- /* Only apply to port with PHY. */ +- if (port >= dev->phy_port_cnt) +- return; +- +- /* The MAC actually cannot run in 1000 half-duplex mode. */ +- phy_remove_link_mode(phy, +- ETHTOOL_LINK_MODE_1000baseT_Half_BIT); +- +- /* PHY does not support gigabit. */ +- if (!(dev->features & GBIT_SUPPORT)) +- phy_remove_link_mode(phy, +- ETHTOOL_LINK_MODE_1000baseT_Full_BIT); +-} +- + static bool ksz9477_get_gbit(struct ksz_device *dev, u8 data) + { + bool gbit; +@@ -1606,7 +1589,6 @@ static const struct ksz_dev_ops ksz9477_dev_ops = { + .get_port_addr = ksz9477_get_port_addr, + .cfg_port_member = ksz9477_cfg_port_member, + .flush_dyn_mac_table = ksz9477_flush_dyn_mac_table, +- .phy_setup = ksz9477_phy_setup, + .port_setup = ksz9477_port_setup, + .r_mib_cnt = ksz9477_r_mib_cnt, + .r_mib_pkt = ksz9477_r_mib_pkt, +@@ -1620,7 +1602,29 @@ static const struct ksz_dev_ops ksz9477_dev_ops = { + + int ksz9477_switch_register(struct ksz_device *dev) + { +- return ksz_switch_register(dev, &ksz9477_dev_ops); ++ int ret, i; ++ struct phy_device *phydev; ++ ++ ret = ksz_switch_register(dev, &ksz9477_dev_ops); ++ if (ret) ++ return ret; ++ ++ for (i = 0; i < dev->phy_port_cnt; ++i) { ++ if (!dsa_is_user_port(dev->ds, i)) ++ continue; ++ ++ phydev = dsa_to_port(dev->ds, i)->slave->phydev; ++ ++ /* The MAC actually cannot run in 1000 half-duplex mode. */ ++ phy_remove_link_mode(phydev, ++ ETHTOOL_LINK_MODE_1000baseT_Half_BIT); ++ ++ /* PHY does not support gigabit. */ ++ if (!(dev->features & GBIT_SUPPORT)) ++ phy_remove_link_mode(phydev, ++ ETHTOOL_LINK_MODE_1000baseT_Full_BIT); ++ } ++ return ret; + } + EXPORT_SYMBOL(ksz9477_switch_register); + +diff --git a/drivers/net/dsa/microchip/ksz_common.c b/drivers/net/dsa/microchip/ksz_common.c +index fd1d6676ae4f..7b6c0dce7536 100644 +--- a/drivers/net/dsa/microchip/ksz_common.c ++++ b/drivers/net/dsa/microchip/ksz_common.c +@@ -358,8 +358,6 @@ int ksz_enable_port(struct dsa_switch *ds, int port, struct phy_device *phy) + + /* setup slave port */ + dev->dev_ops->port_setup(dev, port, false); +- if (dev->dev_ops->phy_setup) +- dev->dev_ops->phy_setup(dev, port, phy); + + /* port_stp_state_set() will be called after to enable the port so + * there is no need to do anything. +diff --git a/drivers/net/dsa/microchip/ksz_common.h b/drivers/net/dsa/microchip/ksz_common.h +index f2c9bb68fd33..7d11dd32ec0d 100644 +--- a/drivers/net/dsa/microchip/ksz_common.h ++++ b/drivers/net/dsa/microchip/ksz_common.h +@@ -119,8 +119,6 @@ struct ksz_dev_ops { + u32 (*get_port_addr)(int port, int offset); + void (*cfg_port_member)(struct ksz_device *dev, int port, u8 member); + void (*flush_dyn_mac_table)(struct ksz_device *dev, int port); +- void (*phy_setup)(struct ksz_device *dev, int port, +- struct phy_device *phy); + void (*port_cleanup)(struct ksz_device *dev, int port); + void (*port_setup)(struct ksz_device *dev, int port, bool cpu_port); + void (*r_phy)(struct ksz_device *dev, u16 phy, u16 reg, u16 *val); +diff --git a/drivers/net/dsa/mv88e6xxx/chip.c b/drivers/net/dsa/mv88e6xxx/chip.c +index 2b4a723c8306..e065be419a03 100644 +--- a/drivers/net/dsa/mv88e6xxx/chip.c ++++ b/drivers/net/dsa/mv88e6xxx/chip.c +@@ -664,8 +664,11 @@ static void mv88e6xxx_mac_config(struct dsa_switch *ds, int port, + const struct phylink_link_state *state) + { + struct mv88e6xxx_chip *chip = ds->priv; ++ struct mv88e6xxx_port *p; + int err; + ++ p = &chip->ports[port]; ++ + /* FIXME: is this the correct test? If we're in fixed mode on an + * internal port, why should we process this any different from + * PHY mode? On the other hand, the port may be automedia between +@@ -675,10 +678,14 @@ static void mv88e6xxx_mac_config(struct dsa_switch *ds, int port, + return; + + mv88e6xxx_reg_lock(chip); +- /* FIXME: should we force the link down here - but if we do, how +- * do we restore the link force/unforce state? The driver layering +- * gets in the way. ++ /* In inband mode, the link may come up at any time while the link ++ * is not forced down. Force the link down while we reconfigure the ++ * interface mode. + */ ++ if (mode == MLO_AN_INBAND && p->interface != state->interface && ++ chip->info->ops->port_set_link) ++ chip->info->ops->port_set_link(chip, port, LINK_FORCED_DOWN); ++ + err = mv88e6xxx_port_config_interface(chip, port, state->interface); + if (err && err != -EOPNOTSUPP) + goto err_unlock; +@@ -691,6 +698,15 @@ static void mv88e6xxx_mac_config(struct dsa_switch *ds, int port, + if (err > 0) + err = 0; + ++ /* Undo the forced down state above after completing configuration ++ * irrespective of its state on entry, which allows the link to come up. ++ */ ++ if (mode == MLO_AN_INBAND && p->interface != state->interface && ++ chip->info->ops->port_set_link) ++ chip->info->ops->port_set_link(chip, port, LINK_UNFORCED); ++ ++ p->interface = state->interface; ++ + err_unlock: + mv88e6xxx_reg_unlock(chip); + +diff --git a/drivers/net/dsa/mv88e6xxx/chip.h b/drivers/net/dsa/mv88e6xxx/chip.h +index e5430cf2ad71..6476524e8239 100644 +--- a/drivers/net/dsa/mv88e6xxx/chip.h ++++ b/drivers/net/dsa/mv88e6xxx/chip.h +@@ -232,6 +232,7 @@ struct mv88e6xxx_port { + u64 atu_full_violation; + u64 vtu_member_violation; + u64 vtu_miss_violation; ++ phy_interface_t interface; + u8 cmode; + bool mirror_ingress; + bool mirror_egress; +diff --git a/drivers/net/ethernet/atheros/ag71xx.c b/drivers/net/ethernet/atheros/ag71xx.c +index 02b7705393ca..37a1cf63d9f7 100644 +--- a/drivers/net/ethernet/atheros/ag71xx.c ++++ b/drivers/net/ethernet/atheros/ag71xx.c +@@ -556,7 +556,8 @@ static int ag71xx_mdio_probe(struct ag71xx *ag) + ag->mdio_reset = of_reset_control_get_exclusive(np, "mdio"); + if (IS_ERR(ag->mdio_reset)) { + netif_err(ag, probe, ndev, "Failed to get reset mdio.\n"); +- return PTR_ERR(ag->mdio_reset); ++ err = PTR_ERR(ag->mdio_reset); ++ goto mdio_err_put_clk; + } + + mii_bus->name = "ag71xx_mdio"; +diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c +index b6fb5a1709c0..1656dc277af4 100644 +--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c ++++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c +@@ -3418,7 +3418,7 @@ void bnxt_set_tpa_flags(struct bnxt *bp) + */ + void bnxt_set_ring_params(struct bnxt *bp) + { +- u32 ring_size, rx_size, rx_space; ++ u32 ring_size, rx_size, rx_space, max_rx_cmpl; + u32 agg_factor = 0, agg_ring_size = 0; + + /* 8 for CRC and VLAN */ +@@ -3474,7 +3474,15 @@ void bnxt_set_ring_params(struct bnxt *bp) + bp->tx_nr_pages = bnxt_calc_nr_ring_pages(ring_size, TX_DESC_CNT); + bp->tx_ring_mask = (bp->tx_nr_pages * TX_DESC_CNT) - 1; + +- ring_size = bp->rx_ring_size * (2 + agg_factor) + bp->tx_ring_size; ++ max_rx_cmpl = bp->rx_ring_size; ++ /* MAX TPA needs to be added because TPA_START completions are ++ * immediately recycled, so the TPA completions are not bound by ++ * the RX ring size. ++ */ ++ if (bp->flags & BNXT_FLAG_TPA) ++ max_rx_cmpl += bp->max_tpa; ++ /* RX and TPA completions are 32-byte, all others are 16-byte */ ++ ring_size = max_rx_cmpl * 2 + agg_ring_size + bp->tx_ring_size; + bp->cp_ring_size = ring_size; + + bp->cp_nr_pages = bnxt_calc_nr_ring_pages(ring_size, CP_DESC_CNT); +@@ -10362,15 +10370,15 @@ static void bnxt_sp_task(struct work_struct *work) + &bp->sp_event)) + bnxt_hwrm_phy_qcaps(bp); + +- if (test_and_clear_bit(BNXT_LINK_CFG_CHANGE_SP_EVENT, +- &bp->sp_event)) +- bnxt_init_ethtool_link_settings(bp); +- + rc = bnxt_update_link(bp, true); +- mutex_unlock(&bp->link_lock); + if (rc) + netdev_err(bp->dev, "SP task can't update link (rc: %x)\n", + rc); ++ ++ if (test_and_clear_bit(BNXT_LINK_CFG_CHANGE_SP_EVENT, ++ &bp->sp_event)) ++ bnxt_init_ethtool_link_settings(bp); ++ mutex_unlock(&bp->link_lock); + } + if (test_and_clear_bit(BNXT_UPDATE_PHY_SP_EVENT, &bp->sp_event)) { + int rc; +diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c +index 360f9a95c1d5..21cc2bd12760 100644 +--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c ++++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c +@@ -1687,8 +1687,11 @@ static int bnxt_set_pauseparam(struct net_device *dev, + if (epause->tx_pause) + link_info->req_flow_ctrl |= BNXT_LINK_PAUSE_TX; + +- if (netif_running(dev)) ++ if (netif_running(dev)) { ++ mutex_lock(&bp->link_lock); + rc = bnxt_hwrm_set_pause(bp); ++ mutex_unlock(&bp->link_lock); ++ } + return rc; + } + +diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.c b/drivers/net/ethernet/broadcom/genet/bcmgenet.c +index dde1c23c8e39..7b95bb77ad3b 100644 +--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.c ++++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.c +@@ -3522,7 +3522,7 @@ static int bcmgenet_probe(struct platform_device *pdev) + if (err) + err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); + if (err) +- goto err; ++ goto err_clk_disable; + + /* Mii wait queue */ + init_waitqueue_head(&priv->wq); +diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c +index 6bfa7575af94..5f82c1f32f09 100644 +--- a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c ++++ b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c +@@ -2938,7 +2938,7 @@ static int dpaa_eth_probe(struct platform_device *pdev) + DMA_BIT_MASK(40)); + if (err) { + netdev_err(net_dev, "dma_coerce_mask_and_coherent() failed\n"); +- return err; ++ goto free_netdev; + } + + /* If fsl_fm_max_frm is set to a higher value than the all-common 1500, +diff --git a/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c b/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c +index 569e06d2bab2..72fa9c4e058f 100644 +--- a/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c ++++ b/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c +@@ -3383,7 +3383,7 @@ static int dpaa2_eth_connect_mac(struct dpaa2_eth_priv *priv) + + dpni_dev = to_fsl_mc_device(priv->net_dev->dev.parent); + dpmac_dev = fsl_mc_get_endpoint(dpni_dev); +- if (IS_ERR(dpmac_dev) || dpmac_dev->dev.type != &fsl_mc_bus_dpmac_type) ++ if (IS_ERR_OR_NULL(dpmac_dev) || dpmac_dev->dev.type != &fsl_mc_bus_dpmac_type) + return 0; + + if (dpaa2_mac_is_type_fixed(dpmac_dev, priv->mc_io)) +diff --git a/drivers/net/ethernet/freescale/enetc/enetc_pf.c b/drivers/net/ethernet/freescale/enetc/enetc_pf.c +index 438648a06f2a..041e19895adf 100644 +--- a/drivers/net/ethernet/freescale/enetc/enetc_pf.c ++++ b/drivers/net/ethernet/freescale/enetc/enetc_pf.c +@@ -919,6 +919,7 @@ static int enetc_pf_probe(struct pci_dev *pdev, + return 0; + + err_reg_netdev: ++ enetc_mdio_remove(pf); + enetc_of_put_phy(priv); + enetc_free_msix(priv); + err_alloc_msix: +diff --git a/drivers/net/ethernet/freescale/fec.h b/drivers/net/ethernet/freescale/fec.h +index e74dd1f86bba..828eb8ce6631 100644 +--- a/drivers/net/ethernet/freescale/fec.h ++++ b/drivers/net/ethernet/freescale/fec.h +@@ -597,6 +597,7 @@ struct fec_enet_private { + void fec_ptp_init(struct platform_device *pdev, int irq_idx); + void fec_ptp_stop(struct platform_device *pdev); + void fec_ptp_start_cyclecounter(struct net_device *ndev); ++void fec_ptp_disable_hwts(struct net_device *ndev); + int fec_ptp_set(struct net_device *ndev, struct ifreq *ifr); + int fec_ptp_get(struct net_device *ndev, struct ifreq *ifr); + +diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c +index dc6f8763a5d4..bf73bc9bf35b 100644 +--- a/drivers/net/ethernet/freescale/fec_main.c ++++ b/drivers/net/ethernet/freescale/fec_main.c +@@ -1302,8 +1302,13 @@ fec_enet_tx_queue(struct net_device *ndev, u16 queue_id) + ndev->stats.tx_bytes += skb->len; + } + +- if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS) && +- fep->bufdesc_ex) { ++ /* NOTE: SKBTX_IN_PROGRESS being set does not imply it's we who ++ * are to time stamp the packet, so we still need to check time ++ * stamping enabled flag. ++ */ ++ if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS && ++ fep->hwts_tx_en) && ++ fep->bufdesc_ex) { + struct skb_shared_hwtstamps shhwtstamps; + struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp; + +@@ -2731,10 +2736,16 @@ static int fec_enet_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd) + return -ENODEV; + + if (fep->bufdesc_ex) { +- if (cmd == SIOCSHWTSTAMP) +- return fec_ptp_set(ndev, rq); +- if (cmd == SIOCGHWTSTAMP) +- return fec_ptp_get(ndev, rq); ++ bool use_fec_hwts = !phy_has_hwtstamp(phydev); ++ ++ if (cmd == SIOCSHWTSTAMP) { ++ if (use_fec_hwts) ++ return fec_ptp_set(ndev, rq); ++ fec_ptp_disable_hwts(ndev); ++ } else if (cmd == SIOCGHWTSTAMP) { ++ if (use_fec_hwts) ++ return fec_ptp_get(ndev, rq); ++ } + } + + return phy_mii_ioctl(phydev, rq, cmd); +diff --git a/drivers/net/ethernet/freescale/fec_ptp.c b/drivers/net/ethernet/freescale/fec_ptp.c +index 945643c02615..f8a592c96beb 100644 +--- a/drivers/net/ethernet/freescale/fec_ptp.c ++++ b/drivers/net/ethernet/freescale/fec_ptp.c +@@ -452,6 +452,18 @@ static int fec_ptp_enable(struct ptp_clock_info *ptp, + return -EOPNOTSUPP; + } + ++/** ++ * fec_ptp_disable_hwts - disable hardware time stamping ++ * @ndev: pointer to net_device ++ */ ++void fec_ptp_disable_hwts(struct net_device *ndev) ++{ ++ struct fec_enet_private *fep = netdev_priv(ndev); ++ ++ fep->hwts_tx_en = 0; ++ fep->hwts_rx_en = 0; ++} ++ + int fec_ptp_set(struct net_device *ndev, struct ifreq *ifr) + { + struct fec_enet_private *fep = netdev_priv(ndev); +diff --git a/drivers/net/ethernet/hisilicon/hns3/hnae3.h b/drivers/net/ethernet/hisilicon/hns3/hnae3.h +index 5587605d6deb..cc45662f77f0 100644 +--- a/drivers/net/ethernet/hisilicon/hns3/hnae3.h ++++ b/drivers/net/ethernet/hisilicon/hns3/hnae3.h +@@ -77,6 +77,7 @@ + ((ring)->p = ((ring)->p - 1 + (ring)->desc_num) % (ring)->desc_num) + + enum hns_desc_type { ++ DESC_TYPE_UNKNOWN, + DESC_TYPE_SKB, + DESC_TYPE_FRAGLIST_SKB, + DESC_TYPE_PAGE, +diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c +index 3003eecd5263..df1cb0441183 100644 +--- a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c ++++ b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c +@@ -1140,7 +1140,7 @@ static int hns3_fill_desc(struct hns3_enet_ring *ring, void *priv, + } + + frag_buf_num = hns3_tx_bd_count(size); +- sizeoflast = size & HNS3_TX_LAST_SIZE_M; ++ sizeoflast = size % HNS3_MAX_BD_SIZE; + sizeoflast = sizeoflast ? sizeoflast : HNS3_MAX_BD_SIZE; + + /* When frag size is bigger than hardware limit, split this frag */ +@@ -1351,6 +1351,10 @@ static void hns3_clear_desc(struct hns3_enet_ring *ring, int next_to_use_orig) + unsigned int i; + + for (i = 0; i < ring->desc_num; i++) { ++ struct hns3_desc *desc = &ring->desc[ring->next_to_use]; ++ ++ memset(desc, 0, sizeof(*desc)); ++ + /* check if this is where we started */ + if (ring->next_to_use == next_to_use_orig) + break; +@@ -1358,6 +1362,9 @@ static void hns3_clear_desc(struct hns3_enet_ring *ring, int next_to_use_orig) + /* rollback one */ + ring_ptr_move_bw(ring, next_to_use); + ++ if (!ring->desc_cb[ring->next_to_use].dma) ++ continue; ++ + /* unmap the descriptor dma address */ + if (ring->desc_cb[ring->next_to_use].type == DESC_TYPE_SKB || + ring->desc_cb[ring->next_to_use].type == +@@ -1374,6 +1381,7 @@ static void hns3_clear_desc(struct hns3_enet_ring *ring, int next_to_use_orig) + + ring->desc_cb[ring->next_to_use].length = 0; + ring->desc_cb[ring->next_to_use].dma = 0; ++ ring->desc_cb[ring->next_to_use].type = DESC_TYPE_UNKNOWN; + } + } + +diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.h b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.h +index abefd7a179f7..e6b29a35cdb2 100644 +--- a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.h ++++ b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.h +@@ -186,8 +186,6 @@ enum hns3_nic_state { + #define HNS3_TXD_MSS_S 0 + #define HNS3_TXD_MSS_M (0x3fff << HNS3_TXD_MSS_S) + +-#define HNS3_TX_LAST_SIZE_M 0xffff +- + #define HNS3_VECTOR_TX_IRQ BIT_ULL(0) + #define HNS3_VECTOR_RX_IRQ BIT_ULL(1) + +diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c +index 4de268a87958..b66b93f320b4 100644 +--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c ++++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c +@@ -2680,11 +2680,10 @@ void hclge_task_schedule(struct hclge_dev *hdev, unsigned long delay_time) + delay_time); + } + +-static int hclge_get_mac_link_status(struct hclge_dev *hdev) ++static int hclge_get_mac_link_status(struct hclge_dev *hdev, int *link_status) + { + struct hclge_link_status_cmd *req; + struct hclge_desc desc; +- int link_status; + int ret; + + hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_QUERY_LINK_STATUS, true); +@@ -2696,33 +2695,25 @@ static int hclge_get_mac_link_status(struct hclge_dev *hdev) + } + + req = (struct hclge_link_status_cmd *)desc.data; +- link_status = req->status & HCLGE_LINK_STATUS_UP_M; ++ *link_status = (req->status & HCLGE_LINK_STATUS_UP_M) > 0 ? ++ HCLGE_LINK_STATUS_UP : HCLGE_LINK_STATUS_DOWN; + +- return !!link_status; ++ return 0; + } + +-static int hclge_get_mac_phy_link(struct hclge_dev *hdev) ++static int hclge_get_mac_phy_link(struct hclge_dev *hdev, int *link_status) + { +- unsigned int mac_state; +- int link_stat; ++ struct phy_device *phydev = hdev->hw.mac.phydev; ++ ++ *link_status = HCLGE_LINK_STATUS_DOWN; + + if (test_bit(HCLGE_STATE_DOWN, &hdev->state)) + return 0; + +- mac_state = hclge_get_mac_link_status(hdev); +- +- if (hdev->hw.mac.phydev) { +- if (hdev->hw.mac.phydev->state == PHY_RUNNING) +- link_stat = mac_state & +- hdev->hw.mac.phydev->link; +- else +- link_stat = 0; +- +- } else { +- link_stat = mac_state; +- } ++ if (phydev && (phydev->state != PHY_RUNNING || !phydev->link)) ++ return 0; + +- return !!link_stat; ++ return hclge_get_mac_link_status(hdev, link_status); + } + + static void hclge_update_link_status(struct hclge_dev *hdev) +@@ -2732,6 +2723,7 @@ static void hclge_update_link_status(struct hclge_dev *hdev) + struct hnae3_handle *rhandle; + struct hnae3_handle *handle; + int state; ++ int ret; + int i; + + if (!client) +@@ -2740,7 +2732,12 @@ static void hclge_update_link_status(struct hclge_dev *hdev) + if (test_and_set_bit(HCLGE_STATE_LINK_UPDATING, &hdev->state)) + return; + +- state = hclge_get_mac_phy_link(hdev); ++ ret = hclge_get_mac_phy_link(hdev, &state); ++ if (ret) { ++ clear_bit(HCLGE_STATE_LINK_UPDATING, &hdev->state); ++ return; ++ } ++ + if (state != hdev->hw.mac.link) { + for (i = 0; i < hdev->num_vmdq_vport + 1; i++) { + handle = &hdev->vport[i].nic; +@@ -6435,14 +6432,15 @@ static int hclge_mac_link_status_wait(struct hclge_dev *hdev, int link_ret) + { + #define HCLGE_MAC_LINK_STATUS_NUM 100 + ++ int link_status; + int i = 0; + int ret; + + do { +- ret = hclge_get_mac_link_status(hdev); +- if (ret < 0) ++ ret = hclge_get_mac_link_status(hdev, &link_status); ++ if (ret) + return ret; +- else if (ret == link_ret) ++ if (link_status == link_ret) + return 0; + + msleep(HCLGE_LINK_STATUS_MS); +@@ -6453,9 +6451,6 @@ static int hclge_mac_link_status_wait(struct hclge_dev *hdev, int link_ret) + static int hclge_mac_phy_link_status_wait(struct hclge_dev *hdev, bool en, + bool is_phy) + { +-#define HCLGE_LINK_STATUS_DOWN 0 +-#define HCLGE_LINK_STATUS_UP 1 +- + int link_ret; + + link_ret = en ? HCLGE_LINK_STATUS_UP : HCLGE_LINK_STATUS_DOWN; +diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h +index 71df23d5f1b4..8784168f8f6f 100644 +--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h ++++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h +@@ -316,6 +316,9 @@ enum hclge_link_fail_code { + HCLGE_LF_XSFP_ABSENT, + }; + ++#define HCLGE_LINK_STATUS_DOWN 0 ++#define HCLGE_LINK_STATUS_UP 1 ++ + #define HCLGE_PG_NUM 4 + #define HCLGE_SCH_MODE_SP 0 + #define HCLGE_SCH_MODE_DWRR 1 +diff --git a/drivers/net/ethernet/marvell/sky2.c b/drivers/net/ethernet/marvell/sky2.c +index 241f00716979..fe54764caea9 100644 +--- a/drivers/net/ethernet/marvell/sky2.c ++++ b/drivers/net/ethernet/marvell/sky2.c +@@ -203,7 +203,7 @@ io_error: + + static inline u16 gm_phy_read(struct sky2_hw *hw, unsigned port, u16 reg) + { +- u16 v; ++ u16 v = 0; + __gm_phy_read(hw, port, reg, &v); + return v; + } +diff --git a/drivers/net/ethernet/mellanox/mlxsw/core.c b/drivers/net/ethernet/mellanox/mlxsw/core.c +index e9ccd333f61d..d6d6fe64887b 100644 +--- a/drivers/net/ethernet/mellanox/mlxsw/core.c ++++ b/drivers/net/ethernet/mellanox/mlxsw/core.c +@@ -710,7 +710,7 @@ static int mlxsw_emad_init(struct mlxsw_core *mlxsw_core) + err = mlxsw_core_trap_register(mlxsw_core, &mlxsw_emad_rx_listener, + mlxsw_core); + if (err) +- return err; ++ goto err_trap_register; + + err = mlxsw_core->driver->basic_trap_groups_set(mlxsw_core); + if (err) +@@ -722,6 +722,7 @@ static int mlxsw_emad_init(struct mlxsw_core *mlxsw_core) + err_emad_trap_set: + mlxsw_core_trap_unregister(mlxsw_core, &mlxsw_emad_rx_listener, + mlxsw_core); ++err_trap_register: + destroy_workqueue(mlxsw_core->emad_wq); + return err; + } +diff --git a/drivers/net/ethernet/mellanox/mlxsw/core_env.c b/drivers/net/ethernet/mellanox/mlxsw/core_env.c +index 08215fed193d..a7d86df7123f 100644 +--- a/drivers/net/ethernet/mellanox/mlxsw/core_env.c ++++ b/drivers/net/ethernet/mellanox/mlxsw/core_env.c +@@ -45,7 +45,7 @@ static int mlxsw_env_validate_cable_ident(struct mlxsw_core *core, int id, + static int + mlxsw_env_query_module_eeprom(struct mlxsw_core *mlxsw_core, int module, + u16 offset, u16 size, void *data, +- unsigned int *p_read_size) ++ bool qsfp, unsigned int *p_read_size) + { + char eeprom_tmp[MLXSW_REG_MCIA_EEPROM_SIZE]; + char mcia_pl[MLXSW_REG_MCIA_LEN]; +@@ -54,6 +54,10 @@ mlxsw_env_query_module_eeprom(struct mlxsw_core *mlxsw_core, int module, + int status; + int err; + ++ /* MCIA register accepts buffer size <= 48. Page of size 128 should be ++ * read by chunks of size 48, 48, 32. Align the size of the last chunk ++ * to avoid reading after the end of the page. ++ */ + size = min_t(u16, size, MLXSW_REG_MCIA_EEPROM_SIZE); + + if (offset < MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH && +@@ -63,18 +67,25 @@ mlxsw_env_query_module_eeprom(struct mlxsw_core *mlxsw_core, int module, + + i2c_addr = MLXSW_REG_MCIA_I2C_ADDR_LOW; + if (offset >= MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH) { +- page = MLXSW_REG_MCIA_PAGE_GET(offset); +- offset -= MLXSW_REG_MCIA_EEPROM_UP_PAGE_LENGTH * page; +- /* When reading upper pages 1, 2 and 3 the offset starts at +- * 128. Please refer to "QSFP+ Memory Map" figure in SFF-8436 +- * specification for graphical depiction. +- * MCIA register accepts buffer size <= 48. Page of size 128 +- * should be read by chunks of size 48, 48, 32. Align the size +- * of the last chunk to avoid reading after the end of the +- * page. +- */ +- if (offset + size > MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH) +- size = MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH - offset; ++ if (qsfp) { ++ /* When reading upper pages 1, 2 and 3 the offset ++ * starts at 128. Please refer to "QSFP+ Memory Map" ++ * figure in SFF-8436 specification for graphical ++ * depiction. ++ */ ++ page = MLXSW_REG_MCIA_PAGE_GET(offset); ++ offset -= MLXSW_REG_MCIA_EEPROM_UP_PAGE_LENGTH * page; ++ if (offset + size > MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH) ++ size = MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH - offset; ++ } else { ++ /* When reading upper pages 1, 2 and 3 the offset ++ * starts at 0 and I2C high address is used. Please refer ++ * refer to "Memory Organization" figure in SFF-8472 ++ * specification for graphical depiction. ++ */ ++ i2c_addr = MLXSW_REG_MCIA_I2C_ADDR_HIGH; ++ offset -= MLXSW_REG_MCIA_EEPROM_PAGE_LENGTH; ++ } + } + + mlxsw_reg_mcia_pack(mcia_pl, module, 0, page, offset, size, i2c_addr); +@@ -166,7 +177,7 @@ int mlxsw_env_get_module_info(struct mlxsw_core *mlxsw_core, int module, + int err; + + err = mlxsw_env_query_module_eeprom(mlxsw_core, module, 0, offset, +- module_info, &read_size); ++ module_info, false, &read_size); + if (err) + return err; + +@@ -197,7 +208,7 @@ int mlxsw_env_get_module_info(struct mlxsw_core *mlxsw_core, int module, + /* Verify if transceiver provides diagnostic monitoring page */ + err = mlxsw_env_query_module_eeprom(mlxsw_core, module, + SFP_DIAGMON, 1, &diag_mon, +- &read_size); ++ false, &read_size); + if (err) + return err; + +@@ -225,17 +236,22 @@ int mlxsw_env_get_module_eeprom(struct net_device *netdev, + int offset = ee->offset; + unsigned int read_size; + int i = 0; ++ bool qsfp; + int err; + + if (!ee->len) + return -EINVAL; + + memset(data, 0, ee->len); ++ /* Validate module identifier value. */ ++ err = mlxsw_env_validate_cable_ident(mlxsw_core, module, &qsfp); ++ if (err) ++ return err; + + while (i < ee->len) { + err = mlxsw_env_query_module_eeprom(mlxsw_core, module, offset, + ee->len - i, data + i, +- &read_size); ++ qsfp, &read_size); + if (err) { + netdev_err(netdev, "Eeprom query failed\n"); + return err; +diff --git a/drivers/net/ethernet/pensando/ionic/ionic_ethtool.c b/drivers/net/ethernet/pensando/ionic/ionic_ethtool.c +index 22430fa911e2..63d78519cbc6 100644 +--- a/drivers/net/ethernet/pensando/ionic/ionic_ethtool.c ++++ b/drivers/net/ethernet/pensando/ionic/ionic_ethtool.c +@@ -102,15 +102,18 @@ static void ionic_get_regs(struct net_device *netdev, struct ethtool_regs *regs, + void *p) + { + struct ionic_lif *lif = netdev_priv(netdev); ++ unsigned int offset; + unsigned int size; + + regs->version = IONIC_DEV_CMD_REG_VERSION; + ++ offset = 0; + size = IONIC_DEV_INFO_REG_COUNT * sizeof(u32); +- memcpy_fromio(p, lif->ionic->idev.dev_info_regs->words, size); ++ memcpy_fromio(p + offset, lif->ionic->idev.dev_info_regs->words, size); + ++ offset += size; + size = IONIC_DEV_CMD_REG_COUNT * sizeof(u32); +- memcpy_fromio(p, lif->ionic->idev.dev_cmd_regs->words, size); ++ memcpy_fromio(p + offset, lif->ionic->idev.dev_cmd_regs->words, size); + } + + static int ionic_get_link_ksettings(struct net_device *netdev, +diff --git a/drivers/net/ethernet/pensando/ionic/ionic_lif.c b/drivers/net/ethernet/pensando/ionic/ionic_lif.c +index 7fea60fc3e08..2c3e9ef22129 100644 +--- a/drivers/net/ethernet/pensando/ionic/ionic_lif.c ++++ b/drivers/net/ethernet/pensando/ionic/ionic_lif.c +@@ -85,8 +85,7 @@ static void ionic_link_status_check(struct ionic_lif *lif) + u16 link_status; + bool link_up; + +- if (!test_bit(IONIC_LIF_F_LINK_CHECK_REQUESTED, lif->state) || +- test_bit(IONIC_LIF_F_QUEUE_RESET, lif->state)) ++ if (!test_bit(IONIC_LIF_F_LINK_CHECK_REQUESTED, lif->state)) + return; + + if (lif->ionic->is_mgmt_nic) +@@ -106,16 +105,22 @@ static void ionic_link_status_check(struct ionic_lif *lif) + netif_carrier_on(netdev); + } + +- if (lif->netdev->flags & IFF_UP && netif_running(lif->netdev)) ++ if (lif->netdev->flags & IFF_UP && netif_running(lif->netdev)) { ++ mutex_lock(&lif->queue_lock); + ionic_start_queues(lif); ++ mutex_unlock(&lif->queue_lock); ++ } + } else { + if (netif_carrier_ok(netdev)) { + netdev_info(netdev, "Link down\n"); + netif_carrier_off(netdev); + } + +- if (lif->netdev->flags & IFF_UP && netif_running(lif->netdev)) ++ if (lif->netdev->flags & IFF_UP && netif_running(lif->netdev)) { ++ mutex_lock(&lif->queue_lock); + ionic_stop_queues(lif); ++ mutex_unlock(&lif->queue_lock); ++ } + } + + clear_bit(IONIC_LIF_F_LINK_CHECK_REQUESTED, lif->state); +@@ -849,8 +854,7 @@ static int ionic_lif_addr_add(struct ionic_lif *lif, const u8 *addr) + if (f) + return 0; + +- netdev_dbg(lif->netdev, "rx_filter add ADDR %pM (id %d)\n", addr, +- ctx.comp.rx_filter_add.filter_id); ++ netdev_dbg(lif->netdev, "rx_filter add ADDR %pM\n", addr); + + memcpy(ctx.cmd.rx_filter_add.mac.addr, addr, ETH_ALEN); + err = ionic_adminq_post_wait(lif, &ctx); +@@ -879,6 +883,9 @@ static int ionic_lif_addr_del(struct ionic_lif *lif, const u8 *addr) + return -ENOENT; + } + ++ netdev_dbg(lif->netdev, "rx_filter del ADDR %pM (id %d)\n", ++ addr, f->filter_id); ++ + ctx.cmd.rx_filter_del.filter_id = cpu_to_le32(f->filter_id); + ionic_rx_filter_free(lif, f); + spin_unlock_bh(&lif->rx_filters.lock); +@@ -887,9 +894,6 @@ static int ionic_lif_addr_del(struct ionic_lif *lif, const u8 *addr) + if (err && err != -EEXIST) + return err; + +- netdev_dbg(lif->netdev, "rx_filter del ADDR %pM (id %d)\n", addr, +- ctx.cmd.rx_filter_del.filter_id); +- + return 0; + } + +@@ -1341,13 +1345,11 @@ static int ionic_vlan_rx_add_vid(struct net_device *netdev, __be16 proto, + }; + int err; + ++ netdev_dbg(netdev, "rx_filter add VLAN %d\n", vid); + err = ionic_adminq_post_wait(lif, &ctx); + if (err) + return err; + +- netdev_dbg(netdev, "rx_filter add VLAN %d (id %d)\n", vid, +- ctx.comp.rx_filter_add.filter_id); +- + return ionic_rx_filter_save(lif, 0, IONIC_RXQ_INDEX_ANY, 0, &ctx); + } + +@@ -1372,8 +1374,8 @@ static int ionic_vlan_rx_kill_vid(struct net_device *netdev, __be16 proto, + return -ENOENT; + } + +- netdev_dbg(netdev, "rx_filter del VLAN %d (id %d)\n", vid, +- le32_to_cpu(ctx.cmd.rx_filter_del.filter_id)); ++ netdev_dbg(netdev, "rx_filter del VLAN %d (id %d)\n", ++ vid, f->filter_id); + + ctx.cmd.rx_filter_del.filter_id = cpu_to_le32(f->filter_id); + ionic_rx_filter_free(lif, f); +@@ -1951,16 +1953,13 @@ int ionic_reset_queues(struct ionic_lif *lif, ionic_reset_cb cb, void *arg) + bool running; + int err = 0; + +- err = ionic_wait_for_bit(lif, IONIC_LIF_F_QUEUE_RESET); +- if (err) +- return err; +- ++ mutex_lock(&lif->queue_lock); + running = netif_running(lif->netdev); + if (running) { + netif_device_detach(lif->netdev); + err = ionic_stop(lif->netdev); + if (err) +- goto reset_out; ++ return err; + } + + if (cb) +@@ -1970,9 +1969,7 @@ int ionic_reset_queues(struct ionic_lif *lif, ionic_reset_cb cb, void *arg) + err = ionic_open(lif->netdev); + netif_device_attach(lif->netdev); + } +- +-reset_out: +- clear_bit(IONIC_LIF_F_QUEUE_RESET, lif->state); ++ mutex_unlock(&lif->queue_lock); + + return err; + } +@@ -2111,7 +2108,9 @@ static void ionic_lif_handle_fw_down(struct ionic_lif *lif) + + if (test_bit(IONIC_LIF_F_UP, lif->state)) { + dev_info(ionic->dev, "Surprise FW stop, stopping queues\n"); ++ mutex_lock(&lif->queue_lock); + ionic_stop_queues(lif); ++ mutex_unlock(&lif->queue_lock); + } + + if (netif_running(lif->netdev)) { +@@ -2230,15 +2229,15 @@ static void ionic_lif_deinit(struct ionic_lif *lif) + cancel_work_sync(&lif->deferred.work); + cancel_work_sync(&lif->tx_timeout_work); + ionic_rx_filters_deinit(lif); ++ if (lif->netdev->features & NETIF_F_RXHASH) ++ ionic_lif_rss_deinit(lif); + } + +- if (lif->netdev->features & NETIF_F_RXHASH) +- ionic_lif_rss_deinit(lif); +- + napi_disable(&lif->adminqcq->napi); + ionic_lif_qcq_deinit(lif, lif->notifyqcq); + ionic_lif_qcq_deinit(lif, lif->adminqcq); + ++ mutex_destroy(&lif->queue_lock); + ionic_lif_reset(lif); + } + +@@ -2414,6 +2413,7 @@ static int ionic_lif_init(struct ionic_lif *lif) + return err; + + lif->hw_index = le16_to_cpu(comp.hw_index); ++ mutex_init(&lif->queue_lock); + + /* now that we have the hw_index we can figure out our doorbell page */ + lif->dbid_count = le32_to_cpu(lif->ionic->ident.dev.ndbpgs_per_lif); +diff --git a/drivers/net/ethernet/pensando/ionic/ionic_lif.h b/drivers/net/ethernet/pensando/ionic/ionic_lif.h +index 2c65cf6300db..90992614f136 100644 +--- a/drivers/net/ethernet/pensando/ionic/ionic_lif.h ++++ b/drivers/net/ethernet/pensando/ionic/ionic_lif.h +@@ -126,7 +126,6 @@ enum ionic_lif_state_flags { + IONIC_LIF_F_SW_DEBUG_STATS, + IONIC_LIF_F_UP, + IONIC_LIF_F_LINK_CHECK_REQUESTED, +- IONIC_LIF_F_QUEUE_RESET, + IONIC_LIF_F_FW_RESET, + + /* leave this as last */ +@@ -145,6 +144,7 @@ struct ionic_lif { + unsigned int hw_index; + unsigned int kern_pid; + u64 __iomem *kern_dbpage; ++ struct mutex queue_lock; /* lock for queue structures */ + spinlock_t adminq_lock; /* lock for AdminQ operations */ + struct ionic_qcq *adminqcq; + struct ionic_qcq *notifyqcq; +@@ -191,12 +191,6 @@ struct ionic_lif { + #define lif_to_txq(lif, i) (&lif_to_txqcq((lif), i)->q) + #define lif_to_rxq(lif, i) (&lif_to_txqcq((lif), i)->q) + +-/* return 0 if successfully set the bit, else non-zero */ +-static inline int ionic_wait_for_bit(struct ionic_lif *lif, int bitname) +-{ +- return wait_on_bit_lock(lif->state, bitname, TASK_INTERRUPTIBLE); +-} +- + static inline u32 ionic_coal_usec_to_hw(struct ionic *ionic, u32 usecs) + { + u32 mult = le32_to_cpu(ionic->ident.dev.intr_coal_mult); +diff --git a/drivers/net/ethernet/pensando/ionic/ionic_rx_filter.c b/drivers/net/ethernet/pensando/ionic/ionic_rx_filter.c +index 80eeb7696e01..cd0076fc3044 100644 +--- a/drivers/net/ethernet/pensando/ionic/ionic_rx_filter.c ++++ b/drivers/net/ethernet/pensando/ionic/ionic_rx_filter.c +@@ -21,13 +21,16 @@ void ionic_rx_filter_free(struct ionic_lif *lif, struct ionic_rx_filter *f) + void ionic_rx_filter_replay(struct ionic_lif *lif) + { + struct ionic_rx_filter_add_cmd *ac; ++ struct hlist_head new_id_list; + struct ionic_admin_ctx ctx; + struct ionic_rx_filter *f; + struct hlist_head *head; + struct hlist_node *tmp; ++ unsigned int key; + unsigned int i; + int err; + ++ INIT_HLIST_HEAD(&new_id_list); + ac = &ctx.cmd.rx_filter_add; + + for (i = 0; i < IONIC_RX_FILTER_HLISTS; i++) { +@@ -58,9 +61,30 @@ void ionic_rx_filter_replay(struct ionic_lif *lif) + ac->mac.addr); + break; + } ++ spin_lock_bh(&lif->rx_filters.lock); ++ ionic_rx_filter_free(lif, f); ++ spin_unlock_bh(&lif->rx_filters.lock); ++ ++ continue; + } ++ ++ /* remove from old id list, save new id in tmp list */ ++ spin_lock_bh(&lif->rx_filters.lock); ++ hlist_del(&f->by_id); ++ spin_unlock_bh(&lif->rx_filters.lock); ++ f->filter_id = le32_to_cpu(ctx.comp.rx_filter_add.filter_id); ++ hlist_add_head(&f->by_id, &new_id_list); + } + } ++ ++ /* rebuild the by_id hash lists with the new filter ids */ ++ spin_lock_bh(&lif->rx_filters.lock); ++ hlist_for_each_entry_safe(f, tmp, &new_id_list, by_id) { ++ key = f->filter_id & IONIC_RX_FILTER_HLISTS_MASK; ++ head = &lif->rx_filters.by_id[key]; ++ hlist_add_head(&f->by_id, head); ++ } ++ spin_unlock_bh(&lif->rx_filters.lock); + } + + int ionic_rx_filters_init(struct ionic_lif *lif) +@@ -69,10 +93,12 @@ int ionic_rx_filters_init(struct ionic_lif *lif) + + spin_lock_init(&lif->rx_filters.lock); + ++ spin_lock_bh(&lif->rx_filters.lock); + for (i = 0; i < IONIC_RX_FILTER_HLISTS; i++) { + INIT_HLIST_HEAD(&lif->rx_filters.by_hash[i]); + INIT_HLIST_HEAD(&lif->rx_filters.by_id[i]); + } ++ spin_unlock_bh(&lif->rx_filters.lock); + + return 0; + } +@@ -84,11 +110,13 @@ void ionic_rx_filters_deinit(struct ionic_lif *lif) + struct hlist_node *tmp; + unsigned int i; + ++ spin_lock_bh(&lif->rx_filters.lock); + for (i = 0; i < IONIC_RX_FILTER_HLISTS; i++) { + head = &lif->rx_filters.by_id[i]; + hlist_for_each_entry_safe(f, tmp, head, by_id) + ionic_rx_filter_free(lif, f); + } ++ spin_unlock_bh(&lif->rx_filters.lock); + } + + int ionic_rx_filter_save(struct ionic_lif *lif, u32 flow_id, u16 rxq_index, +@@ -124,6 +152,7 @@ int ionic_rx_filter_save(struct ionic_lif *lif, u32 flow_id, u16 rxq_index, + f->filter_id = le32_to_cpu(ctx->comp.rx_filter_add.filter_id); + f->rxq_index = rxq_index; + memcpy(&f->cmd, ac, sizeof(f->cmd)); ++ netdev_dbg(lif->netdev, "rx_filter add filter_id %d\n", f->filter_id); + + INIT_HLIST_NODE(&f->by_hash); + INIT_HLIST_NODE(&f->by_id); +diff --git a/drivers/net/ethernet/pensando/ionic/ionic_txrx.c b/drivers/net/ethernet/pensando/ionic/ionic_txrx.c +index d233b6e77b1e..ce8e246cda07 100644 +--- a/drivers/net/ethernet/pensando/ionic/ionic_txrx.c ++++ b/drivers/net/ethernet/pensando/ionic/ionic_txrx.c +@@ -157,12 +157,6 @@ static void ionic_rx_clean(struct ionic_queue *q, struct ionic_desc_info *desc_i + return; + } + +- /* no packet processing while resetting */ +- if (unlikely(test_bit(IONIC_LIF_F_QUEUE_RESET, q->lif->state))) { +- stats->dropped++; +- return; +- } +- + stats->pkts++; + stats->bytes += le16_to_cpu(comp->len); + +diff --git a/drivers/net/ethernet/qlogic/qed/qed_cxt.c b/drivers/net/ethernet/qlogic/qed/qed_cxt.c +index aeed8939f410..3bbcff5f2621 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_cxt.c ++++ b/drivers/net/ethernet/qlogic/qed/qed_cxt.c +@@ -1987,8 +1987,8 @@ static void qed_rdma_set_pf_params(struct qed_hwfn *p_hwfn, + num_srqs = min_t(u32, QED_RDMA_MAX_SRQS, p_params->num_srqs); + + if (p_hwfn->mcp_info->func_info.protocol == QED_PCI_ETH_RDMA) { +- DP_NOTICE(p_hwfn, +- "Current day drivers don't support RoCE & iWARP simultaneously on the same PF. Default to RoCE-only\n"); ++ DP_VERBOSE(p_hwfn, QED_MSG_SP, ++ "Current day drivers don't support RoCE & iWARP simultaneously on the same PF. Default to RoCE-only\n"); + p_hwfn->hw_info.personality = QED_PCI_ETH_ROCE; + } + +diff --git a/drivers/net/ethernet/qlogic/qed/qed_dev.c b/drivers/net/ethernet/qlogic/qed/qed_dev.c +index 58913fe4f345..0629dd4e18d9 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_dev.c ++++ b/drivers/net/ethernet/qlogic/qed/qed_dev.c +@@ -3096,7 +3096,7 @@ int qed_hw_init(struct qed_dev *cdev, struct qed_hw_init_params *p_params) + } + + /* Log and clear previous pglue_b errors if such exist */ +- qed_pglueb_rbc_attn_handler(p_hwfn, p_hwfn->p_main_ptt); ++ qed_pglueb_rbc_attn_handler(p_hwfn, p_hwfn->p_main_ptt, true); + + /* Enable the PF's internal FID_enable in the PXP */ + rc = qed_pglueb_set_pfid_enable(p_hwfn, p_hwfn->p_main_ptt, +diff --git a/drivers/net/ethernet/qlogic/qed/qed_int.c b/drivers/net/ethernet/qlogic/qed/qed_int.c +index 9f5113639eaf..8d106063e927 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_int.c ++++ b/drivers/net/ethernet/qlogic/qed/qed_int.c +@@ -256,9 +256,10 @@ out: + #define PGLUE_ATTENTION_ZLR_VALID (1 << 25) + #define PGLUE_ATTENTION_ILT_VALID (1 << 23) + +-int qed_pglueb_rbc_attn_handler(struct qed_hwfn *p_hwfn, +- struct qed_ptt *p_ptt) ++int qed_pglueb_rbc_attn_handler(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, ++ bool hw_init) + { ++ char msg[256]; + u32 tmp; + + tmp = qed_rd(p_hwfn, p_ptt, PGLUE_B_REG_TX_ERR_WR_DETAILS2); +@@ -272,22 +273,23 @@ int qed_pglueb_rbc_attn_handler(struct qed_hwfn *p_hwfn, + details = qed_rd(p_hwfn, p_ptt, + PGLUE_B_REG_TX_ERR_WR_DETAILS); + +- DP_NOTICE(p_hwfn, +- "Illegal write by chip to [%08x:%08x] blocked.\n" +- "Details: %08x [PFID %02x, VFID %02x, VF_VALID %02x]\n" +- "Details2 %08x [Was_error %02x BME deassert %02x FID_enable deassert %02x]\n", +- addr_hi, addr_lo, details, +- (u8)GET_FIELD(details, PGLUE_ATTENTION_DETAILS_PFID), +- (u8)GET_FIELD(details, PGLUE_ATTENTION_DETAILS_VFID), +- GET_FIELD(details, +- PGLUE_ATTENTION_DETAILS_VF_VALID) ? 1 : 0, +- tmp, +- GET_FIELD(tmp, +- PGLUE_ATTENTION_DETAILS2_WAS_ERR) ? 1 : 0, +- GET_FIELD(tmp, +- PGLUE_ATTENTION_DETAILS2_BME) ? 1 : 0, +- GET_FIELD(tmp, +- PGLUE_ATTENTION_DETAILS2_FID_EN) ? 1 : 0); ++ snprintf(msg, sizeof(msg), ++ "Illegal write by chip to [%08x:%08x] blocked.\n" ++ "Details: %08x [PFID %02x, VFID %02x, VF_VALID %02x]\n" ++ "Details2 %08x [Was_error %02x BME deassert %02x FID_enable deassert %02x]", ++ addr_hi, addr_lo, details, ++ (u8)GET_FIELD(details, PGLUE_ATTENTION_DETAILS_PFID), ++ (u8)GET_FIELD(details, PGLUE_ATTENTION_DETAILS_VFID), ++ !!GET_FIELD(details, PGLUE_ATTENTION_DETAILS_VF_VALID), ++ tmp, ++ !!GET_FIELD(tmp, PGLUE_ATTENTION_DETAILS2_WAS_ERR), ++ !!GET_FIELD(tmp, PGLUE_ATTENTION_DETAILS2_BME), ++ !!GET_FIELD(tmp, PGLUE_ATTENTION_DETAILS2_FID_EN)); ++ ++ if (hw_init) ++ DP_VERBOSE(p_hwfn, NETIF_MSG_INTR, "%s\n", msg); ++ else ++ DP_NOTICE(p_hwfn, "%s\n", msg); + } + + tmp = qed_rd(p_hwfn, p_ptt, PGLUE_B_REG_TX_ERR_RD_DETAILS2); +@@ -320,8 +322,14 @@ int qed_pglueb_rbc_attn_handler(struct qed_hwfn *p_hwfn, + } + + tmp = qed_rd(p_hwfn, p_ptt, PGLUE_B_REG_TX_ERR_WR_DETAILS_ICPL); +- if (tmp & PGLUE_ATTENTION_ICPL_VALID) +- DP_NOTICE(p_hwfn, "ICPL error - %08x\n", tmp); ++ if (tmp & PGLUE_ATTENTION_ICPL_VALID) { ++ snprintf(msg, sizeof(msg), "ICPL error - %08x", tmp); ++ ++ if (hw_init) ++ DP_VERBOSE(p_hwfn, NETIF_MSG_INTR, "%s\n", msg); ++ else ++ DP_NOTICE(p_hwfn, "%s\n", msg); ++ } + + tmp = qed_rd(p_hwfn, p_ptt, PGLUE_B_REG_MASTER_ZLR_ERR_DETAILS); + if (tmp & PGLUE_ATTENTION_ZLR_VALID) { +@@ -360,7 +368,7 @@ int qed_pglueb_rbc_attn_handler(struct qed_hwfn *p_hwfn, + + static int qed_pglueb_rbc_attn_cb(struct qed_hwfn *p_hwfn) + { +- return qed_pglueb_rbc_attn_handler(p_hwfn, p_hwfn->p_dpc_ptt); ++ return qed_pglueb_rbc_attn_handler(p_hwfn, p_hwfn->p_dpc_ptt, false); + } + + #define QED_DORQ_ATTENTION_REASON_MASK (0xfffff) +diff --git a/drivers/net/ethernet/qlogic/qed/qed_int.h b/drivers/net/ethernet/qlogic/qed/qed_int.h +index 9ad568d93ae6..defb0d1bc45a 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_int.h ++++ b/drivers/net/ethernet/qlogic/qed/qed_int.h +@@ -431,7 +431,7 @@ int qed_int_set_timer_res(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, + + #define QED_MAPPING_MEMORY_SIZE(dev) (NUM_OF_SBS(dev)) + +-int qed_pglueb_rbc_attn_handler(struct qed_hwfn *p_hwfn, +- struct qed_ptt *p_ptt); ++int qed_pglueb_rbc_attn_handler(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, ++ bool hw_init); + + #endif +diff --git a/drivers/net/ethernet/smsc/smc91x.c b/drivers/net/ethernet/smsc/smc91x.c +index 90410f9d3b1a..1c4fea9c3ec4 100644 +--- a/drivers/net/ethernet/smsc/smc91x.c ++++ b/drivers/net/ethernet/smsc/smc91x.c +@@ -2274,7 +2274,7 @@ static int smc_drv_probe(struct platform_device *pdev) + ret = try_toggle_control_gpio(&pdev->dev, &lp->power_gpio, + "power", 0, 0, 100); + if (ret) +- return ret; ++ goto out_free_netdev; + + /* + * Optional reset GPIO configured? Minimum 100 ns reset needed +@@ -2283,7 +2283,7 @@ static int smc_drv_probe(struct platform_device *pdev) + ret = try_toggle_control_gpio(&pdev->dev, &lp->reset_gpio, + "reset", 0, 0, 100); + if (ret) +- return ret; ++ goto out_free_netdev; + + /* + * Need to wait for optional EEPROM to load, max 750 us according +diff --git a/drivers/net/ethernet/socionext/sni_ave.c b/drivers/net/ethernet/socionext/sni_ave.c +index 67ddf782d98a..897c895629d0 100644 +--- a/drivers/net/ethernet/socionext/sni_ave.c ++++ b/drivers/net/ethernet/socionext/sni_ave.c +@@ -1191,7 +1191,7 @@ static int ave_init(struct net_device *ndev) + ret = regmap_update_bits(priv->regmap, SG_ETPINMODE, + priv->pinmode_mask, priv->pinmode_val); + if (ret) +- return ret; ++ goto out_reset_assert; + + ave_global_reset(ndev); + +diff --git a/drivers/net/geneve.c b/drivers/net/geneve.c +index 4661ef865807..dec52b763d50 100644 +--- a/drivers/net/geneve.c ++++ b/drivers/net/geneve.c +@@ -1615,11 +1615,11 @@ static int geneve_changelink(struct net_device *dev, struct nlattr *tb[], + struct netlink_ext_ack *extack) + { + struct geneve_dev *geneve = netdev_priv(dev); ++ enum ifla_geneve_df df = geneve->df; + struct geneve_sock *gs4, *gs6; + struct ip_tunnel_info info; + bool metadata; + bool use_udp6_rx_checksums; +- enum ifla_geneve_df df; + bool ttl_inherit; + int err; + +diff --git a/drivers/net/hippi/rrunner.c b/drivers/net/hippi/rrunner.c +index 2a6ec5394966..a4b3fce69ecd 100644 +--- a/drivers/net/hippi/rrunner.c ++++ b/drivers/net/hippi/rrunner.c +@@ -1242,7 +1242,7 @@ static int rr_open(struct net_device *dev) + rrpriv->info = NULL; + } + if (rrpriv->rx_ctrl) { +- pci_free_consistent(pdev, sizeof(struct ring_ctrl), ++ pci_free_consistent(pdev, 256 * sizeof(struct ring_ctrl), + rrpriv->rx_ctrl, rrpriv->rx_ctrl_dma); + rrpriv->rx_ctrl = NULL; + } +diff --git a/drivers/net/ieee802154/adf7242.c b/drivers/net/ieee802154/adf7242.c +index 5a37514e4234..8dbccec6ac86 100644 +--- a/drivers/net/ieee802154/adf7242.c ++++ b/drivers/net/ieee802154/adf7242.c +@@ -1262,7 +1262,7 @@ static int adf7242_probe(struct spi_device *spi) + WQ_MEM_RECLAIM); + if (unlikely(!lp->wqueue)) { + ret = -ENOMEM; +- goto err_hw_init; ++ goto err_alloc_wq; + } + + ret = adf7242_hw_init(lp); +@@ -1294,6 +1294,8 @@ static int adf7242_probe(struct spi_device *spi) + return ret; + + err_hw_init: ++ destroy_workqueue(lp->wqueue); ++err_alloc_wq: + mutex_destroy(&lp->bmux); + ieee802154_free_hw(lp->hw); + +diff --git a/drivers/net/netdevsim/netdev.c b/drivers/net/netdevsim/netdev.c +index 2908e0a0d6e1..23950e7a0f81 100644 +--- a/drivers/net/netdevsim/netdev.c ++++ b/drivers/net/netdevsim/netdev.c +@@ -302,7 +302,7 @@ nsim_create(struct nsim_dev *nsim_dev, struct nsim_dev_port *nsim_dev_port) + rtnl_lock(); + err = nsim_bpf_init(ns); + if (err) +- goto err_free_netdev; ++ goto err_rtnl_unlock; + + nsim_ipsec_init(ns); + +@@ -316,8 +316,8 @@ nsim_create(struct nsim_dev *nsim_dev, struct nsim_dev_port *nsim_dev_port) + err_ipsec_teardown: + nsim_ipsec_teardown(ns); + nsim_bpf_uninit(ns); ++err_rtnl_unlock: + rtnl_unlock(); +-err_free_netdev: + free_netdev(dev); + return ERR_PTR(err); + } +diff --git a/drivers/net/phy/dp83640.c b/drivers/net/phy/dp83640.c +index ecbd5e0d685c..acb0aae60755 100644 +--- a/drivers/net/phy/dp83640.c ++++ b/drivers/net/phy/dp83640.c +@@ -1260,6 +1260,7 @@ static int dp83640_hwtstamp(struct mii_timestamper *mii_ts, struct ifreq *ifr) + dp83640->hwts_rx_en = 1; + dp83640->layer = PTP_CLASS_L4; + dp83640->version = PTP_CLASS_V1; ++ cfg.rx_filter = HWTSTAMP_FILTER_PTP_V1_L4_EVENT; + break; + case HWTSTAMP_FILTER_PTP_V2_L4_EVENT: + case HWTSTAMP_FILTER_PTP_V2_L4_SYNC: +@@ -1267,6 +1268,7 @@ static int dp83640_hwtstamp(struct mii_timestamper *mii_ts, struct ifreq *ifr) + dp83640->hwts_rx_en = 1; + dp83640->layer = PTP_CLASS_L4; + dp83640->version = PTP_CLASS_V2; ++ cfg.rx_filter = HWTSTAMP_FILTER_PTP_V2_L4_EVENT; + break; + case HWTSTAMP_FILTER_PTP_V2_L2_EVENT: + case HWTSTAMP_FILTER_PTP_V2_L2_SYNC: +@@ -1274,6 +1276,7 @@ static int dp83640_hwtstamp(struct mii_timestamper *mii_ts, struct ifreq *ifr) + dp83640->hwts_rx_en = 1; + dp83640->layer = PTP_CLASS_L2; + dp83640->version = PTP_CLASS_V2; ++ cfg.rx_filter = HWTSTAMP_FILTER_PTP_V2_L2_EVENT; + break; + case HWTSTAMP_FILTER_PTP_V2_EVENT: + case HWTSTAMP_FILTER_PTP_V2_SYNC: +@@ -1281,6 +1284,7 @@ static int dp83640_hwtstamp(struct mii_timestamper *mii_ts, struct ifreq *ifr) + dp83640->hwts_rx_en = 1; + dp83640->layer = PTP_CLASS_L4 | PTP_CLASS_L2; + dp83640->version = PTP_CLASS_V2; ++ cfg.rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT; + break; + default: + return -ERANGE; +diff --git a/drivers/net/usb/ax88172a.c b/drivers/net/usb/ax88172a.c +index 4e514f5d7c6c..fd3a04d98dc1 100644 +--- a/drivers/net/usb/ax88172a.c ++++ b/drivers/net/usb/ax88172a.c +@@ -187,6 +187,7 @@ static int ax88172a_bind(struct usbnet *dev, struct usb_interface *intf) + ret = asix_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf, 0); + if (ret < ETH_ALEN) { + netdev_err(dev->net, "Failed to read MAC address: %d\n", ret); ++ ret = -EIO; + goto free; + } + memcpy(dev->net->dev_addr, buf, ETH_ALEN); +diff --git a/drivers/net/wan/lapbether.c b/drivers/net/wan/lapbether.c +index e30d91a38cfb..284832314f31 100644 +--- a/drivers/net/wan/lapbether.c ++++ b/drivers/net/wan/lapbether.c +@@ -303,7 +303,6 @@ static void lapbeth_setup(struct net_device *dev) + dev->netdev_ops = &lapbeth_netdev_ops; + dev->needs_free_netdev = true; + dev->type = ARPHRD_X25; +- dev->hard_header_len = 3; + dev->mtu = 1000; + dev->addr_len = 0; + } +@@ -324,6 +323,14 @@ static int lapbeth_new_device(struct net_device *dev) + if (!ndev) + goto out; + ++ /* When transmitting data: ++ * first this driver removes a pseudo header of 1 byte, ++ * then the lapb module prepends an LAPB header of at most 3 bytes, ++ * then this driver prepends a length field of 2 bytes, ++ * then the underlying Ethernet device prepends its own header. ++ */ ++ ndev->hard_header_len = -1 + 3 + 2 + dev->hard_header_len; ++ + lapbeth = netdev_priv(ndev); + lapbeth->axdev = ndev; + +diff --git a/drivers/net/wireless/ath/ath9k/hif_usb.c b/drivers/net/wireless/ath/ath9k/hif_usb.c +index 6049d3766c64..3f563e02d17d 100644 +--- a/drivers/net/wireless/ath/ath9k/hif_usb.c ++++ b/drivers/net/wireless/ath/ath9k/hif_usb.c +@@ -643,9 +643,9 @@ err: + + static void ath9k_hif_usb_rx_cb(struct urb *urb) + { +- struct sk_buff *skb = (struct sk_buff *) urb->context; +- struct hif_device_usb *hif_dev = +- usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0)); ++ struct rx_buf *rx_buf = (struct rx_buf *)urb->context; ++ struct hif_device_usb *hif_dev = rx_buf->hif_dev; ++ struct sk_buff *skb = rx_buf->skb; + int ret; + + if (!skb) +@@ -685,14 +685,15 @@ resubmit: + return; + free: + kfree_skb(skb); ++ kfree(rx_buf); + } + + static void ath9k_hif_usb_reg_in_cb(struct urb *urb) + { +- struct sk_buff *skb = (struct sk_buff *) urb->context; ++ struct rx_buf *rx_buf = (struct rx_buf *)urb->context; ++ struct hif_device_usb *hif_dev = rx_buf->hif_dev; ++ struct sk_buff *skb = rx_buf->skb; + struct sk_buff *nskb; +- struct hif_device_usb *hif_dev = +- usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0)); + int ret; + + if (!skb) +@@ -732,11 +733,13 @@ static void ath9k_hif_usb_reg_in_cb(struct urb *urb) + return; + } + ++ rx_buf->skb = nskb; ++ + usb_fill_int_urb(urb, hif_dev->udev, + usb_rcvintpipe(hif_dev->udev, + USB_REG_IN_PIPE), + nskb->data, MAX_REG_IN_BUF_SIZE, +- ath9k_hif_usb_reg_in_cb, nskb, 1); ++ ath9k_hif_usb_reg_in_cb, rx_buf, 1); + } + + resubmit: +@@ -750,6 +753,7 @@ resubmit: + return; + free: + kfree_skb(skb); ++ kfree(rx_buf); + urb->context = NULL; + } + +@@ -795,7 +799,7 @@ static int ath9k_hif_usb_alloc_tx_urbs(struct hif_device_usb *hif_dev) + init_usb_anchor(&hif_dev->mgmt_submitted); + + for (i = 0; i < MAX_TX_URB_NUM; i++) { +- tx_buf = kzalloc(sizeof(struct tx_buf), GFP_KERNEL); ++ tx_buf = kzalloc(sizeof(*tx_buf), GFP_KERNEL); + if (!tx_buf) + goto err; + +@@ -832,8 +836,9 @@ static void ath9k_hif_usb_dealloc_rx_urbs(struct hif_device_usb *hif_dev) + + static int ath9k_hif_usb_alloc_rx_urbs(struct hif_device_usb *hif_dev) + { +- struct urb *urb = NULL; ++ struct rx_buf *rx_buf = NULL; + struct sk_buff *skb = NULL; ++ struct urb *urb = NULL; + int i, ret; + + init_usb_anchor(&hif_dev->rx_submitted); +@@ -841,6 +846,12 @@ static int ath9k_hif_usb_alloc_rx_urbs(struct hif_device_usb *hif_dev) + + for (i = 0; i < MAX_RX_URB_NUM; i++) { + ++ rx_buf = kzalloc(sizeof(*rx_buf), GFP_KERNEL); ++ if (!rx_buf) { ++ ret = -ENOMEM; ++ goto err_rxb; ++ } ++ + /* Allocate URB */ + urb = usb_alloc_urb(0, GFP_KERNEL); + if (urb == NULL) { +@@ -855,11 +866,14 @@ static int ath9k_hif_usb_alloc_rx_urbs(struct hif_device_usb *hif_dev) + goto err_skb; + } + ++ rx_buf->hif_dev = hif_dev; ++ rx_buf->skb = skb; ++ + usb_fill_bulk_urb(urb, hif_dev->udev, + usb_rcvbulkpipe(hif_dev->udev, + USB_WLAN_RX_PIPE), + skb->data, MAX_RX_BUF_SIZE, +- ath9k_hif_usb_rx_cb, skb); ++ ath9k_hif_usb_rx_cb, rx_buf); + + /* Anchor URB */ + usb_anchor_urb(urb, &hif_dev->rx_submitted); +@@ -885,6 +899,8 @@ err_submit: + err_skb: + usb_free_urb(urb); + err_urb: ++ kfree(rx_buf); ++err_rxb: + ath9k_hif_usb_dealloc_rx_urbs(hif_dev); + return ret; + } +@@ -896,14 +912,21 @@ static void ath9k_hif_usb_dealloc_reg_in_urbs(struct hif_device_usb *hif_dev) + + static int ath9k_hif_usb_alloc_reg_in_urbs(struct hif_device_usb *hif_dev) + { +- struct urb *urb = NULL; ++ struct rx_buf *rx_buf = NULL; + struct sk_buff *skb = NULL; ++ struct urb *urb = NULL; + int i, ret; + + init_usb_anchor(&hif_dev->reg_in_submitted); + + for (i = 0; i < MAX_REG_IN_URB_NUM; i++) { + ++ rx_buf = kzalloc(sizeof(*rx_buf), GFP_KERNEL); ++ if (!rx_buf) { ++ ret = -ENOMEM; ++ goto err_rxb; ++ } ++ + /* Allocate URB */ + urb = usb_alloc_urb(0, GFP_KERNEL); + if (urb == NULL) { +@@ -918,11 +941,14 @@ static int ath9k_hif_usb_alloc_reg_in_urbs(struct hif_device_usb *hif_dev) + goto err_skb; + } + ++ rx_buf->hif_dev = hif_dev; ++ rx_buf->skb = skb; ++ + usb_fill_int_urb(urb, hif_dev->udev, + usb_rcvintpipe(hif_dev->udev, + USB_REG_IN_PIPE), + skb->data, MAX_REG_IN_BUF_SIZE, +- ath9k_hif_usb_reg_in_cb, skb, 1); ++ ath9k_hif_usb_reg_in_cb, rx_buf, 1); + + /* Anchor URB */ + usb_anchor_urb(urb, &hif_dev->reg_in_submitted); +@@ -948,6 +974,8 @@ err_submit: + err_skb: + usb_free_urb(urb); + err_urb: ++ kfree(rx_buf); ++err_rxb: + ath9k_hif_usb_dealloc_reg_in_urbs(hif_dev); + return ret; + } +diff --git a/drivers/net/wireless/ath/ath9k/hif_usb.h b/drivers/net/wireless/ath/ath9k/hif_usb.h +index a94e7e1c86e9..5985aa15ca93 100644 +--- a/drivers/net/wireless/ath/ath9k/hif_usb.h ++++ b/drivers/net/wireless/ath/ath9k/hif_usb.h +@@ -86,6 +86,11 @@ struct tx_buf { + struct list_head list; + }; + ++struct rx_buf { ++ struct sk_buff *skb; ++ struct hif_device_usb *hif_dev; ++}; ++ + #define HIF_USB_TX_STOP BIT(0) + #define HIF_USB_TX_FLUSH BIT(1) + +diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c +index 07ca8c91499d..ff49750b8ee7 100644 +--- a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c ++++ b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c +@@ -1184,17 +1184,15 @@ static int iwl_mvm_inactivity_check(struct iwl_mvm *mvm, u8 alloc_for_sta) + for_each_set_bit(i, &changetid_queues, IWL_MAX_HW_QUEUES) + iwl_mvm_change_queue_tid(mvm, i); + ++ rcu_read_unlock(); ++ + if (free_queue >= 0 && alloc_for_sta != IWL_MVM_INVALID_STA) { + ret = iwl_mvm_free_inactive_queue(mvm, free_queue, queue_owner, + alloc_for_sta); +- if (ret) { +- rcu_read_unlock(); ++ if (ret) + return ret; +- } + } + +- rcu_read_unlock(); +- + return free_queue; + } + +diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c +index 29971c25dba4..9ea3e5634672 100644 +--- a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c ++++ b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c +@@ -577,6 +577,8 @@ static const struct iwl_dev_info iwl_dev_info_table[] = { + IWL_DEV_INFO(0x30DC, 0x1552, iwl9560_2ac_cfg_soc, iwl9560_killer_1550i_name), + IWL_DEV_INFO(0x31DC, 0x1551, iwl9560_2ac_cfg_soc, iwl9560_killer_1550s_name), + IWL_DEV_INFO(0x31DC, 0x1552, iwl9560_2ac_cfg_soc, iwl9560_killer_1550i_name), ++ IWL_DEV_INFO(0xA370, 0x1551, iwl9560_2ac_cfg_soc, iwl9560_killer_1550s_name), ++ IWL_DEV_INFO(0xA370, 0x1552, iwl9560_2ac_cfg_soc, iwl9560_killer_1550i_name), + + IWL_DEV_INFO(0x271C, 0x0214, iwl9260_2ac_cfg, iwl9260_1_name), + +diff --git a/drivers/net/wireless/mediatek/mt76/mt76.h b/drivers/net/wireless/mediatek/mt76/mt76.h +index 37641ad14d49..652dd05af16b 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt76.h ++++ b/drivers/net/wireless/mediatek/mt76/mt76.h +@@ -275,6 +275,7 @@ enum { + MT76_STATE_RUNNING, + MT76_STATE_MCU_RUNNING, + MT76_SCANNING, ++ MT76_RESTART, + MT76_RESET, + MT76_MCU_RESET, + MT76_REMOVED, +diff --git a/drivers/net/wireless/mediatek/mt76/mt76x0/pci.c b/drivers/net/wireless/mediatek/mt76/mt76x0/pci.c +index 0b520ae08d01..57091d41eb85 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt76x0/pci.c ++++ b/drivers/net/wireless/mediatek/mt76/mt76x0/pci.c +@@ -29,6 +29,7 @@ static void mt76x0e_stop_hw(struct mt76x02_dev *dev) + { + cancel_delayed_work_sync(&dev->cal_work); + cancel_delayed_work_sync(&dev->mt76.mac_work); ++ clear_bit(MT76_RESTART, &dev->mphy.state); + + if (!mt76_poll(dev, MT_WPDMA_GLO_CFG, MT_WPDMA_GLO_CFG_TX_DMA_BUSY, + 0, 1000)) +@@ -83,6 +84,7 @@ static const struct ieee80211_ops mt76x0e_ops = { + .set_coverage_class = mt76x02_set_coverage_class, + .set_rts_threshold = mt76x02_set_rts_threshold, + .get_antenna = mt76_get_antenna, ++ .reconfig_complete = mt76x02_reconfig_complete, + }; + + static int mt76x0e_register_device(struct mt76x02_dev *dev) +diff --git a/drivers/net/wireless/mediatek/mt76/mt76x02.h b/drivers/net/wireless/mediatek/mt76/mt76x02.h +index 830532b85b58..6ea210bd3f07 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt76x02.h ++++ b/drivers/net/wireless/mediatek/mt76/mt76x02.h +@@ -187,6 +187,8 @@ void mt76x02_sta_ps(struct mt76_dev *dev, struct ieee80211_sta *sta, bool ps); + void mt76x02_bss_info_changed(struct ieee80211_hw *hw, + struct ieee80211_vif *vif, + struct ieee80211_bss_conf *info, u32 changed); ++void mt76x02_reconfig_complete(struct ieee80211_hw *hw, ++ enum ieee80211_reconfig_type reconfig_type); + + struct beacon_bc_data { + struct mt76x02_dev *dev; +diff --git a/drivers/net/wireless/mediatek/mt76/mt76x02_mcu.c b/drivers/net/wireless/mediatek/mt76/mt76x02_mcu.c +index 5664749ad6c1..8247611d9b18 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt76x02_mcu.c ++++ b/drivers/net/wireless/mediatek/mt76/mt76x02_mcu.c +@@ -20,6 +20,9 @@ int mt76x02_mcu_msg_send(struct mt76_dev *mdev, int cmd, const void *data, + int ret; + u8 seq; + ++ if (mt76_is_mmio(&dev->mt76) && dev->mcu_timeout) ++ return -EIO; ++ + skb = mt76x02_mcu_msg_alloc(data, len); + if (!skb) + return -ENOMEM; +diff --git a/drivers/net/wireless/mediatek/mt76/mt76x02_mmio.c b/drivers/net/wireless/mediatek/mt76/mt76x02_mmio.c +index 7dcc5d342e9f..7e389dbccfeb 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt76x02_mmio.c ++++ b/drivers/net/wireless/mediatek/mt76/mt76x02_mmio.c +@@ -520,6 +520,7 @@ static void mt76x02_watchdog_reset(struct mt76x02_dev *dev) + } + + if (restart) { ++ set_bit(MT76_RESTART, &dev->mphy.state); + mt76x02_mcu_function_select(dev, Q_SELECT, 1); + ieee80211_restart_hw(dev->mt76.hw); + } else { +@@ -528,8 +529,23 @@ static void mt76x02_watchdog_reset(struct mt76x02_dev *dev) + } + } + ++void mt76x02_reconfig_complete(struct ieee80211_hw *hw, ++ enum ieee80211_reconfig_type reconfig_type) ++{ ++ struct mt76x02_dev *dev = hw->priv; ++ ++ if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART) ++ return; ++ ++ clear_bit(MT76_RESTART, &dev->mphy.state); ++} ++EXPORT_SYMBOL_GPL(mt76x02_reconfig_complete); ++ + static void mt76x02_check_tx_hang(struct mt76x02_dev *dev) + { ++ if (test_bit(MT76_RESTART, &dev->mphy.state)) ++ return; ++ + if (mt76x02_tx_hang(dev)) { + if (++dev->tx_hang_check >= MT_TX_HANG_TH) + goto restart; +diff --git a/drivers/net/wireless/mediatek/mt76/mt76x2/pci_init.c b/drivers/net/wireless/mediatek/mt76/mt76x2/pci_init.c +index c69579e5f647..f27774f57438 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt76x2/pci_init.c ++++ b/drivers/net/wireless/mediatek/mt76/mt76x2/pci_init.c +@@ -256,6 +256,7 @@ void mt76x2_stop_hardware(struct mt76x02_dev *dev) + cancel_delayed_work_sync(&dev->cal_work); + cancel_delayed_work_sync(&dev->mt76.mac_work); + cancel_delayed_work_sync(&dev->wdt_work); ++ clear_bit(MT76_RESTART, &dev->mphy.state); + mt76x02_mcu_set_radio_state(dev, false); + mt76x2_mac_stop(dev, false); + } +diff --git a/drivers/net/wireless/mediatek/mt76/mt76x2/pci_main.c b/drivers/net/wireless/mediatek/mt76/mt76x2/pci_main.c +index 105e5b99b3f9..a74599f7f729 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt76x2/pci_main.c ++++ b/drivers/net/wireless/mediatek/mt76/mt76x2/pci_main.c +@@ -10,12 +10,9 @@ static int + mt76x2_start(struct ieee80211_hw *hw) + { + struct mt76x02_dev *dev = hw->priv; +- int ret; + + mt76x02_mac_start(dev); +- ret = mt76x2_phy_start(dev); +- if (ret) +- return ret; ++ mt76x2_phy_start(dev); + + ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work, + MT_MAC_WORK_INTERVAL); +@@ -35,11 +32,9 @@ mt76x2_stop(struct ieee80211_hw *hw) + mt76x2_stop_hardware(dev); + } + +-static int ++static void + mt76x2_set_channel(struct mt76x02_dev *dev, struct cfg80211_chan_def *chandef) + { +- int ret; +- + cancel_delayed_work_sync(&dev->cal_work); + tasklet_disable(&dev->mt76.pre_tbtt_tasklet); + tasklet_disable(&dev->dfs_pd.dfs_tasklet); +@@ -50,7 +45,7 @@ mt76x2_set_channel(struct mt76x02_dev *dev, struct cfg80211_chan_def *chandef) + mt76_set_channel(&dev->mphy); + + mt76x2_mac_stop(dev, true); +- ret = mt76x2_phy_set_channel(dev, chandef); ++ mt76x2_phy_set_channel(dev, chandef); + + mt76x02_mac_cc_reset(dev); + mt76x02_dfs_init_params(dev); +@@ -64,15 +59,12 @@ mt76x2_set_channel(struct mt76x02_dev *dev, struct cfg80211_chan_def *chandef) + tasklet_enable(&dev->mt76.pre_tbtt_tasklet); + + mt76_txq_schedule_all(&dev->mphy); +- +- return ret; + } + + static int + mt76x2_config(struct ieee80211_hw *hw, u32 changed) + { + struct mt76x02_dev *dev = hw->priv; +- int ret = 0; + + mutex_lock(&dev->mt76.mutex); + +@@ -101,11 +93,11 @@ mt76x2_config(struct ieee80211_hw *hw, u32 changed) + + if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { + ieee80211_stop_queues(hw); +- ret = mt76x2_set_channel(dev, &hw->conf.chandef); ++ mt76x2_set_channel(dev, &hw->conf.chandef); + ieee80211_wake_queues(hw); + } + +- return ret; ++ return 0; + } + + static void +@@ -162,5 +154,6 @@ const struct ieee80211_ops mt76x2_ops = { + .set_antenna = mt76x2_set_antenna, + .get_antenna = mt76_get_antenna, + .set_rts_threshold = mt76x02_set_rts_threshold, ++ .reconfig_complete = mt76x02_reconfig_complete, + }; + +diff --git a/drivers/pci/controller/vmd.c b/drivers/pci/controller/vmd.c +index e386d4eac407..9a64cf90c291 100644 +--- a/drivers/pci/controller/vmd.c ++++ b/drivers/pci/controller/vmd.c +@@ -546,9 +546,10 @@ static int vmd_enable_domain(struct vmd_dev *vmd, unsigned long features) + + vmd->irq_domain = pci_msi_create_irq_domain(fn, &vmd_msi_domain_info, + x86_vector_domain); +- irq_domain_free_fwnode(fn); +- if (!vmd->irq_domain) ++ if (!vmd->irq_domain) { ++ irq_domain_free_fwnode(fn); + return -ENODEV; ++ } + + pci_add_resource(&resources, &vmd->resources[0]); + pci_add_resource_offset(&resources, &vmd->resources[1], offset[0]); +diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c +index d4758518a97b..a4efc7e0061f 100644 +--- a/drivers/pci/pci.c ++++ b/drivers/pci/pci.c +@@ -4662,8 +4662,7 @@ static int pci_pm_reset(struct pci_dev *dev, int probe) + * pcie_wait_for_link_delay - Wait until link is active or inactive + * @pdev: Bridge device + * @active: waiting for active or inactive? +- * @delay: Delay to wait after link has become active (in ms). Specify %0 +- * for no delay. ++ * @delay: Delay to wait after link has become active (in ms) + * + * Use this to wait till link becomes active or inactive. + */ +@@ -4704,7 +4703,7 @@ static bool pcie_wait_for_link_delay(struct pci_dev *pdev, bool active, + msleep(10); + timeout -= 10; + } +- if (active && ret && delay) ++ if (active && ret) + msleep(delay); + else if (ret != active) + pci_info(pdev, "Data Link Layer Link Active not %s in 1000 msec\n", +@@ -4825,28 +4824,17 @@ void pci_bridge_wait_for_secondary_bus(struct pci_dev *dev) + if (!pcie_downstream_port(dev)) + return; + +- /* +- * Per PCIe r5.0, sec 6.6.1, for downstream ports that support +- * speeds > 5 GT/s, we must wait for link training to complete +- * before the mandatory delay. +- * +- * We can only tell when link training completes via DLL Link +- * Active, which is required for downstream ports that support +- * speeds > 5 GT/s (sec 7.5.3.6). Unfortunately some common +- * devices do not implement Link Active reporting even when it's +- * required, so we'll check for that directly instead of checking +- * the supported link speed. We assume devices without Link Active +- * reporting can train in 100 ms regardless of speed. +- */ +- if (dev->link_active_reporting) { +- pci_dbg(dev, "waiting for link to train\n"); +- if (!pcie_wait_for_link_delay(dev, true, 0)) { ++ if (pcie_get_speed_cap(dev) <= PCIE_SPEED_5_0GT) { ++ pci_dbg(dev, "waiting %d ms for downstream link\n", delay); ++ msleep(delay); ++ } else { ++ pci_dbg(dev, "waiting %d ms for downstream link, after activation\n", ++ delay); ++ if (!pcie_wait_for_link_delay(dev, true, delay)) { + /* Did not train, no need to wait any further */ + return; + } + } +- pci_dbg(child, "waiting %d ms to become accessible\n", delay); +- msleep(delay); + + if (!pci_device_is_present(child)) { + pci_dbg(child, "waiting additional %d ms to become accessible\n", delay); +diff --git a/drivers/perf/arm-cci.c b/drivers/perf/arm-cci.c +index 1b8e337a29ca..87c4be9dd412 100644 +--- a/drivers/perf/arm-cci.c ++++ b/drivers/perf/arm-cci.c +@@ -1718,6 +1718,7 @@ static struct platform_driver cci_pmu_driver = { + .driver = { + .name = DRIVER_NAME, + .of_match_table = arm_cci_pmu_matches, ++ .suppress_bind_attrs = true, + }, + .probe = cci_pmu_probe, + .remove = cci_pmu_remove, +diff --git a/drivers/perf/arm-ccn.c b/drivers/perf/arm-ccn.c +index d50edef91f59..7b7d23f25713 100644 +--- a/drivers/perf/arm-ccn.c ++++ b/drivers/perf/arm-ccn.c +@@ -1545,6 +1545,7 @@ static struct platform_driver arm_ccn_driver = { + .driver = { + .name = "arm-ccn", + .of_match_table = arm_ccn_match, ++ .suppress_bind_attrs = true, + }, + .probe = arm_ccn_probe, + .remove = arm_ccn_remove, +diff --git a/drivers/perf/arm_dsu_pmu.c b/drivers/perf/arm_dsu_pmu.c +index 70968c8c09d7..4594e2ed13d5 100644 +--- a/drivers/perf/arm_dsu_pmu.c ++++ b/drivers/perf/arm_dsu_pmu.c +@@ -759,6 +759,7 @@ static struct platform_driver dsu_pmu_driver = { + .driver = { + .name = DRVNAME, + .of_match_table = of_match_ptr(dsu_pmu_of_match), ++ .suppress_bind_attrs = true, + }, + .probe = dsu_pmu_device_probe, + .remove = dsu_pmu_device_remove, +diff --git a/drivers/perf/arm_smmuv3_pmu.c b/drivers/perf/arm_smmuv3_pmu.c +index 48e28ef93a70..4cdb35d166ac 100644 +--- a/drivers/perf/arm_smmuv3_pmu.c ++++ b/drivers/perf/arm_smmuv3_pmu.c +@@ -742,6 +742,7 @@ static int smmu_pmu_probe(struct platform_device *pdev) + platform_set_drvdata(pdev, smmu_pmu); + + smmu_pmu->pmu = (struct pmu) { ++ .module = THIS_MODULE, + .task_ctx_nr = perf_invalid_context, + .pmu_enable = smmu_pmu_enable, + .pmu_disable = smmu_pmu_disable, +@@ -859,6 +860,7 @@ static void smmu_pmu_shutdown(struct platform_device *pdev) + static struct platform_driver smmu_pmu_driver = { + .driver = { + .name = "arm-smmu-v3-pmcg", ++ .suppress_bind_attrs = true, + }, + .probe = smmu_pmu_probe, + .remove = smmu_pmu_remove, +diff --git a/drivers/perf/arm_spe_pmu.c b/drivers/perf/arm_spe_pmu.c +index b72c04852599..c5418fd3122c 100644 +--- a/drivers/perf/arm_spe_pmu.c ++++ b/drivers/perf/arm_spe_pmu.c +@@ -1228,6 +1228,7 @@ static struct platform_driver arm_spe_pmu_driver = { + .driver = { + .name = DRVNAME, + .of_match_table = of_match_ptr(arm_spe_pmu_of_match), ++ .suppress_bind_attrs = true, + }, + .probe = arm_spe_pmu_device_probe, + .remove = arm_spe_pmu_device_remove, +diff --git a/drivers/perf/fsl_imx8_ddr_perf.c b/drivers/perf/fsl_imx8_ddr_perf.c +index 90884d14f95f..397540a4b799 100644 +--- a/drivers/perf/fsl_imx8_ddr_perf.c ++++ b/drivers/perf/fsl_imx8_ddr_perf.c +@@ -512,6 +512,7 @@ static int ddr_perf_init(struct ddr_pmu *pmu, void __iomem *base, + { + *pmu = (struct ddr_pmu) { + .pmu = (struct pmu) { ++ .module = THIS_MODULE, + .capabilities = PERF_PMU_CAP_NO_EXCLUDE, + .task_ctx_nr = perf_invalid_context, + .attr_groups = attr_groups, +@@ -706,6 +707,7 @@ static struct platform_driver imx_ddr_pmu_driver = { + .driver = { + .name = "imx-ddr-pmu", + .of_match_table = imx_ddr_pmu_dt_ids, ++ .suppress_bind_attrs = true, + }, + .probe = ddr_perf_probe, + .remove = ddr_perf_remove, +diff --git a/drivers/perf/hisilicon/hisi_uncore_ddrc_pmu.c b/drivers/perf/hisilicon/hisi_uncore_ddrc_pmu.c +index 453f1c6a16ca..341852736640 100644 +--- a/drivers/perf/hisilicon/hisi_uncore_ddrc_pmu.c ++++ b/drivers/perf/hisilicon/hisi_uncore_ddrc_pmu.c +@@ -378,6 +378,7 @@ static int hisi_ddrc_pmu_probe(struct platform_device *pdev) + ddrc_pmu->sccl_id, ddrc_pmu->index_id); + ddrc_pmu->pmu = (struct pmu) { + .name = name, ++ .module = THIS_MODULE, + .task_ctx_nr = perf_invalid_context, + .event_init = hisi_uncore_pmu_event_init, + .pmu_enable = hisi_uncore_pmu_enable, +@@ -416,6 +417,7 @@ static struct platform_driver hisi_ddrc_pmu_driver = { + .driver = { + .name = "hisi_ddrc_pmu", + .acpi_match_table = ACPI_PTR(hisi_ddrc_pmu_acpi_match), ++ .suppress_bind_attrs = true, + }, + .probe = hisi_ddrc_pmu_probe, + .remove = hisi_ddrc_pmu_remove, +diff --git a/drivers/perf/hisilicon/hisi_uncore_hha_pmu.c b/drivers/perf/hisilicon/hisi_uncore_hha_pmu.c +index e5af9d7e6e14..375c4737a088 100644 +--- a/drivers/perf/hisilicon/hisi_uncore_hha_pmu.c ++++ b/drivers/perf/hisilicon/hisi_uncore_hha_pmu.c +@@ -390,6 +390,7 @@ static int hisi_hha_pmu_probe(struct platform_device *pdev) + hha_pmu->sccl_id, hha_pmu->index_id); + hha_pmu->pmu = (struct pmu) { + .name = name, ++ .module = THIS_MODULE, + .task_ctx_nr = perf_invalid_context, + .event_init = hisi_uncore_pmu_event_init, + .pmu_enable = hisi_uncore_pmu_enable, +@@ -428,6 +429,7 @@ static struct platform_driver hisi_hha_pmu_driver = { + .driver = { + .name = "hisi_hha_pmu", + .acpi_match_table = ACPI_PTR(hisi_hha_pmu_acpi_match), ++ .suppress_bind_attrs = true, + }, + .probe = hisi_hha_pmu_probe, + .remove = hisi_hha_pmu_remove, +diff --git a/drivers/perf/hisilicon/hisi_uncore_l3c_pmu.c b/drivers/perf/hisilicon/hisi_uncore_l3c_pmu.c +index 479de4be99eb..44e8a660c5f5 100644 +--- a/drivers/perf/hisilicon/hisi_uncore_l3c_pmu.c ++++ b/drivers/perf/hisilicon/hisi_uncore_l3c_pmu.c +@@ -380,6 +380,7 @@ static int hisi_l3c_pmu_probe(struct platform_device *pdev) + l3c_pmu->sccl_id, l3c_pmu->index_id); + l3c_pmu->pmu = (struct pmu) { + .name = name, ++ .module = THIS_MODULE, + .task_ctx_nr = perf_invalid_context, + .event_init = hisi_uncore_pmu_event_init, + .pmu_enable = hisi_uncore_pmu_enable, +@@ -418,6 +419,7 @@ static struct platform_driver hisi_l3c_pmu_driver = { + .driver = { + .name = "hisi_l3c_pmu", + .acpi_match_table = ACPI_PTR(hisi_l3c_pmu_acpi_match), ++ .suppress_bind_attrs = true, + }, + .probe = hisi_l3c_pmu_probe, + .remove = hisi_l3c_pmu_remove, +diff --git a/drivers/perf/qcom_l2_pmu.c b/drivers/perf/qcom_l2_pmu.c +index 21d6991dbe0b..4da37f650f98 100644 +--- a/drivers/perf/qcom_l2_pmu.c ++++ b/drivers/perf/qcom_l2_pmu.c +@@ -1028,6 +1028,7 @@ static struct platform_driver l2_cache_pmu_driver = { + .driver = { + .name = "qcom-l2cache-pmu", + .acpi_match_table = ACPI_PTR(l2_cache_pmu_acpi_match), ++ .suppress_bind_attrs = true, + }, + .probe = l2_cache_pmu_probe, + .remove = l2_cache_pmu_remove, +diff --git a/drivers/perf/qcom_l3_pmu.c b/drivers/perf/qcom_l3_pmu.c +index 656e830798d9..9ddb577c542b 100644 +--- a/drivers/perf/qcom_l3_pmu.c ++++ b/drivers/perf/qcom_l3_pmu.c +@@ -814,6 +814,7 @@ static struct platform_driver qcom_l3_cache_pmu_driver = { + .driver = { + .name = "qcom-l3cache-pmu", + .acpi_match_table = ACPI_PTR(qcom_l3_cache_pmu_acpi_match), ++ .suppress_bind_attrs = true, + }, + .probe = qcom_l3_cache_pmu_probe, + }; +diff --git a/drivers/perf/thunderx2_pmu.c b/drivers/perf/thunderx2_pmu.c +index 51b31d6ff2c4..aac9823b0c6b 100644 +--- a/drivers/perf/thunderx2_pmu.c ++++ b/drivers/perf/thunderx2_pmu.c +@@ -1017,6 +1017,7 @@ static struct platform_driver tx2_uncore_driver = { + .driver = { + .name = "tx2-uncore-pmu", + .acpi_match_table = ACPI_PTR(tx2_uncore_acpi_match), ++ .suppress_bind_attrs = true, + }, + .probe = tx2_uncore_probe, + .remove = tx2_uncore_remove, +diff --git a/drivers/perf/xgene_pmu.c b/drivers/perf/xgene_pmu.c +index 46ee6807d533..edac28cd25dd 100644 +--- a/drivers/perf/xgene_pmu.c ++++ b/drivers/perf/xgene_pmu.c +@@ -1975,6 +1975,7 @@ static struct platform_driver xgene_pmu_driver = { + .name = "xgene-pmu", + .of_match_table = xgene_pmu_of_match, + .acpi_match_table = ACPI_PTR(xgene_pmu_acpi_match), ++ .suppress_bind_attrs = true, + }, + }; + +diff --git a/drivers/pinctrl/pinctrl-amd.h b/drivers/pinctrl/pinctrl-amd.h +index 3e5760f1a715..d4a192df5fab 100644 +--- a/drivers/pinctrl/pinctrl-amd.h ++++ b/drivers/pinctrl/pinctrl-amd.h +@@ -252,7 +252,7 @@ static const struct amd_pingroup kerncz_groups[] = { + { + .name = "uart0", + .pins = uart0_pins, +- .npins = 9, ++ .npins = 5, + }, + { + .name = "uart1", +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index cd212ee210e2..537b824a1ae2 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -432,6 +432,7 @@ static int asus_wmi_battery_add(struct power_supply *battery) + * battery is named BATT. + */ + if (strcmp(battery->desc->name, "BAT0") != 0 && ++ strcmp(battery->desc->name, "BAT1") != 0 && + strcmp(battery->desc->name, "BATT") != 0) + return -ENODEV; + +diff --git a/drivers/platform/x86/intel_speed_select_if/isst_if_common.h b/drivers/platform/x86/intel_speed_select_if/isst_if_common.h +index 1409a5bb5582..4f6f7f0761fc 100644 +--- a/drivers/platform/x86/intel_speed_select_if/isst_if_common.h ++++ b/drivers/platform/x86/intel_speed_select_if/isst_if_common.h +@@ -13,6 +13,9 @@ + #define INTEL_RAPL_PRIO_DEVID_0 0x3451 + #define INTEL_CFG_MBOX_DEVID_0 0x3459 + ++#define INTEL_RAPL_PRIO_DEVID_1 0x3251 ++#define INTEL_CFG_MBOX_DEVID_1 0x3259 ++ + /* + * Validate maximum commands in a single request. + * This is enough to handle command to every core in one ioctl, or all +diff --git a/drivers/platform/x86/intel_speed_select_if/isst_if_mbox_pci.c b/drivers/platform/x86/intel_speed_select_if/isst_if_mbox_pci.c +index de4169d0796b..9a055fd54053 100644 +--- a/drivers/platform/x86/intel_speed_select_if/isst_if_mbox_pci.c ++++ b/drivers/platform/x86/intel_speed_select_if/isst_if_mbox_pci.c +@@ -148,6 +148,7 @@ static long isst_if_mbox_proc_cmd(u8 *cmd_ptr, int *write_only, int resume) + + static const struct pci_device_id isst_if_mbox_ids[] = { + { PCI_DEVICE(PCI_VENDOR_ID_INTEL, INTEL_CFG_MBOX_DEVID_0)}, ++ { PCI_DEVICE(PCI_VENDOR_ID_INTEL, INTEL_CFG_MBOX_DEVID_1)}, + { 0 }, + }; + MODULE_DEVICE_TABLE(pci, isst_if_mbox_ids); +diff --git a/drivers/platform/x86/intel_speed_select_if/isst_if_mmio.c b/drivers/platform/x86/intel_speed_select_if/isst_if_mmio.c +index 3584859fcc42..aa17fd7817f8 100644 +--- a/drivers/platform/x86/intel_speed_select_if/isst_if_mmio.c ++++ b/drivers/platform/x86/intel_speed_select_if/isst_if_mmio.c +@@ -72,6 +72,7 @@ static long isst_if_mmio_rd_wr(u8 *cmd_ptr, int *write_only, int resume) + + static const struct pci_device_id isst_if_ids[] = { + { PCI_DEVICE(PCI_VENDOR_ID_INTEL, INTEL_RAPL_PRIO_DEVID_0)}, ++ { PCI_DEVICE(PCI_VENDOR_ID_INTEL, INTEL_RAPL_PRIO_DEVID_1)}, + { 0 }, + }; + MODULE_DEVICE_TABLE(pci, isst_if_ids); +diff --git a/drivers/scsi/mpt3sas/mpt3sas_ctl.c b/drivers/scsi/mpt3sas/mpt3sas_ctl.c +index 62e552838565..983e568ff231 100644 +--- a/drivers/scsi/mpt3sas/mpt3sas_ctl.c ++++ b/drivers/scsi/mpt3sas/mpt3sas_ctl.c +@@ -3145,19 +3145,18 @@ BRM_status_show(struct device *cdev, struct device_attribute *attr, + if (!ioc->is_warpdrive) { + ioc_err(ioc, "%s: BRM attribute is only for warpdrive\n", + __func__); +- goto out; ++ return 0; + } + /* pci_access_mutex lock acquired by sysfs show path */ + mutex_lock(&ioc->pci_access_mutex); +- if (ioc->pci_error_recovery || ioc->remove_host) { +- mutex_unlock(&ioc->pci_access_mutex); +- return 0; +- } ++ if (ioc->pci_error_recovery || ioc->remove_host) ++ goto out; + + /* allocate upto GPIOVal 36 entries */ + sz = offsetof(Mpi2IOUnitPage3_t, GPIOVal) + (sizeof(u16) * 36); + io_unit_pg3 = kzalloc(sz, GFP_KERNEL); + if (!io_unit_pg3) { ++ rc = -ENOMEM; + ioc_err(ioc, "%s: failed allocating memory for iounit_pg3: (%d) bytes\n", + __func__, sz); + goto out; +@@ -3167,6 +3166,7 @@ BRM_status_show(struct device *cdev, struct device_attribute *attr, + 0) { + ioc_err(ioc, "%s: failed reading iounit_pg3\n", + __func__); ++ rc = -EINVAL; + goto out; + } + +@@ -3174,12 +3174,14 @@ BRM_status_show(struct device *cdev, struct device_attribute *attr, + if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { + ioc_err(ioc, "%s: iounit_pg3 failed with ioc_status(0x%04x)\n", + __func__, ioc_status); ++ rc = -EINVAL; + goto out; + } + + if (io_unit_pg3->GPIOCount < 25) { + ioc_err(ioc, "%s: iounit_pg3->GPIOCount less than 25 entries, detected (%d) entries\n", + __func__, io_unit_pg3->GPIOCount); ++ rc = -EINVAL; + goto out; + } + +diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c +index eed31021e788..ba84244c1b4f 100644 +--- a/drivers/scsi/scsi_devinfo.c ++++ b/drivers/scsi/scsi_devinfo.c +@@ -239,6 +239,7 @@ static struct { + {"LSI", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, + {"ENGENIO", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, + {"LENOVO", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, ++ {"FUJITSU", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, + {"SanDisk", "Cruzer Blade", NULL, BLIST_TRY_VPD_PAGES | + BLIST_INQUIRY_36}, + {"SMSC", "USB 2 HS-CF", NULL, BLIST_SPARSELUN | BLIST_INQUIRY_36}, +diff --git a/drivers/scsi/scsi_dh.c b/drivers/scsi/scsi_dh.c +index 42f0550d6b11..6f41e4b5a2b8 100644 +--- a/drivers/scsi/scsi_dh.c ++++ b/drivers/scsi/scsi_dh.c +@@ -63,6 +63,7 @@ static const struct scsi_dh_blist scsi_dh_blist[] = { + {"LSI", "INF-01-00", "rdac", }, + {"ENGENIO", "INF-01-00", "rdac", }, + {"LENOVO", "DE_Series", "rdac", }, ++ {"FUJITSU", "ETERNUS_AHB", "rdac", }, + {NULL, NULL, NULL }, + }; + +diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c +index f8661062ef95..f3d5b1bbd5aa 100644 +--- a/drivers/scsi/scsi_transport_spi.c ++++ b/drivers/scsi/scsi_transport_spi.c +@@ -339,7 +339,7 @@ store_spi_transport_##field(struct device *dev, \ + struct spi_transport_attrs *tp \ + = (struct spi_transport_attrs *)&starget->starget_data; \ + \ +- if (i->f->set_##field) \ ++ if (!i->f->set_##field) \ + return -EINVAL; \ + val = simple_strtoul(buf, NULL, 0); \ + if (val > tp->max_##field) \ +diff --git a/drivers/soc/amlogic/meson-gx-socinfo.c b/drivers/soc/amlogic/meson-gx-socinfo.c +index 01fc0d20a70d..6f54bd832c8b 100644 +--- a/drivers/soc/amlogic/meson-gx-socinfo.c ++++ b/drivers/soc/amlogic/meson-gx-socinfo.c +@@ -66,10 +66,12 @@ static const struct meson_gx_package_id { + { "A113D", 0x25, 0x22, 0xff }, + { "S905D2", 0x28, 0x10, 0xf0 }, + { "S905X2", 0x28, 0x40, 0xf0 }, +- { "S922X", 0x29, 0x40, 0xf0 }, + { "A311D", 0x29, 0x10, 0xf0 }, +- { "S905X3", 0x2b, 0x5, 0xf }, +- { "S905D3", 0x2b, 0xb0, 0xf0 }, ++ { "S922X", 0x29, 0x40, 0xf0 }, ++ { "S905D3", 0x2b, 0x4, 0xf5 }, ++ { "S905X3", 0x2b, 0x5, 0xf5 }, ++ { "S905X3", 0x2b, 0x10, 0x3f }, ++ { "S905D3", 0x2b, 0x30, 0x3f }, + { "A113L", 0x2c, 0x0, 0xf8 }, + }; + +diff --git a/drivers/soc/qcom/rpmh.c b/drivers/soc/qcom/rpmh.c +index a75f3df97742..908b74352c1b 100644 +--- a/drivers/soc/qcom/rpmh.c ++++ b/drivers/soc/qcom/rpmh.c +@@ -150,10 +150,10 @@ existing: + break; + } + +- ctrlr->dirty = (req->sleep_val != old_sleep_val || +- req->wake_val != old_wake_val) && +- req->sleep_val != UINT_MAX && +- req->wake_val != UINT_MAX; ++ ctrlr->dirty |= (req->sleep_val != old_sleep_val || ++ req->wake_val != old_wake_val) && ++ req->sleep_val != UINT_MAX && ++ req->wake_val != UINT_MAX; + + unlock: + spin_unlock_irqrestore(&ctrlr->cache_lock, flags); +diff --git a/drivers/spi/spi-mt65xx.c b/drivers/spi/spi-mt65xx.c +index 6783e12c40c2..a556795caeef 100644 +--- a/drivers/spi/spi-mt65xx.c ++++ b/drivers/spi/spi-mt65xx.c +@@ -36,7 +36,6 @@ + #define SPI_CFG0_SCK_LOW_OFFSET 8 + #define SPI_CFG0_CS_HOLD_OFFSET 16 + #define SPI_CFG0_CS_SETUP_OFFSET 24 +-#define SPI_ADJUST_CFG0_SCK_LOW_OFFSET 16 + #define SPI_ADJUST_CFG0_CS_HOLD_OFFSET 0 + #define SPI_ADJUST_CFG0_CS_SETUP_OFFSET 16 + +@@ -48,6 +47,8 @@ + #define SPI_CFG1_CS_IDLE_MASK 0xff + #define SPI_CFG1_PACKET_LOOP_MASK 0xff00 + #define SPI_CFG1_PACKET_LENGTH_MASK 0x3ff0000 ++#define SPI_CFG2_SCK_HIGH_OFFSET 0 ++#define SPI_CFG2_SCK_LOW_OFFSET 16 + + #define SPI_CMD_ACT BIT(0) + #define SPI_CMD_RESUME BIT(1) +@@ -283,7 +284,7 @@ static void mtk_spi_set_cs(struct spi_device *spi, bool enable) + static void mtk_spi_prepare_transfer(struct spi_master *master, + struct spi_transfer *xfer) + { +- u32 spi_clk_hz, div, sck_time, cs_time, reg_val = 0; ++ u32 spi_clk_hz, div, sck_time, cs_time, reg_val; + struct mtk_spi *mdata = spi_master_get_devdata(master); + + spi_clk_hz = clk_get_rate(mdata->spi_clk); +@@ -296,18 +297,18 @@ static void mtk_spi_prepare_transfer(struct spi_master *master, + cs_time = sck_time * 2; + + if (mdata->dev_comp->enhance_timing) { ++ reg_val = (((sck_time - 1) & 0xffff) ++ << SPI_CFG2_SCK_HIGH_OFFSET); + reg_val |= (((sck_time - 1) & 0xffff) +- << SPI_CFG0_SCK_HIGH_OFFSET); +- reg_val |= (((sck_time - 1) & 0xffff) +- << SPI_ADJUST_CFG0_SCK_LOW_OFFSET); ++ << SPI_CFG2_SCK_LOW_OFFSET); + writel(reg_val, mdata->base + SPI_CFG2_REG); +- reg_val |= (((cs_time - 1) & 0xffff) ++ reg_val = (((cs_time - 1) & 0xffff) + << SPI_ADJUST_CFG0_CS_HOLD_OFFSET); + reg_val |= (((cs_time - 1) & 0xffff) + << SPI_ADJUST_CFG0_CS_SETUP_OFFSET); + writel(reg_val, mdata->base + SPI_CFG0_REG); + } else { +- reg_val |= (((sck_time - 1) & 0xff) ++ reg_val = (((sck_time - 1) & 0xff) + << SPI_CFG0_SCK_HIGH_OFFSET); + reg_val |= (((sck_time - 1) & 0xff) << SPI_CFG0_SCK_LOW_OFFSET); + reg_val |= (((cs_time - 1) & 0xff) << SPI_CFG0_CS_HOLD_OFFSET); +diff --git a/drivers/staging/comedi/drivers/addi_apci_1032.c b/drivers/staging/comedi/drivers/addi_apci_1032.c +index 560649be9d13..e035c9f757a1 100644 +--- a/drivers/staging/comedi/drivers/addi_apci_1032.c ++++ b/drivers/staging/comedi/drivers/addi_apci_1032.c +@@ -106,14 +106,22 @@ static int apci1032_cos_insn_config(struct comedi_device *dev, + unsigned int *data) + { + struct apci1032_private *devpriv = dev->private; +- unsigned int shift, oldmask; ++ unsigned int shift, oldmask, himask, lomask; + + switch (data[0]) { + case INSN_CONFIG_DIGITAL_TRIG: + if (data[1] != 0) + return -EINVAL; + shift = data[3]; +- oldmask = (1U << shift) - 1; ++ if (shift < 32) { ++ oldmask = (1U << shift) - 1; ++ himask = data[4] << shift; ++ lomask = data[5] << shift; ++ } else { ++ oldmask = 0xffffffffu; ++ himask = 0; ++ lomask = 0; ++ } + switch (data[2]) { + case COMEDI_DIGITAL_TRIG_DISABLE: + devpriv->ctrl = 0; +@@ -136,8 +144,8 @@ static int apci1032_cos_insn_config(struct comedi_device *dev, + devpriv->mode2 &= oldmask; + } + /* configure specified channels */ +- devpriv->mode1 |= data[4] << shift; +- devpriv->mode2 |= data[5] << shift; ++ devpriv->mode1 |= himask; ++ devpriv->mode2 |= lomask; + break; + case COMEDI_DIGITAL_TRIG_ENABLE_LEVELS: + if (devpriv->ctrl != (APCI1032_CTRL_INT_ENA | +@@ -154,8 +162,8 @@ static int apci1032_cos_insn_config(struct comedi_device *dev, + devpriv->mode2 &= oldmask; + } + /* configure specified channels */ +- devpriv->mode1 |= data[4] << shift; +- devpriv->mode2 |= data[5] << shift; ++ devpriv->mode1 |= himask; ++ devpriv->mode2 |= lomask; + break; + default: + return -EINVAL; +diff --git a/drivers/staging/comedi/drivers/addi_apci_1500.c b/drivers/staging/comedi/drivers/addi_apci_1500.c +index 689acd69a1b9..816dd25b9d0e 100644 +--- a/drivers/staging/comedi/drivers/addi_apci_1500.c ++++ b/drivers/staging/comedi/drivers/addi_apci_1500.c +@@ -452,13 +452,14 @@ static int apci1500_di_cfg_trig(struct comedi_device *dev, + struct apci1500_private *devpriv = dev->private; + unsigned int trig = data[1]; + unsigned int shift = data[3]; +- unsigned int hi_mask = data[4] << shift; +- unsigned int lo_mask = data[5] << shift; +- unsigned int chan_mask = hi_mask | lo_mask; +- unsigned int old_mask = (1 << shift) - 1; ++ unsigned int hi_mask; ++ unsigned int lo_mask; ++ unsigned int chan_mask; ++ unsigned int old_mask; + unsigned int pm; + unsigned int pt; + unsigned int pp; ++ unsigned int invalid_chan; + + if (trig > 1) { + dev_dbg(dev->class_dev, +@@ -466,7 +467,20 @@ static int apci1500_di_cfg_trig(struct comedi_device *dev, + return -EINVAL; + } + +- if (chan_mask > 0xffff) { ++ if (shift <= 16) { ++ hi_mask = data[4] << shift; ++ lo_mask = data[5] << shift; ++ old_mask = (1U << shift) - 1; ++ invalid_chan = (data[4] | data[5]) >> (16 - shift); ++ } else { ++ hi_mask = 0; ++ lo_mask = 0; ++ old_mask = 0xffff; ++ invalid_chan = data[4] | data[5]; ++ } ++ chan_mask = hi_mask | lo_mask; ++ ++ if (invalid_chan) { + dev_dbg(dev->class_dev, "invalid digital trigger channel\n"); + return -EINVAL; + } +diff --git a/drivers/staging/comedi/drivers/addi_apci_1564.c b/drivers/staging/comedi/drivers/addi_apci_1564.c +index 10501fe6bb25..1268ba34be5f 100644 +--- a/drivers/staging/comedi/drivers/addi_apci_1564.c ++++ b/drivers/staging/comedi/drivers/addi_apci_1564.c +@@ -331,14 +331,22 @@ static int apci1564_cos_insn_config(struct comedi_device *dev, + unsigned int *data) + { + struct apci1564_private *devpriv = dev->private; +- unsigned int shift, oldmask; ++ unsigned int shift, oldmask, himask, lomask; + + switch (data[0]) { + case INSN_CONFIG_DIGITAL_TRIG: + if (data[1] != 0) + return -EINVAL; + shift = data[3]; +- oldmask = (1U << shift) - 1; ++ if (shift < 32) { ++ oldmask = (1U << shift) - 1; ++ himask = data[4] << shift; ++ lomask = data[5] << shift; ++ } else { ++ oldmask = 0xffffffffu; ++ himask = 0; ++ lomask = 0; ++ } + switch (data[2]) { + case COMEDI_DIGITAL_TRIG_DISABLE: + devpriv->ctrl = 0; +@@ -362,8 +370,8 @@ static int apci1564_cos_insn_config(struct comedi_device *dev, + devpriv->mode2 &= oldmask; + } + /* configure specified channels */ +- devpriv->mode1 |= data[4] << shift; +- devpriv->mode2 |= data[5] << shift; ++ devpriv->mode1 |= himask; ++ devpriv->mode2 |= lomask; + break; + case COMEDI_DIGITAL_TRIG_ENABLE_LEVELS: + if (devpriv->ctrl != (APCI1564_DI_IRQ_ENA | +@@ -380,8 +388,8 @@ static int apci1564_cos_insn_config(struct comedi_device *dev, + devpriv->mode2 &= oldmask; + } + /* configure specified channels */ +- devpriv->mode1 |= data[4] << shift; +- devpriv->mode2 |= data[5] << shift; ++ devpriv->mode1 |= himask; ++ devpriv->mode2 |= lomask; + break; + default: + return -EINVAL; +diff --git a/drivers/staging/comedi/drivers/ni_6527.c b/drivers/staging/comedi/drivers/ni_6527.c +index 4d1eccb5041d..4518c2680b7c 100644 +--- a/drivers/staging/comedi/drivers/ni_6527.c ++++ b/drivers/staging/comedi/drivers/ni_6527.c +@@ -332,7 +332,7 @@ static int ni6527_intr_insn_config(struct comedi_device *dev, + case COMEDI_DIGITAL_TRIG_ENABLE_EDGES: + /* check shift amount */ + shift = data[3]; +- if (shift >= s->n_chan) { ++ if (shift >= 32) { + mask = 0; + rising = 0; + falling = 0; +diff --git a/drivers/staging/wlan-ng/prism2usb.c b/drivers/staging/wlan-ng/prism2usb.c +index 4689b2170e4f..456603fd26c0 100644 +--- a/drivers/staging/wlan-ng/prism2usb.c ++++ b/drivers/staging/wlan-ng/prism2usb.c +@@ -61,11 +61,25 @@ static int prism2sta_probe_usb(struct usb_interface *interface, + const struct usb_device_id *id) + { + struct usb_device *dev; +- ++ const struct usb_endpoint_descriptor *epd; ++ const struct usb_host_interface *iface_desc = interface->cur_altsetting; + struct wlandevice *wlandev = NULL; + struct hfa384x *hw = NULL; + int result = 0; + ++ if (iface_desc->desc.bNumEndpoints != 2) { ++ result = -ENODEV; ++ goto failed; ++ } ++ ++ result = -EINVAL; ++ epd = &iface_desc->endpoint[1].desc; ++ if (!usb_endpoint_is_bulk_in(epd)) ++ goto failed; ++ epd = &iface_desc->endpoint[2].desc; ++ if (!usb_endpoint_is_bulk_out(epd)) ++ goto failed; ++ + dev = interface_to_usbdev(interface); + wlandev = create_wlan(); + if (!wlandev) { +diff --git a/drivers/tty/serial/8250/8250_core.c b/drivers/tty/serial/8250/8250_core.c +index 9548d3f8fc8e..c3beee1f580a 100644 +--- a/drivers/tty/serial/8250/8250_core.c ++++ b/drivers/tty/serial/8250/8250_core.c +@@ -524,6 +524,7 @@ static void __init serial8250_isa_init_ports(void) + */ + up->mcr_mask = ~ALPHA_KLUDGE_MCR; + up->mcr_force = ALPHA_KLUDGE_MCR; ++ serial8250_set_defaults(up); + } + + /* chain base port ops to support Remote Supervisor Adapter */ +@@ -547,7 +548,6 @@ static void __init serial8250_isa_init_ports(void) + port->membase = old_serial_port[i].iomem_base; + port->iotype = old_serial_port[i].io_type; + port->regshift = old_serial_port[i].iomem_reg_shift; +- serial8250_set_defaults(up); + + port->irqflags |= irqflag; + if (serial8250_isa_config != NULL) +diff --git a/drivers/tty/serial/8250/8250_exar.c b/drivers/tty/serial/8250/8250_exar.c +index 59449b6500cd..9b5da1d43332 100644 +--- a/drivers/tty/serial/8250/8250_exar.c ++++ b/drivers/tty/serial/8250/8250_exar.c +@@ -326,7 +326,17 @@ static void setup_gpio(struct pci_dev *pcidev, u8 __iomem *p) + * devices will export them as GPIOs, so we pre-configure them safely + * as inputs. + */ +- u8 dir = pcidev->vendor == PCI_VENDOR_ID_EXAR ? 0xff : 0x00; ++ ++ u8 dir = 0x00; ++ ++ if ((pcidev->vendor == PCI_VENDOR_ID_EXAR) && ++ (pcidev->subsystem_vendor != PCI_VENDOR_ID_SEALEVEL)) { ++ // Configure GPIO as inputs for Commtech adapters ++ dir = 0xff; ++ } else { ++ // Configure GPIO as outputs for SeaLevel adapters ++ dir = 0x00; ++ } + + writeb(0x00, p + UART_EXAR_MPIOINT_7_0); + writeb(0x00, p + UART_EXAR_MPIOLVL_7_0); +diff --git a/drivers/tty/serial/8250/8250_mtk.c b/drivers/tty/serial/8250/8250_mtk.c +index f839380c2f4c..98b8a3e30733 100644 +--- a/drivers/tty/serial/8250/8250_mtk.c ++++ b/drivers/tty/serial/8250/8250_mtk.c +@@ -306,8 +306,21 @@ mtk8250_set_termios(struct uart_port *port, struct ktermios *termios, + } + #endif + ++ /* ++ * Store the requested baud rate before calling the generic 8250 ++ * set_termios method. Standard 8250 port expects bauds to be ++ * no higher than (uartclk / 16) so the baud will be clamped if it ++ * gets out of that bound. Mediatek 8250 port supports speed ++ * higher than that, therefore we'll get original baud rate back ++ * after calling the generic set_termios method and recalculate ++ * the speed later in this method. ++ */ ++ baud = tty_termios_baud_rate(termios); ++ + serial8250_do_set_termios(port, termios, old); + ++ tty_termios_encode_baud_rate(termios, baud, baud); ++ + /* + * Mediatek UARTs use an extra highspeed register (MTK_UART_HIGHS) + * +@@ -339,6 +352,11 @@ mtk8250_set_termios(struct uart_port *port, struct ktermios *termios, + */ + spin_lock_irqsave(&port->lock, flags); + ++ /* ++ * Update the per-port timeout. ++ */ ++ uart_update_timeout(port, termios->c_cflag, baud); ++ + /* set DLAB we have cval saved in up->lcr from the call to the core */ + serial_port_out(port, UART_LCR, up->lcr | UART_LCR_DLAB); + serial_dl_write(up, quot); +diff --git a/drivers/tty/serial/serial-tegra.c b/drivers/tty/serial/serial-tegra.c +index 8de8bac9c6c7..b3bbee6b6702 100644 +--- a/drivers/tty/serial/serial-tegra.c ++++ b/drivers/tty/serial/serial-tegra.c +@@ -653,11 +653,14 @@ static void tegra_uart_handle_rx_pio(struct tegra_uart_port *tup, + ch = (unsigned char) tegra_uart_read(tup, UART_RX); + tup->uport.icount.rx++; + +- if (!uart_handle_sysrq_char(&tup->uport, ch) && tty) +- tty_insert_flip_char(tty, ch, flag); ++ if (uart_handle_sysrq_char(&tup->uport, ch)) ++ continue; + + if (tup->uport.ignore_status_mask & UART_LSR_DR) + continue; ++ ++ if (tty) ++ tty_insert_flip_char(tty, ch, flag); + } while (1); + } + +diff --git a/drivers/tty/serial/xilinx_uartps.c b/drivers/tty/serial/xilinx_uartps.c +index ac137b6a1dc1..56e108902502 100644 +--- a/drivers/tty/serial/xilinx_uartps.c ++++ b/drivers/tty/serial/xilinx_uartps.c +@@ -1574,8 +1574,10 @@ static int cdns_uart_probe(struct platform_device *pdev) + * If register_console() don't assign value, then console_port pointer + * is cleanup. + */ +- if (!console_port) ++ if (!console_port) { ++ cdns_uart_console.index = id; + console_port = port; ++ } + #endif + + rc = uart_add_one_port(&cdns_uart_uart_driver, port); +@@ -1588,8 +1590,10 @@ static int cdns_uart_probe(struct platform_device *pdev) + #ifdef CONFIG_SERIAL_XILINX_PS_UART_CONSOLE + /* This is not port which is used for console that's why clean it up */ + if (console_port == port && +- !(cdns_uart_uart_driver.cons->flags & CON_ENABLED)) ++ !(cdns_uart_uart_driver.cons->flags & CON_ENABLED)) { + console_port = NULL; ++ cdns_uart_console.index = -1; ++ } + #endif + + cdns_uart_data->cts_override = of_property_read_bool(pdev->dev.of_node, +diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c +index 48a8199f7845..42d8c67a481f 100644 +--- a/drivers/tty/vt/vt.c ++++ b/drivers/tty/vt/vt.c +@@ -1092,10 +1092,19 @@ static const struct tty_port_operations vc_port_ops = { + .destruct = vc_port_destruct, + }; + ++/* ++ * Change # of rows and columns (0 means unchanged/the size of fg_console) ++ * [this is to be used together with some user program ++ * like resize that changes the hardware videomode] ++ */ ++#define VC_MAXCOL (32767) ++#define VC_MAXROW (32767) ++ + int vc_allocate(unsigned int currcons) /* return 0 on success */ + { + struct vt_notifier_param param; + struct vc_data *vc; ++ int err; + + WARN_CONSOLE_UNLOCKED(); + +@@ -1125,6 +1134,11 @@ int vc_allocate(unsigned int currcons) /* return 0 on success */ + if (!*vc->vc_uni_pagedir_loc) + con_set_default_unimap(vc); + ++ err = -EINVAL; ++ if (vc->vc_cols > VC_MAXCOL || vc->vc_rows > VC_MAXROW || ++ vc->vc_screenbuf_size > KMALLOC_MAX_SIZE || !vc->vc_screenbuf_size) ++ goto err_free; ++ err = -ENOMEM; + vc->vc_screenbuf = kzalloc(vc->vc_screenbuf_size, GFP_KERNEL); + if (!vc->vc_screenbuf) + goto err_free; +@@ -1143,7 +1157,7 @@ err_free: + visual_deinit(vc); + kfree(vc); + vc_cons[currcons].d = NULL; +- return -ENOMEM; ++ return err; + } + + static inline int resize_screen(struct vc_data *vc, int width, int height, +@@ -1158,14 +1172,6 @@ static inline int resize_screen(struct vc_data *vc, int width, int height, + return err; + } + +-/* +- * Change # of rows and columns (0 means unchanged/the size of fg_console) +- * [this is to be used together with some user program +- * like resize that changes the hardware videomode] +- */ +-#define VC_RESIZE_MAXCOL (32767) +-#define VC_RESIZE_MAXROW (32767) +- + /** + * vc_do_resize - resizing method for the tty + * @tty: tty being resized +@@ -1201,7 +1207,7 @@ static int vc_do_resize(struct tty_struct *tty, struct vc_data *vc, + user = vc->vc_resize_user; + vc->vc_resize_user = 0; + +- if (cols > VC_RESIZE_MAXCOL || lines > VC_RESIZE_MAXROW) ++ if (cols > VC_MAXCOL || lines > VC_MAXROW) + return -EINVAL; + + new_cols = (cols ? cols : vc->vc_cols); +@@ -1212,7 +1218,7 @@ static int vc_do_resize(struct tty_struct *tty, struct vc_data *vc, + if (new_cols == vc->vc_cols && new_rows == vc->vc_rows) + return 0; + +- if (new_screen_size > KMALLOC_MAX_SIZE) ++ if (new_screen_size > KMALLOC_MAX_SIZE || !new_screen_size) + return -EINVAL; + newscreen = kzalloc(new_screen_size, GFP_USER); + if (!newscreen) +@@ -3393,6 +3399,7 @@ static int __init con_init(void) + INIT_WORK(&vc_cons[currcons].SAK_work, vc_SAK); + tty_port_init(&vc->port); + visual_init(vc, currcons, 1); ++ /* Assuming vc->vc_{cols,rows,screenbuf_size} are sane here. */ + vc->vc_screenbuf = kzalloc(vc->vc_screenbuf_size, GFP_NOWAIT); + vc_init(vc, vc->vc_rows, vc->vc_cols, + currcons || !vc->vc_sw->con_save_screen); +diff --git a/drivers/usb/cdns3/ep0.c b/drivers/usb/cdns3/ep0.c +index da4c5eb03d7e..666cebd9c5f2 100644 +--- a/drivers/usb/cdns3/ep0.c ++++ b/drivers/usb/cdns3/ep0.c +@@ -37,18 +37,18 @@ static void cdns3_ep0_run_transfer(struct cdns3_device *priv_dev, + struct cdns3_usb_regs __iomem *regs = priv_dev->regs; + struct cdns3_endpoint *priv_ep = priv_dev->eps[0]; + +- priv_ep->trb_pool[0].buffer = TRB_BUFFER(dma_addr); +- priv_ep->trb_pool[0].length = TRB_LEN(length); ++ priv_ep->trb_pool[0].buffer = cpu_to_le32(TRB_BUFFER(dma_addr)); ++ priv_ep->trb_pool[0].length = cpu_to_le32(TRB_LEN(length)); + + if (zlp) { +- priv_ep->trb_pool[0].control = TRB_CYCLE | TRB_TYPE(TRB_NORMAL); +- priv_ep->trb_pool[1].buffer = TRB_BUFFER(dma_addr); +- priv_ep->trb_pool[1].length = TRB_LEN(0); +- priv_ep->trb_pool[1].control = TRB_CYCLE | TRB_IOC | +- TRB_TYPE(TRB_NORMAL); ++ priv_ep->trb_pool[0].control = cpu_to_le32(TRB_CYCLE | TRB_TYPE(TRB_NORMAL)); ++ priv_ep->trb_pool[1].buffer = cpu_to_le32(TRB_BUFFER(dma_addr)); ++ priv_ep->trb_pool[1].length = cpu_to_le32(TRB_LEN(0)); ++ priv_ep->trb_pool[1].control = cpu_to_le32(TRB_CYCLE | TRB_IOC | ++ TRB_TYPE(TRB_NORMAL)); + } else { +- priv_ep->trb_pool[0].control = TRB_CYCLE | TRB_IOC | +- TRB_TYPE(TRB_NORMAL); ++ priv_ep->trb_pool[0].control = cpu_to_le32(TRB_CYCLE | TRB_IOC | ++ TRB_TYPE(TRB_NORMAL)); + priv_ep->trb_pool[1].control = 0; + } + +@@ -264,11 +264,11 @@ static int cdns3_req_ep0_get_status(struct cdns3_device *priv_dev, + case USB_RECIP_INTERFACE: + return cdns3_ep0_delegate_req(priv_dev, ctrl); + case USB_RECIP_ENDPOINT: +- index = cdns3_ep_addr_to_index(ctrl->wIndex); ++ index = cdns3_ep_addr_to_index(le16_to_cpu(ctrl->wIndex)); + priv_ep = priv_dev->eps[index]; + + /* check if endpoint is stalled or stall is pending */ +- cdns3_select_ep(priv_dev, ctrl->wIndex); ++ cdns3_select_ep(priv_dev, le16_to_cpu(ctrl->wIndex)); + if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)) || + (priv_ep->flags & EP_STALL_PENDING)) + usb_status = BIT(USB_ENDPOINT_HALT); +@@ -388,10 +388,10 @@ static int cdns3_ep0_feature_handle_endpoint(struct cdns3_device *priv_dev, + if (!(ctrl->wIndex & ~USB_DIR_IN)) + return 0; + +- index = cdns3_ep_addr_to_index(ctrl->wIndex); ++ index = cdns3_ep_addr_to_index(le16_to_cpu(ctrl->wIndex)); + priv_ep = priv_dev->eps[index]; + +- cdns3_select_ep(priv_dev, ctrl->wIndex); ++ cdns3_select_ep(priv_dev, le16_to_cpu(ctrl->wIndex)); + + if (set) + __cdns3_gadget_ep_set_halt(priv_ep); +@@ -452,7 +452,7 @@ static int cdns3_req_ep0_set_sel(struct cdns3_device *priv_dev, + if (priv_dev->gadget.state < USB_STATE_ADDRESS) + return -EINVAL; + +- if (ctrl_req->wLength != 6) { ++ if (le16_to_cpu(ctrl_req->wLength) != 6) { + dev_err(priv_dev->dev, "Set SEL should be 6 bytes, got %d\n", + ctrl_req->wLength); + return -EINVAL; +@@ -476,7 +476,7 @@ static int cdns3_req_ep0_set_isoch_delay(struct cdns3_device *priv_dev, + if (ctrl_req->wIndex || ctrl_req->wLength) + return -EINVAL; + +- priv_dev->isoch_delay = ctrl_req->wValue; ++ priv_dev->isoch_delay = le16_to_cpu(ctrl_req->wValue); + + return 0; + } +diff --git a/drivers/usb/cdns3/trace.h b/drivers/usb/cdns3/trace.h +index 755c56582257..0a2a3269bfac 100644 +--- a/drivers/usb/cdns3/trace.h ++++ b/drivers/usb/cdns3/trace.h +@@ -404,9 +404,9 @@ DECLARE_EVENT_CLASS(cdns3_log_trb, + TP_fast_assign( + __assign_str(name, priv_ep->name); + __entry->trb = trb; +- __entry->buffer = trb->buffer; +- __entry->length = trb->length; +- __entry->control = trb->control; ++ __entry->buffer = le32_to_cpu(trb->buffer); ++ __entry->length = le32_to_cpu(trb->length); ++ __entry->control = le32_to_cpu(trb->control); + __entry->type = usb_endpoint_type(priv_ep->endpoint.desc); + __entry->last_stream_id = priv_ep->last_stream_id; + ), +diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c +index 96c05b121fac..139474c3e77b 100644 +--- a/drivers/usb/dwc3/dwc3-pci.c ++++ b/drivers/usb/dwc3/dwc3-pci.c +@@ -38,6 +38,8 @@ + #define PCI_DEVICE_ID_INTEL_ICLLP 0x34ee + #define PCI_DEVICE_ID_INTEL_EHLLP 0x4b7e + #define PCI_DEVICE_ID_INTEL_TGPLP 0xa0ee ++#define PCI_DEVICE_ID_INTEL_TGPH 0x43ee ++#define PCI_DEVICE_ID_INTEL_JSP 0x4dee + + #define PCI_INTEL_BXT_DSM_GUID "732b85d5-b7a7-4a1b-9ba0-4bbd00ffd511" + #define PCI_INTEL_BXT_FUNC_PMU_PWR 4 +@@ -358,6 +360,12 @@ static const struct pci_device_id dwc3_pci_id_table[] = { + { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_TGPLP), + (kernel_ulong_t) &dwc3_pci_intel_properties, }, + ++ { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_TGPH), ++ (kernel_ulong_t) &dwc3_pci_intel_properties, }, ++ ++ { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_JSP), ++ (kernel_ulong_t) &dwc3_pci_intel_properties, }, ++ + { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_NL_USB), + (kernel_ulong_t) &dwc3_pci_amd_properties, }, + { } /* Terminating Entry */ +diff --git a/drivers/usb/gadget/udc/gr_udc.c b/drivers/usb/gadget/udc/gr_udc.c +index aaf975c809bf..ecf874dee996 100644 +--- a/drivers/usb/gadget/udc/gr_udc.c ++++ b/drivers/usb/gadget/udc/gr_udc.c +@@ -1981,9 +1981,12 @@ static int gr_ep_init(struct gr_udc *dev, int num, int is_in, u32 maxplimit) + + if (num == 0) { + _req = gr_alloc_request(&ep->ep, GFP_ATOMIC); ++ if (!_req) ++ return -ENOMEM; ++ + buf = devm_kzalloc(dev->dev, PAGE_SIZE, GFP_DMA | GFP_ATOMIC); +- if (!_req || !buf) { +- /* possible _req freed by gr_probe via gr_remove */ ++ if (!buf) { ++ gr_free_request(&ep->ep, _req); + return -ENOMEM; + } + +diff --git a/drivers/usb/host/xhci-mtk-sch.c b/drivers/usb/host/xhci-mtk-sch.c +index fea555570ad4..45c54d56ecbd 100644 +--- a/drivers/usb/host/xhci-mtk-sch.c ++++ b/drivers/usb/host/xhci-mtk-sch.c +@@ -557,6 +557,10 @@ static bool need_bw_sch(struct usb_host_endpoint *ep, + if (is_fs_or_ls(speed) && !has_tt) + return false; + ++ /* skip endpoint with zero maxpkt */ ++ if (usb_endpoint_maxp(&ep->desc) == 0) ++ return false; ++ + return true; + } + +diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c +index 766b74723e64..51251c1be059 100644 +--- a/drivers/usb/host/xhci-pci.c ++++ b/drivers/usb/host/xhci-pci.c +@@ -255,6 +255,9 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci) + if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA && + pdev->device == 0x1142) + xhci->quirks |= XHCI_TRUST_TX_LENGTH; ++ if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA && ++ pdev->device == 0x2142) ++ xhci->quirks |= XHCI_NO_64BIT_SUPPORT; + + if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA && + pdev->device == PCI_DEVICE_ID_ASMEDIA_1042A_XHCI) +diff --git a/drivers/usb/host/xhci-tegra.c b/drivers/usb/host/xhci-tegra.c +index 2eaf5c0af80c..ee6bf01775bb 100644 +--- a/drivers/usb/host/xhci-tegra.c ++++ b/drivers/usb/host/xhci-tegra.c +@@ -856,7 +856,7 @@ static int tegra_xusb_init_context(struct tegra_xusb *tegra) + if (!tegra->context.ipfs) + return -ENOMEM; + +- tegra->context.fpci = devm_kcalloc(tegra->dev, soc->ipfs.num_offsets, ++ tegra->context.fpci = devm_kcalloc(tegra->dev, soc->fpci.num_offsets, + sizeof(u32), GFP_KERNEL); + if (!tegra->context.fpci) + return -ENOMEM; +diff --git a/drivers/video/fbdev/core/bitblit.c b/drivers/video/fbdev/core/bitblit.c +index ca935c09a261..35ebeeccde4d 100644 +--- a/drivers/video/fbdev/core/bitblit.c ++++ b/drivers/video/fbdev/core/bitblit.c +@@ -216,7 +216,7 @@ static void bit_clear_margins(struct vc_data *vc, struct fb_info *info, + region.color = color; + region.rop = ROP_COPY; + +- if (rw && !bottom_only) { ++ if ((int) rw > 0 && !bottom_only) { + region.dx = info->var.xoffset + rs; + region.dy = 0; + region.width = rw; +@@ -224,7 +224,7 @@ static void bit_clear_margins(struct vc_data *vc, struct fb_info *info, + info->fbops->fb_fillrect(info, ®ion); + } + +- if (bh) { ++ if ((int) bh > 0) { + region.dx = info->var.xoffset; + region.dy = info->var.yoffset + bs; + region.width = rs; +diff --git a/drivers/video/fbdev/core/fbcon_ccw.c b/drivers/video/fbdev/core/fbcon_ccw.c +index dfa9a8aa4509..78f3a5621478 100644 +--- a/drivers/video/fbdev/core/fbcon_ccw.c ++++ b/drivers/video/fbdev/core/fbcon_ccw.c +@@ -201,7 +201,7 @@ static void ccw_clear_margins(struct vc_data *vc, struct fb_info *info, + region.color = color; + region.rop = ROP_COPY; + +- if (rw && !bottom_only) { ++ if ((int) rw > 0 && !bottom_only) { + region.dx = 0; + region.dy = info->var.yoffset; + region.height = rw; +@@ -209,7 +209,7 @@ static void ccw_clear_margins(struct vc_data *vc, struct fb_info *info, + info->fbops->fb_fillrect(info, ®ion); + } + +- if (bh) { ++ if ((int) bh > 0) { + region.dx = info->var.xoffset + bs; + region.dy = 0; + region.height = info->var.yres_virtual; +diff --git a/drivers/video/fbdev/core/fbcon_cw.c b/drivers/video/fbdev/core/fbcon_cw.c +index ce08251bfd38..fd098ff17574 100644 +--- a/drivers/video/fbdev/core/fbcon_cw.c ++++ b/drivers/video/fbdev/core/fbcon_cw.c +@@ -184,7 +184,7 @@ static void cw_clear_margins(struct vc_data *vc, struct fb_info *info, + region.color = color; + region.rop = ROP_COPY; + +- if (rw && !bottom_only) { ++ if ((int) rw > 0 && !bottom_only) { + region.dx = 0; + region.dy = info->var.yoffset + rs; + region.height = rw; +@@ -192,7 +192,7 @@ static void cw_clear_margins(struct vc_data *vc, struct fb_info *info, + info->fbops->fb_fillrect(info, ®ion); + } + +- if (bh) { ++ if ((int) bh > 0) { + region.dx = info->var.xoffset; + region.dy = info->var.yoffset; + region.height = info->var.yres; +diff --git a/drivers/video/fbdev/core/fbcon_ud.c b/drivers/video/fbdev/core/fbcon_ud.c +index 1936afc78fec..e165a3fad29a 100644 +--- a/drivers/video/fbdev/core/fbcon_ud.c ++++ b/drivers/video/fbdev/core/fbcon_ud.c +@@ -231,7 +231,7 @@ static void ud_clear_margins(struct vc_data *vc, struct fb_info *info, + region.color = color; + region.rop = ROP_COPY; + +- if (rw && !bottom_only) { ++ if ((int) rw > 0 && !bottom_only) { + region.dy = 0; + region.dx = info->var.xoffset; + region.width = rw; +@@ -239,7 +239,7 @@ static void ud_clear_margins(struct vc_data *vc, struct fb_info *info, + info->fbops->fb_fillrect(info, ®ion); + } + +- if (bh) { ++ if ((int) bh > 0) { + region.dy = info->var.yoffset; + region.dx = info->var.xoffset; + region.height = bh; +diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c +index 0cc02577577b..ae5cb94ef191 100644 +--- a/fs/btrfs/backref.c ++++ b/fs/btrfs/backref.c +@@ -1465,6 +1465,7 @@ static int btrfs_find_all_roots_safe(struct btrfs_trans_handle *trans, + if (ret < 0 && ret != -ENOENT) { + ulist_free(tmp); + ulist_free(*roots); ++ *roots = NULL; + return ret; + } + node = ulist_next(tmp, &uiter); +diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c +index f71e4dbe1d8a..f00e64fee5dd 100644 +--- a/fs/btrfs/disk-io.c ++++ b/fs/btrfs/disk-io.c +@@ -1998,6 +1998,7 @@ void btrfs_put_root(struct btrfs_root *root) + + if (refcount_dec_and_test(&root->refs)) { + WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree)); ++ WARN_ON(test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state)); + if (root->anon_dev) + free_anon_bdev(root->anon_dev); + btrfs_drew_lock_destroy(&root->snapshot_lock); +diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c +index 6e17a92869ad..79196eb1a1b3 100644 +--- a/fs/btrfs/extent_io.c ++++ b/fs/btrfs/extent_io.c +@@ -1999,7 +1999,8 @@ static int __process_pages_contig(struct address_space *mapping, + if (!PageDirty(pages[i]) || + pages[i]->mapping != mapping) { + unlock_page(pages[i]); +- put_page(pages[i]); ++ for (; i < ret; i++) ++ put_page(pages[i]); + err = -EAGAIN; + goto out; + } +diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c +index 157452a5e110..f67d736c27a1 100644 +--- a/fs/btrfs/relocation.c ++++ b/fs/btrfs/relocation.c +@@ -2642,6 +2642,8 @@ again: + root->reloc_root = NULL; + btrfs_put_root(reloc_root); + } ++ clear_bit(BTRFS_ROOT_DEAD_RELOC_TREE, ++ &root->state); + btrfs_put_root(root); + } + +diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c +index 21c7d3d87827..45cf455f906d 100644 +--- a/fs/btrfs/volumes.c ++++ b/fs/btrfs/volumes.c +@@ -7055,6 +7055,14 @@ int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info) + mutex_lock(&uuid_mutex); + mutex_lock(&fs_info->chunk_mutex); + ++ /* ++ * It is possible for mount and umount to race in such a way that ++ * we execute this code path, but open_fs_devices failed to clear ++ * total_rw_bytes. We certainly want it cleared before reading the ++ * device items, so clear it here. ++ */ ++ fs_info->fs_devices->total_rw_bytes = 0; ++ + /* + * Read all device items, and then all the chunk items. All + * device items are found before any chunk item (their object id +diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c +index 44a57b65915b..15f2cdc71ac9 100644 +--- a/fs/cifs/inode.c ++++ b/fs/cifs/inode.c +@@ -1855,7 +1855,6 @@ cifs_rename2(struct inode *source_dir, struct dentry *source_dentry, + FILE_UNIX_BASIC_INFO *info_buf_target; + unsigned int xid; + int rc, tmprc; +- bool new_target = d_really_is_negative(target_dentry); + + if (flags & ~RENAME_NOREPLACE) + return -EINVAL; +@@ -1932,13 +1931,8 @@ cifs_rename2(struct inode *source_dir, struct dentry *source_dentry, + */ + + unlink_target: +- /* +- * If the target dentry was created during the rename, try +- * unlinking it if it's not negative +- */ +- if (new_target && +- d_really_is_positive(target_dentry) && +- (rc == -EACCES || rc == -EEXIST)) { ++ /* Try unlinking the target dentry if it's not negative */ ++ if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) { + if (d_is_dir(target_dentry)) + tmprc = cifs_rmdir(target_dir, target_dentry); + else +diff --git a/fs/efivarfs/super.c b/fs/efivarfs/super.c +index 12c66f5d92dd..28bb5689333a 100644 +--- a/fs/efivarfs/super.c ++++ b/fs/efivarfs/super.c +@@ -201,6 +201,9 @@ static int efivarfs_fill_super(struct super_block *sb, struct fs_context *fc) + sb->s_d_op = &efivarfs_d_ops; + sb->s_time_gran = 1; + ++ if (!efivar_supports_writes()) ++ sb->s_flags |= SB_RDONLY; ++ + inode = efivarfs_get_inode(sb, NULL, S_IFDIR | 0755, 0, true); + if (!inode) + return -ENOMEM; +@@ -252,9 +255,6 @@ static struct file_system_type efivarfs_type = { + + static __init int efivarfs_init(void) + { +- if (!efi_rt_services_supported(EFI_RT_SUPPORTED_VARIABLE_SERVICES)) +- return -ENODEV; +- + if (!efivars_kobject()) + return -ENODEV; + +diff --git a/fs/exfat/dir.c b/fs/exfat/dir.c +index 6db302d76d4c..0c244eb706bd 100644 +--- a/fs/exfat/dir.c ++++ b/fs/exfat/dir.c +@@ -1160,7 +1160,7 @@ found: + ret = exfat_get_next_cluster(sb, &clu.dir); + } + +- if (ret || clu.dir != EXFAT_EOF_CLUSTER) { ++ if (ret || clu.dir == EXFAT_EOF_CLUSTER) { + /* just initialized hint_stat */ + hint_stat->clu = p_dir->dir; + hint_stat->eidx = 0; +diff --git a/fs/exfat/exfat_fs.h b/fs/exfat/exfat_fs.h +index d865050fa6cd..99e9baf2d31d 100644 +--- a/fs/exfat/exfat_fs.h ++++ b/fs/exfat/exfat_fs.h +@@ -375,7 +375,7 @@ static inline bool exfat_is_last_sector_in_cluster(struct exfat_sb_info *sbi, + static inline sector_t exfat_cluster_to_sector(struct exfat_sb_info *sbi, + unsigned int clus) + { +- return ((clus - EXFAT_RESERVED_CLUSTERS) << sbi->sect_per_clus_bits) + ++ return ((sector_t)(clus - EXFAT_RESERVED_CLUSTERS) << sbi->sect_per_clus_bits) + + sbi->data_start_sector; + } + +diff --git a/fs/exfat/file.c b/fs/exfat/file.c +index b93aa9e6cb16..04278f3c0adf 100644 +--- a/fs/exfat/file.c ++++ b/fs/exfat/file.c +@@ -175,7 +175,7 @@ int __exfat_truncate(struct inode *inode, loff_t new_size) + ep2->dentry.stream.size = 0; + } else { + ep2->dentry.stream.valid_size = cpu_to_le64(new_size); +- ep2->dentry.stream.size = ep->dentry.stream.valid_size; ++ ep2->dentry.stream.size = ep2->dentry.stream.valid_size; + } + + if (new_size == 0) { +diff --git a/fs/exfat/nls.c b/fs/exfat/nls.c +index 6d1c3ae130ff..a647f8127f3b 100644 +--- a/fs/exfat/nls.c ++++ b/fs/exfat/nls.c +@@ -495,7 +495,7 @@ static int exfat_utf8_to_utf16(struct super_block *sb, + struct exfat_uni_name *p_uniname, int *p_lossy) + { + int i, unilen, lossy = NLS_NAME_NO_LOSSY; +- unsigned short upname[MAX_NAME_LENGTH + 1]; ++ __le16 upname[MAX_NAME_LENGTH + 1]; + unsigned short *uniname = p_uniname->name; + + WARN_ON(!len); +@@ -523,7 +523,7 @@ static int exfat_utf8_to_utf16(struct super_block *sb, + exfat_wstrchr(bad_uni_chars, *uniname)) + lossy |= NLS_NAME_LOSSY; + +- upname[i] = exfat_toupper(sb, *uniname); ++ upname[i] = cpu_to_le16(exfat_toupper(sb, *uniname)); + uniname++; + } + +@@ -614,7 +614,7 @@ static int exfat_nls_to_ucs2(struct super_block *sb, + struct exfat_uni_name *p_uniname, int *p_lossy) + { + int i = 0, unilen = 0, lossy = NLS_NAME_NO_LOSSY; +- unsigned short upname[MAX_NAME_LENGTH + 1]; ++ __le16 upname[MAX_NAME_LENGTH + 1]; + unsigned short *uniname = p_uniname->name; + struct nls_table *nls = EXFAT_SB(sb)->nls_io; + +@@ -628,7 +628,7 @@ static int exfat_nls_to_ucs2(struct super_block *sb, + exfat_wstrchr(bad_uni_chars, *uniname)) + lossy |= NLS_NAME_LOSSY; + +- upname[unilen] = exfat_toupper(sb, *uniname); ++ upname[unilen] = cpu_to_le16(exfat_toupper(sb, *uniname)); + uniname++; + unilen++; + } +diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c +index 5c155437a455..ec02c3240176 100644 +--- a/fs/fuse/dev.c ++++ b/fs/fuse/dev.c +@@ -771,7 +771,8 @@ static int fuse_check_page(struct page *page) + 1 << PG_uptodate | + 1 << PG_lru | + 1 << PG_active | +- 1 << PG_reclaim))) { ++ 1 << PG_reclaim | ++ 1 << PG_waiters))) { + pr_warn("trying to steal weird page\n"); + pr_warn(" page=%p index=%li flags=%08lx, count=%i, mapcount=%i, mapping=%p\n", page, page->index, page->flags, page_count(page), page_mapcount(page), page->mapping); + return 1; +diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c +index f0c3f0123131..d49b1d197908 100644 +--- a/fs/nfs/direct.c ++++ b/fs/nfs/direct.c +@@ -267,6 +267,8 @@ static void nfs_direct_complete(struct nfs_direct_req *dreq) + { + struct inode *inode = dreq->inode; + ++ inode_dio_end(inode); ++ + if (dreq->iocb) { + long res = (long) dreq->error; + if (dreq->count != 0) { +@@ -278,10 +280,7 @@ static void nfs_direct_complete(struct nfs_direct_req *dreq) + + complete(&dreq->completion); + +- igrab(inode); + nfs_direct_req_release(dreq); +- inode_dio_end(inode); +- iput(inode); + } + + static void nfs_direct_read_completion(struct nfs_pgio_header *hdr) +@@ -411,10 +410,8 @@ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq, + * generic layer handle the completion. + */ + if (requested_bytes == 0) { +- igrab(inode); +- nfs_direct_req_release(dreq); + inode_dio_end(inode); +- iput(inode); ++ nfs_direct_req_release(dreq); + return result < 0 ? result : -EIO; + } + +@@ -867,10 +864,8 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq, + * generic layer handle the completion. + */ + if (requested_bytes == 0) { +- igrab(inode); +- nfs_direct_req_release(dreq); + inode_dio_end(inode); +- iput(inode); ++ nfs_direct_req_release(dreq); + return result < 0 ? result : -EIO; + } + +diff --git a/fs/nfs/file.c b/fs/nfs/file.c +index ccd6c1637b27..f96367a2463e 100644 +--- a/fs/nfs/file.c ++++ b/fs/nfs/file.c +@@ -83,7 +83,6 @@ nfs_file_release(struct inode *inode, struct file *filp) + dprintk("NFS: release(%pD2)\n", filp); + + nfs_inc_stats(inode, NFSIOS_VFSRELEASE); +- inode_dio_wait(inode); + nfs_file_clear_open_context(filp); + return 0; + } +diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c +index bdfae3ba3953..0a201bb074b0 100644 +--- a/fs/nfsd/nfs4state.c ++++ b/fs/nfsd/nfs4state.c +@@ -509,6 +509,17 @@ find_any_file(struct nfs4_file *f) + return ret; + } + ++static struct nfsd_file *find_deleg_file(struct nfs4_file *f) ++{ ++ struct nfsd_file *ret = NULL; ++ ++ spin_lock(&f->fi_lock); ++ if (f->fi_deleg_file) ++ ret = nfsd_file_get(f->fi_deleg_file); ++ spin_unlock(&f->fi_lock); ++ return ret; ++} ++ + static atomic_long_t num_delegations; + unsigned long max_delegations; + +@@ -2436,6 +2447,8 @@ static int nfs4_show_open(struct seq_file *s, struct nfs4_stid *st) + oo = ols->st_stateowner; + nf = st->sc_file; + file = find_any_file(nf); ++ if (!file) ++ return 0; + + seq_printf(s, "- 0x%16phN: { type: open, ", &st->sc_stateid); + +@@ -2469,6 +2482,8 @@ static int nfs4_show_lock(struct seq_file *s, struct nfs4_stid *st) + oo = ols->st_stateowner; + nf = st->sc_file; + file = find_any_file(nf); ++ if (!file) ++ return 0; + + seq_printf(s, "- 0x%16phN: { type: lock, ", &st->sc_stateid); + +@@ -2497,7 +2512,9 @@ static int nfs4_show_deleg(struct seq_file *s, struct nfs4_stid *st) + + ds = delegstateid(st); + nf = st->sc_file; +- file = nf->fi_deleg_file; ++ file = find_deleg_file(nf); ++ if (!file) ++ return 0; + + seq_printf(s, "- 0x%16phN: { type: deleg, ", &st->sc_stateid); + +@@ -2509,6 +2526,7 @@ static int nfs4_show_deleg(struct seq_file *s, struct nfs4_stid *st) + + nfs4_show_superblock(s, file); + seq_printf(s, " }\n"); ++ nfsd_file_put(file); + + return 0; + } +diff --git a/include/asm-generic/mmiowb.h b/include/asm-generic/mmiowb.h +index 9439ff037b2d..5698fca3bf56 100644 +--- a/include/asm-generic/mmiowb.h ++++ b/include/asm-generic/mmiowb.h +@@ -27,7 +27,7 @@ + #include <asm/smp.h> + + DECLARE_PER_CPU(struct mmiowb_state, __mmiowb_state); +-#define __mmiowb_state() this_cpu_ptr(&__mmiowb_state) ++#define __mmiowb_state() raw_cpu_ptr(&__mmiowb_state) + #else + #define __mmiowb_state() arch_mmiowb_state() + #endif /* arch_mmiowb_state */ +@@ -35,7 +35,9 @@ DECLARE_PER_CPU(struct mmiowb_state, __mmiowb_state); + static inline void mmiowb_set_pending(void) + { + struct mmiowb_state *ms = __mmiowb_state(); +- ms->mmiowb_pending = ms->nesting_count; ++ ++ if (likely(ms->nesting_count)) ++ ms->mmiowb_pending = ms->nesting_count; + } + + static inline void mmiowb_spin_lock(void) +diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h +index 71e387a5fe90..dc29044d3ed9 100644 +--- a/include/asm-generic/vmlinux.lds.h ++++ b/include/asm-generic/vmlinux.lds.h +@@ -341,7 +341,8 @@ + + #define PAGE_ALIGNED_DATA(page_align) \ + . = ALIGN(page_align); \ +- *(.data..page_aligned) ++ *(.data..page_aligned) \ ++ . = ALIGN(page_align); + + #define READ_MOSTLY_DATA(align) \ + . = ALIGN(align); \ +@@ -727,7 +728,9 @@ + . = ALIGN(bss_align); \ + .bss : AT(ADDR(.bss) - LOAD_OFFSET) { \ + BSS_FIRST_SECTIONS \ ++ . = ALIGN(PAGE_SIZE); \ + *(.bss..page_aligned) \ ++ . = ALIGN(PAGE_SIZE); \ + *(.dynbss) \ + *(BSS_MAIN) \ + *(COMMON) \ +diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h +index af48d9da3916..2d84ca74cc74 100644 +--- a/include/linux/device-mapper.h ++++ b/include/linux/device-mapper.h +@@ -424,6 +424,7 @@ const char *dm_device_name(struct mapped_device *md); + int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid); + struct gendisk *dm_disk(struct mapped_device *md); + int dm_suspended(struct dm_target *ti); ++int dm_post_suspending(struct dm_target *ti); + int dm_noflush_suspending(struct dm_target *ti); + void dm_accept_partial_bio(struct bio *bio, unsigned n_sectors); + union map_info *dm_get_rq_mapinfo(struct request *rq); +diff --git a/include/linux/efi.h b/include/linux/efi.h +index 9430d01c0c3d..650794abfa32 100644 +--- a/include/linux/efi.h ++++ b/include/linux/efi.h +@@ -991,6 +991,7 @@ int efivars_register(struct efivars *efivars, + int efivars_unregister(struct efivars *efivars); + struct kobject *efivars_kobject(void); + ++int efivar_supports_writes(void); + int efivar_init(int (*func)(efi_char16_t *, efi_guid_t, unsigned long, void *), + void *data, bool duplicates, struct list_head *head); + +diff --git a/include/linux/io-mapping.h b/include/linux/io-mapping.h +index b336622612f3..75eebe7c12f8 100644 +--- a/include/linux/io-mapping.h ++++ b/include/linux/io-mapping.h +@@ -107,9 +107,12 @@ io_mapping_init_wc(struct io_mapping *iomap, + resource_size_t base, + unsigned long size) + { ++ iomap->iomem = ioremap_wc(base, size); ++ if (!iomap->iomem) ++ return NULL; ++ + iomap->base = base; + iomap->size = size; +- iomap->iomem = ioremap_wc(base, size); + #if defined(pgprot_noncached_wc) /* archs can't agree on a name ... */ + iomap->prot = pgprot_noncached_wc(PAGE_KERNEL); + #elif defined(pgprot_writecombine) +diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h +index 0754b8d71262..8a84f11bf124 100644 +--- a/include/linux/mod_devicetable.h ++++ b/include/linux/mod_devicetable.h +@@ -318,7 +318,7 @@ struct pcmcia_device_id { + #define INPUT_DEVICE_ID_LED_MAX 0x0f + #define INPUT_DEVICE_ID_SND_MAX 0x07 + #define INPUT_DEVICE_ID_FF_MAX 0x7f +-#define INPUT_DEVICE_ID_SW_MAX 0x0f ++#define INPUT_DEVICE_ID_SW_MAX 0x10 + #define INPUT_DEVICE_ID_PROP_MAX 0x1f + + #define INPUT_DEVICE_ID_MATCH_BUS 1 +diff --git a/include/linux/xattr.h b/include/linux/xattr.h +index 47eaa34f8761..c5afaf8ca7a2 100644 +--- a/include/linux/xattr.h ++++ b/include/linux/xattr.h +@@ -15,6 +15,7 @@ + #include <linux/slab.h> + #include <linux/types.h> + #include <linux/spinlock.h> ++#include <linux/mm.h> + #include <uapi/linux/xattr.h> + + struct inode; +@@ -94,7 +95,7 @@ static inline void simple_xattrs_free(struct simple_xattrs *xattrs) + + list_for_each_entry_safe(xattr, node, &xattrs->head, list) { + kfree(xattr->name); +- kfree(xattr); ++ kvfree(xattr); + } + } + +diff --git a/include/sound/rt5670.h b/include/sound/rt5670.h +index f9024c7a1600..02e1d7778354 100644 +--- a/include/sound/rt5670.h ++++ b/include/sound/rt5670.h +@@ -12,6 +12,7 @@ struct rt5670_platform_data { + int jd_mode; + bool in2_diff; + bool dev_gpio; ++ bool gpio1_is_ext_spk_en; + + bool dmic_en; + unsigned int dmic1_data_pin; +diff --git a/include/uapi/linux/idxd.h b/include/uapi/linux/idxd.h +index 1f412fbf561b..e103c1434e4b 100644 +--- a/include/uapi/linux/idxd.h ++++ b/include/uapi/linux/idxd.h +@@ -110,9 +110,12 @@ struct dsa_hw_desc { + uint16_t rsvd1; + union { + uint8_t expected_res; ++ /* create delta record */ + struct { + uint64_t delta_addr; + uint32_t max_delta_size; ++ uint32_t delt_rsvd; ++ uint8_t expected_res_mask; + }; + uint32_t delta_rec_size; + uint64_t dest2; +diff --git a/include/uapi/linux/input-event-codes.h b/include/uapi/linux/input-event-codes.h +index b6a835d37826..0c2e27d28e0a 100644 +--- a/include/uapi/linux/input-event-codes.h ++++ b/include/uapi/linux/input-event-codes.h +@@ -888,7 +888,8 @@ + #define SW_LINEIN_INSERT 0x0d /* set = inserted */ + #define SW_MUTE_DEVICE 0x0e /* set = device disabled */ + #define SW_PEN_INSERTED 0x0f /* set = pen inserted */ +-#define SW_MAX 0x0f ++#define SW_MACHINE_COVER 0x10 /* set = cover closed */ ++#define SW_MAX 0x10 + #define SW_CNT (SW_MAX+1) + + /* +diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c +index 739d9ba3ba6b..eebdd5307713 100644 +--- a/kernel/bpf/verifier.c ++++ b/kernel/bpf/verifier.c +@@ -9613,7 +9613,7 @@ static int jit_subprogs(struct bpf_verifier_env *env) + int i, j, subprog_start, subprog_end = 0, len, subprog; + struct bpf_insn *insn; + void *old_bpf_func; +- int err; ++ int err, num_exentries; + + if (env->subprog_cnt <= 1) + return 0; +@@ -9688,6 +9688,14 @@ static int jit_subprogs(struct bpf_verifier_env *env) + func[i]->aux->nr_linfo = prog->aux->nr_linfo; + func[i]->aux->jited_linfo = prog->aux->jited_linfo; + func[i]->aux->linfo_idx = env->subprog_info[i].linfo_idx; ++ num_exentries = 0; ++ insn = func[i]->insnsi; ++ for (j = 0; j < func[i]->len; j++, insn++) { ++ if (BPF_CLASS(insn->code) == BPF_LDX && ++ BPF_MODE(insn->code) == BPF_PROBE_MEM) ++ num_exentries++; ++ } ++ func[i]->aux->num_exentries = num_exentries; + func[i] = bpf_int_jit_compile(func[i]); + if (!func[i]->jited) { + err = -ENOTSUPP; +diff --git a/kernel/events/uprobes.c b/kernel/events/uprobes.c +index cc2095607c74..8e1f7165162c 100644 +--- a/kernel/events/uprobes.c ++++ b/kernel/events/uprobes.c +@@ -2205,7 +2205,7 @@ static void handle_swbp(struct pt_regs *regs) + if (!uprobe) { + if (is_swbp > 0) { + /* No matching uprobe; signal SIGTRAP. */ +- send_sig(SIGTRAP, current, 0); ++ force_sig(SIGTRAP); + } else { + /* + * Either we raced with uprobe_unregister() or we can't +diff --git a/mm/hugetlb.c b/mm/hugetlb.c +index 4f7cdc55fbe4..461324757c75 100644 +--- a/mm/hugetlb.c ++++ b/mm/hugetlb.c +@@ -46,7 +46,10 @@ int hugetlb_max_hstate __read_mostly; + unsigned int default_hstate_idx; + struct hstate hstates[HUGE_MAX_HSTATE]; + ++#ifdef CONFIG_CMA + static struct cma *hugetlb_cma[MAX_NUMNODES]; ++#endif ++static unsigned long hugetlb_cma_size __initdata; + + /* + * Minimum page order among possible hugepage sizes, set to a proper value +@@ -1236,9 +1239,10 @@ static void free_gigantic_page(struct page *page, unsigned int order) + * If the page isn't allocated using the cma allocator, + * cma_release() returns false. + */ +- if (IS_ENABLED(CONFIG_CMA) && +- cma_release(hugetlb_cma[page_to_nid(page)], page, 1 << order)) ++#ifdef CONFIG_CMA ++ if (cma_release(hugetlb_cma[page_to_nid(page)], page, 1 << order)) + return; ++#endif + + free_contig_range(page_to_pfn(page), 1 << order); + } +@@ -1249,7 +1253,8 @@ static struct page *alloc_gigantic_page(struct hstate *h, gfp_t gfp_mask, + { + unsigned long nr_pages = 1UL << huge_page_order(h); + +- if (IS_ENABLED(CONFIG_CMA)) { ++#ifdef CONFIG_CMA ++ { + struct page *page; + int node; + +@@ -1263,6 +1268,7 @@ static struct page *alloc_gigantic_page(struct hstate *h, gfp_t gfp_mask, + return page; + } + } ++#endif + + return alloc_contig_pages(nr_pages, gfp_mask, nid, nodemask); + } +@@ -2572,7 +2578,7 @@ static void __init hugetlb_hstate_alloc_pages(struct hstate *h) + + for (i = 0; i < h->max_huge_pages; ++i) { + if (hstate_is_gigantic(h)) { +- if (IS_ENABLED(CONFIG_CMA) && hugetlb_cma[0]) { ++ if (hugetlb_cma_size) { + pr_warn_once("HugeTLB: hugetlb_cma is enabled, skip boot time allocation\n"); + break; + } +@@ -5548,7 +5554,6 @@ void move_hugetlb_state(struct page *oldpage, struct page *newpage, int reason) + } + + #ifdef CONFIG_CMA +-static unsigned long hugetlb_cma_size __initdata; + static bool cma_reserve_called __initdata; + + static int __init cmdline_parse_hugetlb_cma(char *p) +diff --git a/mm/khugepaged.c b/mm/khugepaged.c +index cd280afb246e..e9e7a5659d64 100644 +--- a/mm/khugepaged.c ++++ b/mm/khugepaged.c +@@ -873,6 +873,9 @@ static int hugepage_vma_revalidate(struct mm_struct *mm, unsigned long address, + return SCAN_ADDRESS_RANGE; + if (!hugepage_vma_check(vma, vma->vm_flags)) + return SCAN_VMA_CHECK; ++ /* Anon VMA expected */ ++ if (!vma->anon_vma || vma->vm_ops) ++ return SCAN_VMA_CHECK; + return 0; + } + +diff --git a/mm/memcontrol.c b/mm/memcontrol.c +index ef0e291a8cf4..9a4a77104d16 100644 +--- a/mm/memcontrol.c ++++ b/mm/memcontrol.c +@@ -5658,7 +5658,6 @@ static void __mem_cgroup_clear_mc(void) + if (!mem_cgroup_is_root(mc.to)) + page_counter_uncharge(&mc.to->memory, mc.moved_swap); + +- mem_cgroup_id_get_many(mc.to, mc.moved_swap); + css_put_many(&mc.to->css, mc.moved_swap); + + mc.moved_swap = 0; +@@ -5849,7 +5848,8 @@ put: /* get_mctgt_type() gets the page */ + ent = target.ent; + if (!mem_cgroup_move_swap_account(ent, mc.from, mc.to)) { + mc.precharge--; +- /* we fixup refcnts and charges later. */ ++ mem_cgroup_id_get_many(mc.to, 1); ++ /* we fixup other refcnts and charges later. */ + mc.moved_swap++; + } + break; +diff --git a/mm/mmap.c b/mm/mmap.c +index f609e9ec4a25..bb1822ac9909 100644 +--- a/mm/mmap.c ++++ b/mm/mmap.c +@@ -2620,7 +2620,7 @@ static void unmap_region(struct mm_struct *mm, + * Create a list of vma's touched by the unmap, removing them from the mm's + * vma list as we go.. + */ +-static void ++static bool + detach_vmas_to_be_unmapped(struct mm_struct *mm, struct vm_area_struct *vma, + struct vm_area_struct *prev, unsigned long end) + { +@@ -2645,6 +2645,17 @@ detach_vmas_to_be_unmapped(struct mm_struct *mm, struct vm_area_struct *vma, + + /* Kill the cache */ + vmacache_invalidate(mm); ++ ++ /* ++ * Do not downgrade mmap_lock if we are next to VM_GROWSDOWN or ++ * VM_GROWSUP VMA. Such VMAs can change their size under ++ * down_read(mmap_lock) and collide with the VMA we are about to unmap. ++ */ ++ if (vma && (vma->vm_flags & VM_GROWSDOWN)) ++ return false; ++ if (prev && (prev->vm_flags & VM_GROWSUP)) ++ return false; ++ return true; + } + + /* +@@ -2825,7 +2836,8 @@ int __do_munmap(struct mm_struct *mm, unsigned long start, size_t len, + } + + /* Detach vmas from rbtree */ +- detach_vmas_to_be_unmapped(mm, vma, prev, end); ++ if (!detach_vmas_to_be_unmapped(mm, vma, prev, end)) ++ downgrade = false; + + if (downgrade) + downgrade_write(&mm->mmap_sem); +diff --git a/mm/shmem.c b/mm/shmem.c +index bd8840082c94..97b4a47e9767 100644 +--- a/mm/shmem.c ++++ b/mm/shmem.c +@@ -3205,7 +3205,7 @@ static int shmem_initxattrs(struct inode *inode, + new_xattr->name = kmalloc(XATTR_SECURITY_PREFIX_LEN + len, + GFP_KERNEL); + if (!new_xattr->name) { +- kfree(new_xattr); ++ kvfree(new_xattr); + return -ENOMEM; + } + +diff --git a/mm/slab_common.c b/mm/slab_common.c +index 37d48a56431d..fe8b68482670 100644 +--- a/mm/slab_common.c ++++ b/mm/slab_common.c +@@ -326,6 +326,14 @@ int slab_unmergeable(struct kmem_cache *s) + if (s->refcount < 0) + return 1; + ++#ifdef CONFIG_MEMCG_KMEM ++ /* ++ * Skip the dying kmem_cache. ++ */ ++ if (s->memcg_params.dying) ++ return 1; ++#endif ++ + return 0; + } + +@@ -886,12 +894,15 @@ static int shutdown_memcg_caches(struct kmem_cache *s) + return 0; + } + +-static void flush_memcg_workqueue(struct kmem_cache *s) ++static void memcg_set_kmem_cache_dying(struct kmem_cache *s) + { + spin_lock_irq(&memcg_kmem_wq_lock); + s->memcg_params.dying = true; + spin_unlock_irq(&memcg_kmem_wq_lock); ++} + ++static void flush_memcg_workqueue(struct kmem_cache *s) ++{ + /* + * SLAB and SLUB deactivate the kmem_caches through call_rcu. Make + * sure all registered rcu callbacks have been invoked. +@@ -923,10 +934,6 @@ static inline int shutdown_memcg_caches(struct kmem_cache *s) + { + return 0; + } +- +-static inline void flush_memcg_workqueue(struct kmem_cache *s) +-{ +-} + #endif /* CONFIG_MEMCG_KMEM */ + + void slab_kmem_cache_release(struct kmem_cache *s) +@@ -944,8 +951,6 @@ void kmem_cache_destroy(struct kmem_cache *s) + if (unlikely(!s)) + return; + +- flush_memcg_workqueue(s); +- + get_online_cpus(); + get_online_mems(); + +@@ -955,6 +960,22 @@ void kmem_cache_destroy(struct kmem_cache *s) + if (s->refcount) + goto out_unlock; + ++#ifdef CONFIG_MEMCG_KMEM ++ memcg_set_kmem_cache_dying(s); ++ ++ mutex_unlock(&slab_mutex); ++ ++ put_online_mems(); ++ put_online_cpus(); ++ ++ flush_memcg_workqueue(s); ++ ++ get_online_cpus(); ++ get_online_mems(); ++ ++ mutex_lock(&slab_mutex); ++#endif ++ + err = shutdown_memcg_caches(s); + if (!err) + err = shutdown_cache(s); +diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c +index 91a13aee4378..961f37c0701b 100644 +--- a/net/mac80211/rx.c ++++ b/net/mac80211/rx.c +@@ -2357,6 +2357,7 @@ static int ieee80211_802_1x_port_control(struct ieee80211_rx_data *rx) + + static int ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc) + { ++ struct ieee80211_hdr *hdr = (void *)rx->skb->data; + struct sk_buff *skb = rx->skb; + struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); + +@@ -2367,6 +2368,31 @@ static int ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc) + if (status->flag & RX_FLAG_DECRYPTED) + return 0; + ++ /* check mesh EAPOL frames first */ ++ if (unlikely(rx->sta && ieee80211_vif_is_mesh(&rx->sdata->vif) && ++ ieee80211_is_data(fc))) { ++ struct ieee80211s_hdr *mesh_hdr; ++ u16 hdr_len = ieee80211_hdrlen(fc); ++ u16 ethertype_offset; ++ __be16 ethertype; ++ ++ if (!ether_addr_equal(hdr->addr1, rx->sdata->vif.addr)) ++ goto drop_check; ++ ++ /* make sure fixed part of mesh header is there, also checks skb len */ ++ if (!pskb_may_pull(rx->skb, hdr_len + 6)) ++ goto drop_check; ++ ++ mesh_hdr = (struct ieee80211s_hdr *)(skb->data + hdr_len); ++ ethertype_offset = hdr_len + ieee80211_get_mesh_hdrlen(mesh_hdr) + ++ sizeof(rfc1042_header); ++ ++ if (skb_copy_bits(rx->skb, ethertype_offset, ðertype, 2) == 0 && ++ ethertype == rx->sdata->control_port_protocol) ++ return 0; ++ } ++ ++drop_check: + /* Drop unencrypted frames if key is set. */ + if (unlikely(!ieee80211_has_protected(fc) && + !ieee80211_is_any_nullfunc(fc) && +diff --git a/net/netfilter/ipvs/ip_vs_sync.c b/net/netfilter/ipvs/ip_vs_sync.c +index 605e0f68f8bd..2b8abbfe018c 100644 +--- a/net/netfilter/ipvs/ip_vs_sync.c ++++ b/net/netfilter/ipvs/ip_vs_sync.c +@@ -1717,6 +1717,8 @@ static int sync_thread_backup(void *data) + { + struct ip_vs_sync_thread_data *tinfo = data; + struct netns_ipvs *ipvs = tinfo->ipvs; ++ struct sock *sk = tinfo->sock->sk; ++ struct udp_sock *up = udp_sk(sk); + int len; + + pr_info("sync thread started: state = BACKUP, mcast_ifn = %s, " +@@ -1724,12 +1726,14 @@ static int sync_thread_backup(void *data) + ipvs->bcfg.mcast_ifn, ipvs->bcfg.syncid, tinfo->id); + + while (!kthread_should_stop()) { +- wait_event_interruptible(*sk_sleep(tinfo->sock->sk), +- !skb_queue_empty(&tinfo->sock->sk->sk_receive_queue) +- || kthread_should_stop()); ++ wait_event_interruptible(*sk_sleep(sk), ++ !skb_queue_empty_lockless(&sk->sk_receive_queue) || ++ !skb_queue_empty_lockless(&up->reader_queue) || ++ kthread_should_stop()); + + /* do we have data now? */ +- while (!skb_queue_empty(&(tinfo->sock->sk->sk_receive_queue))) { ++ while (!skb_queue_empty_lockless(&sk->sk_receive_queue) || ++ !skb_queue_empty_lockless(&up->reader_queue)) { + len = ip_vs_receive(tinfo->sock, tinfo->buf, + ipvs->bcfg.sync_maxlen); + if (len <= 0) { +diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c +index 9780bd93b7e4..e1d678af8749 100644 +--- a/net/netfilter/nf_tables_api.c ++++ b/net/netfilter/nf_tables_api.c +@@ -188,24 +188,6 @@ static void nft_netdev_unregister_hooks(struct net *net, + nf_unregister_net_hook(net, &hook->ops); + } + +-static int nft_register_basechain_hooks(struct net *net, int family, +- struct nft_base_chain *basechain) +-{ +- if (family == NFPROTO_NETDEV) +- return nft_netdev_register_hooks(net, &basechain->hook_list); +- +- return nf_register_net_hook(net, &basechain->ops); +-} +- +-static void nft_unregister_basechain_hooks(struct net *net, int family, +- struct nft_base_chain *basechain) +-{ +- if (family == NFPROTO_NETDEV) +- nft_netdev_unregister_hooks(net, &basechain->hook_list); +- else +- nf_unregister_net_hook(net, &basechain->ops); +-} +- + static int nf_tables_register_hook(struct net *net, + const struct nft_table *table, + struct nft_chain *chain) +@@ -223,7 +205,10 @@ static int nf_tables_register_hook(struct net *net, + if (basechain->type->ops_register) + return basechain->type->ops_register(net, ops); + +- return nft_register_basechain_hooks(net, table->family, basechain); ++ if (table->family == NFPROTO_NETDEV) ++ return nft_netdev_register_hooks(net, &basechain->hook_list); ++ ++ return nf_register_net_hook(net, &basechain->ops); + } + + static void nf_tables_unregister_hook(struct net *net, +@@ -242,7 +227,10 @@ static void nf_tables_unregister_hook(struct net *net, + if (basechain->type->ops_unregister) + return basechain->type->ops_unregister(net, ops); + +- nft_unregister_basechain_hooks(net, table->family, basechain); ++ if (table->family == NFPROTO_NETDEV) ++ nft_netdev_unregister_hooks(net, &basechain->hook_list); ++ else ++ nf_unregister_net_hook(net, &basechain->ops); + } + + static int nft_trans_table_add(struct nft_ctx *ctx, int msg_type) +@@ -832,8 +820,7 @@ static void nft_table_disable(struct net *net, struct nft_table *table, u32 cnt) + if (cnt && i++ == cnt) + break; + +- nft_unregister_basechain_hooks(net, table->family, +- nft_base_chain(chain)); ++ nf_tables_unregister_hook(net, table, chain); + } + } + +@@ -848,8 +835,7 @@ static int nf_tables_table_enable(struct net *net, struct nft_table *table) + if (!nft_is_base_chain(chain)) + continue; + +- err = nft_register_basechain_hooks(net, table->family, +- nft_base_chain(chain)); ++ err = nf_tables_register_hook(net, table, chain); + if (err < 0) + goto err_register_hooks; + +@@ -894,11 +880,12 @@ static int nf_tables_updtable(struct nft_ctx *ctx) + nft_trans_table_enable(trans) = false; + } else if (!(flags & NFT_TABLE_F_DORMANT) && + ctx->table->flags & NFT_TABLE_F_DORMANT) { ++ ctx->table->flags &= ~NFT_TABLE_F_DORMANT; + ret = nf_tables_table_enable(ctx->net, ctx->table); +- if (ret >= 0) { +- ctx->table->flags &= ~NFT_TABLE_F_DORMANT; ++ if (ret >= 0) + nft_trans_table_enable(trans) = true; +- } ++ else ++ ctx->table->flags |= NFT_TABLE_F_DORMANT; + } + if (ret < 0) + goto err; +diff --git a/net/vmw_vsock/virtio_transport.c b/net/vmw_vsock/virtio_transport.c +index dfbaf6bd8b1c..2700a63ab095 100644 +--- a/net/vmw_vsock/virtio_transport.c ++++ b/net/vmw_vsock/virtio_transport.c +@@ -22,7 +22,7 @@ + #include <net/af_vsock.h> + + static struct workqueue_struct *virtio_vsock_workqueue; +-static struct virtio_vsock *the_virtio_vsock; ++static struct virtio_vsock __rcu *the_virtio_vsock; + static DEFINE_MUTEX(the_virtio_vsock_mutex); /* protects the_virtio_vsock */ + + struct virtio_vsock { +diff --git a/scripts/decode_stacktrace.sh b/scripts/decode_stacktrace.sh +index 13e5fbafdf2f..fe7076fdac8a 100755 +--- a/scripts/decode_stacktrace.sh ++++ b/scripts/decode_stacktrace.sh +@@ -84,8 +84,8 @@ parse_symbol() { + return + fi + +- # Strip out the base of the path +- code=${code#$basepath/} ++ # Strip out the base of the path on each line ++ code=$(while read -r line; do echo "${line#$basepath/}"; done <<< "$code") + + # In the case of inlines, move everything to same line + code=${code//$'\n'/' '} +diff --git a/scripts/gdb/linux/symbols.py b/scripts/gdb/linux/symbols.py +index be984aa29b75..1be9763cf8bb 100644 +--- a/scripts/gdb/linux/symbols.py ++++ b/scripts/gdb/linux/symbols.py +@@ -96,7 +96,7 @@ lx-symbols command.""" + return "" + attrs = sect_attrs['attrs'] + section_name_to_address = { +- attrs[n]['name'].string(): attrs[n]['address'] ++ attrs[n]['battr']['attr']['name'].string(): attrs[n]['address'] + for n in range(int(sect_attrs['nsections']))} + args = [] + for section_name in [".data", ".data..read_mostly", ".rodata", ".bss", +diff --git a/sound/core/info.c b/sound/core/info.c +index 8c6bc5241df5..9fec3070f8ba 100644 +--- a/sound/core/info.c ++++ b/sound/core/info.c +@@ -606,7 +606,9 @@ int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) + { + int c; + +- if (snd_BUG_ON(!buffer || !buffer->buffer)) ++ if (snd_BUG_ON(!buffer)) ++ return 1; ++ if (!buffer->buffer) + return 1; + if (len <= 0 || buffer->stop || buffer->error) + return 1; +diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c +index 137d655fed8f..e821c9df8107 100644 +--- a/sound/pci/hda/patch_hdmi.c ++++ b/sound/pci/hda/patch_hdmi.c +@@ -1804,33 +1804,43 @@ static int hdmi_add_cvt(struct hda_codec *codec, hda_nid_t cvt_nid) + + static int hdmi_parse_codec(struct hda_codec *codec) + { +- hda_nid_t nid; ++ hda_nid_t start_nid; ++ unsigned int caps; + int i, nodes; + +- nodes = snd_hda_get_sub_nodes(codec, codec->core.afg, &nid); +- if (!nid || nodes < 0) { ++ nodes = snd_hda_get_sub_nodes(codec, codec->core.afg, &start_nid); ++ if (!start_nid || nodes < 0) { + codec_warn(codec, "HDMI: failed to get afg sub nodes\n"); + return -EINVAL; + } + +- for (i = 0; i < nodes; i++, nid++) { +- unsigned int caps; +- unsigned int type; ++ /* ++ * hdmi_add_pin() assumes total amount of converters to ++ * be known, so first discover all converters ++ */ ++ for (i = 0; i < nodes; i++) { ++ hda_nid_t nid = start_nid + i; + + caps = get_wcaps(codec, nid); +- type = get_wcaps_type(caps); + + if (!(caps & AC_WCAP_DIGITAL)) + continue; + +- switch (type) { +- case AC_WID_AUD_OUT: ++ if (get_wcaps_type(caps) == AC_WID_AUD_OUT) + hdmi_add_cvt(codec, nid); +- break; +- case AC_WID_PIN: ++ } ++ ++ /* discover audio pins */ ++ for (i = 0; i < nodes; i++) { ++ hda_nid_t nid = start_nid + i; ++ ++ caps = get_wcaps(codec, nid); ++ ++ if (!(caps & AC_WCAP_DIGITAL)) ++ continue; ++ ++ if (get_wcaps_type(caps) == AC_WID_PIN) + hdmi_add_pin(codec, nid); +- break; +- } + } + + return 0; +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index d80eed2a48a1..27dd8945d6e6 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -7546,11 +7546,13 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC), + SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC), + SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE), ++ SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC225_FIXUP_HEADSET_JACK), + SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE), + SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC), + SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), + SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), + SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8), ++ SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), + SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC), + SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC), + SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC), +diff --git a/sound/soc/codecs/rt5670.c b/sound/soc/codecs/rt5670.c +index 70fee6849ab0..f21181734170 100644 +--- a/sound/soc/codecs/rt5670.c ++++ b/sound/soc/codecs/rt5670.c +@@ -31,18 +31,19 @@ + #include "rt5670.h" + #include "rt5670-dsp.h" + +-#define RT5670_DEV_GPIO BIT(0) +-#define RT5670_IN2_DIFF BIT(1) +-#define RT5670_DMIC_EN BIT(2) +-#define RT5670_DMIC1_IN2P BIT(3) +-#define RT5670_DMIC1_GPIO6 BIT(4) +-#define RT5670_DMIC1_GPIO7 BIT(5) +-#define RT5670_DMIC2_INR BIT(6) +-#define RT5670_DMIC2_GPIO8 BIT(7) +-#define RT5670_DMIC3_GPIO5 BIT(8) +-#define RT5670_JD_MODE1 BIT(9) +-#define RT5670_JD_MODE2 BIT(10) +-#define RT5670_JD_MODE3 BIT(11) ++#define RT5670_DEV_GPIO BIT(0) ++#define RT5670_IN2_DIFF BIT(1) ++#define RT5670_DMIC_EN BIT(2) ++#define RT5670_DMIC1_IN2P BIT(3) ++#define RT5670_DMIC1_GPIO6 BIT(4) ++#define RT5670_DMIC1_GPIO7 BIT(5) ++#define RT5670_DMIC2_INR BIT(6) ++#define RT5670_DMIC2_GPIO8 BIT(7) ++#define RT5670_DMIC3_GPIO5 BIT(8) ++#define RT5670_JD_MODE1 BIT(9) ++#define RT5670_JD_MODE2 BIT(10) ++#define RT5670_JD_MODE3 BIT(11) ++#define RT5670_GPIO1_IS_EXT_SPK_EN BIT(12) + + static unsigned long rt5670_quirk; + static unsigned int quirk_override; +@@ -1447,6 +1448,33 @@ static int rt5670_hp_event(struct snd_soc_dapm_widget *w, + return 0; + } + ++static int rt5670_spk_event(struct snd_soc_dapm_widget *w, ++ struct snd_kcontrol *kcontrol, int event) ++{ ++ struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); ++ struct rt5670_priv *rt5670 = snd_soc_component_get_drvdata(component); ++ ++ if (!rt5670->pdata.gpio1_is_ext_spk_en) ++ return 0; ++ ++ switch (event) { ++ case SND_SOC_DAPM_POST_PMU: ++ regmap_update_bits(rt5670->regmap, RT5670_GPIO_CTRL2, ++ RT5670_GP1_OUT_MASK, RT5670_GP1_OUT_HI); ++ break; ++ ++ case SND_SOC_DAPM_PRE_PMD: ++ regmap_update_bits(rt5670->regmap, RT5670_GPIO_CTRL2, ++ RT5670_GP1_OUT_MASK, RT5670_GP1_OUT_LO); ++ break; ++ ++ default: ++ return 0; ++ } ++ ++ return 0; ++} ++ + static int rt5670_bst1_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kcontrol, int event) + { +@@ -1860,7 +1888,9 @@ static const struct snd_soc_dapm_widget rt5670_specific_dapm_widgets[] = { + }; + + static const struct snd_soc_dapm_widget rt5672_specific_dapm_widgets[] = { +- SND_SOC_DAPM_PGA("SPO Amp", SND_SOC_NOPM, 0, 0, NULL, 0), ++ SND_SOC_DAPM_PGA_E("SPO Amp", SND_SOC_NOPM, 0, 0, NULL, 0, ++ rt5670_spk_event, SND_SOC_DAPM_PRE_PMD | ++ SND_SOC_DAPM_POST_PMU), + SND_SOC_DAPM_OUTPUT("SPOLP"), + SND_SOC_DAPM_OUTPUT("SPOLN"), + SND_SOC_DAPM_OUTPUT("SPORP"), +@@ -2857,14 +2887,14 @@ static const struct dmi_system_id dmi_platform_intel_quirks[] = { + }, + { + .callback = rt5670_quirk_cb, +- .ident = "Lenovo Thinkpad Tablet 10", ++ .ident = "Lenovo Miix 2 10", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), + DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Miix 2 10"), + }, + .driver_data = (unsigned long *)(RT5670_DMIC_EN | + RT5670_DMIC1_IN2P | +- RT5670_DEV_GPIO | ++ RT5670_GPIO1_IS_EXT_SPK_EN | + RT5670_JD_MODE2), + }, + { +@@ -2924,6 +2954,10 @@ static int rt5670_i2c_probe(struct i2c_client *i2c, + rt5670->pdata.dev_gpio = true; + dev_info(&i2c->dev, "quirk dev_gpio\n"); + } ++ if (rt5670_quirk & RT5670_GPIO1_IS_EXT_SPK_EN) { ++ rt5670->pdata.gpio1_is_ext_spk_en = true; ++ dev_info(&i2c->dev, "quirk GPIO1 is external speaker enable\n"); ++ } + if (rt5670_quirk & RT5670_IN2_DIFF) { + rt5670->pdata.in2_diff = true; + dev_info(&i2c->dev, "quirk IN2_DIFF\n"); +@@ -3023,6 +3057,13 @@ static int rt5670_i2c_probe(struct i2c_client *i2c, + RT5670_GP1_PF_MASK, RT5670_GP1_PF_OUT); + } + ++ if (rt5670->pdata.gpio1_is_ext_spk_en) { ++ regmap_update_bits(rt5670->regmap, RT5670_GPIO_CTRL1, ++ RT5670_GP1_PIN_MASK, RT5670_GP1_PIN_GPIO1); ++ regmap_update_bits(rt5670->regmap, RT5670_GPIO_CTRL2, ++ RT5670_GP1_PF_MASK, RT5670_GP1_PF_OUT); ++ } ++ + if (rt5670->pdata.jd_mode) { + regmap_update_bits(rt5670->regmap, RT5670_GLB_CLK, + RT5670_SCLK_SRC_MASK, RT5670_SCLK_SRC_RCCLK); +diff --git a/sound/soc/codecs/rt5670.h b/sound/soc/codecs/rt5670.h +index a8c3e44770b8..de0203369b7c 100644 +--- a/sound/soc/codecs/rt5670.h ++++ b/sound/soc/codecs/rt5670.h +@@ -757,7 +757,7 @@ + #define RT5670_PWR_VREF2_BIT 4 + #define RT5670_PWR_FV2 (0x1 << 3) + #define RT5670_PWR_FV2_BIT 3 +-#define RT5670_LDO_SEL_MASK (0x3) ++#define RT5670_LDO_SEL_MASK (0x7) + #define RT5670_LDO_SEL_SFT 0 + + /* Power Management for Analog 2 (0x64) */ +diff --git a/sound/soc/intel/boards/bdw-rt5677.c b/sound/soc/intel/boards/bdw-rt5677.c +index cc41a348295e..fa12a85f535a 100644 +--- a/sound/soc/intel/boards/bdw-rt5677.c ++++ b/sound/soc/intel/boards/bdw-rt5677.c +@@ -328,6 +328,7 @@ static struct snd_soc_dai_link bdw_rt5677_dais[] = { + { + .name = "Codec DSP", + .stream_name = "Wake on Voice", ++ .capture_only = 1, + .ops = &bdw_rt5677_dsp_ops, + SND_SOC_DAILINK_REG(dsp), + }, +diff --git a/sound/soc/intel/boards/bytcht_es8316.c b/sound/soc/intel/boards/bytcht_es8316.c +index ddcd070100ef..b3fd7de594d7 100644 +--- a/sound/soc/intel/boards/bytcht_es8316.c ++++ b/sound/soc/intel/boards/bytcht_es8316.c +@@ -543,8 +543,10 @@ static int snd_byt_cht_es8316_mc_probe(struct platform_device *pdev) + + if (cnt) { + ret = device_add_properties(codec_dev, props); +- if (ret) ++ if (ret) { ++ put_device(codec_dev); + return ret; ++ } + } + + devm_acpi_dev_add_driver_gpios(codec_dev, byt_cht_es8316_gpios); +diff --git a/sound/soc/intel/boards/cht_bsw_rt5672.c b/sound/soc/intel/boards/cht_bsw_rt5672.c +index 097023a3ec14..a3aa2c1f7097 100644 +--- a/sound/soc/intel/boards/cht_bsw_rt5672.c ++++ b/sound/soc/intel/boards/cht_bsw_rt5672.c +@@ -253,21 +253,20 @@ static int cht_codec_fixup(struct snd_soc_pcm_runtime *rtd, + params_set_format(params, SNDRV_PCM_FORMAT_S24_LE); + + /* +- * Default mode for SSP configuration is TDM 4 slot ++ * Default mode for SSP configuration is TDM 4 slot. One board/design, ++ * the Lenovo Miix 2 10 uses not 1 but 2 codecs connected to SSP2. The ++ * second piggy-backed, output-only codec is inside the keyboard-dock ++ * (which has extra speakers). Unlike the main rt5672 codec, we cannot ++ * configure this codec, it is hard coded to use 2 channel 24 bit I2S. ++ * Since we only support 2 channels anyways, there is no need for TDM ++ * on any cht-bsw-rt5672 designs. So we simply use I2S 2ch everywhere. + */ +- ret = snd_soc_dai_set_fmt(asoc_rtd_to_codec(rtd, 0), +- SND_SOC_DAIFMT_DSP_B | +- SND_SOC_DAIFMT_IB_NF | ++ ret = snd_soc_dai_set_fmt(asoc_rtd_to_cpu(rtd, 0), ++ SND_SOC_DAIFMT_I2S | ++ SND_SOC_DAIFMT_NB_NF | + SND_SOC_DAIFMT_CBS_CFS); + if (ret < 0) { +- dev_err(rtd->dev, "can't set format to TDM %d\n", ret); +- return ret; +- } +- +- /* TDM 4 slots 24 bit, set Rx & Tx bitmask to 4 active slots */ +- ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_codec(rtd, 0), 0xF, 0xF, 4, 24); +- if (ret < 0) { +- dev_err(rtd->dev, "can't set codec TDM slot %d\n", ret); ++ dev_err(rtd->dev, "can't set format to I2S, err %d\n", ret); + return ret; + } + +diff --git a/sound/soc/qcom/Kconfig b/sound/soc/qcom/Kconfig +index f51b28d1b94d..92f51d0e9fe2 100644 +--- a/sound/soc/qcom/Kconfig ++++ b/sound/soc/qcom/Kconfig +@@ -72,7 +72,7 @@ config SND_SOC_QDSP6_ASM_DAI + + config SND_SOC_QDSP6 + tristate "SoC ALSA audio driver for QDSP6" +- depends on QCOM_APR && HAS_DMA ++ depends on QCOM_APR + select SND_SOC_QDSP6_COMMON + select SND_SOC_QDSP6_CORE + select SND_SOC_QDSP6_AFE +diff --git a/sound/soc/soc-topology.c b/sound/soc/soc-topology.c +index 6df3b0d12d87..31250a14c21d 100644 +--- a/sound/soc/soc-topology.c ++++ b/sound/soc/soc-topology.c +@@ -1285,17 +1285,29 @@ static int soc_tplg_dapm_graph_elems_load(struct soc_tplg *tplg, + list_add(&routes[i]->dobj.list, &tplg->comp->dobj_list); + + ret = soc_tplg_add_route(tplg, routes[i]); +- if (ret < 0) ++ if (ret < 0) { ++ /* ++ * this route was added to the list, it will ++ * be freed in remove_route() so increment the ++ * counter to skip it in the error handling ++ * below. ++ */ ++ i++; + break; ++ } + + /* add route, but keep going if some fail */ + snd_soc_dapm_add_routes(dapm, routes[i], 1); + } + +- /* free memory allocated for all dapm routes in case of error */ +- if (ret < 0) +- for (i = 0; i < count ; i++) +- kfree(routes[i]); ++ /* ++ * free memory allocated for all dapm routes not added to the ++ * list in case of error ++ */ ++ if (ret < 0) { ++ while (i < count) ++ kfree(routes[i++]); ++ } + + /* + * free pointer to array of dapm routes as this is no longer needed. +@@ -1383,7 +1395,6 @@ static struct snd_kcontrol_new *soc_tplg_dapm_widget_dmixer_create( + if (err < 0) { + dev_err(tplg->dev, "ASoC: failed to init %s\n", + mc->hdr.name); +- soc_tplg_free_tlv(tplg, &kc[i]); + goto err_sm; + } + } +@@ -1391,6 +1402,7 @@ static struct snd_kcontrol_new *soc_tplg_dapm_widget_dmixer_create( + + err_sm: + for (; i >= 0; i--) { ++ soc_tplg_free_tlv(tplg, &kc[i]); + sm = (struct soc_mixer_control *)kc[i].private_value; + kfree(sm); + kfree(kc[i].name); +diff --git a/tools/perf/pmu-events/arch/s390/cf_z15/extended.json b/tools/perf/pmu-events/arch/s390/cf_z15/extended.json +index 2df2e231e9ee..24c4ba2a9ae5 100644 +--- a/tools/perf/pmu-events/arch/s390/cf_z15/extended.json ++++ b/tools/perf/pmu-events/arch/s390/cf_z15/extended.json +@@ -380,7 +380,7 @@ + { + "Unit": "CPU-M-CF", + "EventCode": "265", +- "EventName": "DFLT_CCERROR", ++ "EventName": "DFLT_CCFINISH", + "BriefDescription": "Increments by one for every DEFLATE CONVERSION CALL instruction executed that ended in Condition Codes 0, 1 or 2", + "PublicDescription": "Increments by one for every DEFLATE CONVERSION CALL instruction executed that ended in Condition Codes 0, 1 or 2" + }, |