diff options
| author |   Mike Pagano <mpagano@gentoo.org> | 2021-05-11 10:19:48 -0400 |
|---|---|---|
| committer | Mike Pagano <mpagano@gentoo.org> | 2021-05-11 10:19:48 -0400 |
| commit | 3f132681ae22eff1ad96be78333c8a60e142a863 (patch) | |
| tree | 9a7f61e6aee9094cba0f91ac77a02aabcf64b319 | |
| parent | Linux patch 5.4.117 (diff) | |
| download | linux-patches-5.4-121.tar.gz linux-patches-5.4-121.tar.bz2 linux-patches-5.4-121.zip | |
Linux patch 5.4.1185.4-121
Signed-off-by: Mike Pagano <mpagano@gentoo.org>
| -rw-r--r-- | 0000_README | 4 | ||||
| -rw-r--r-- | 1117_linux-5.4.118.patch | 6569 |
2 files changed, 6573 insertions, 0 deletions
diff --git a/0000_README b/0000_README index 8b19f381..5f952d04 100644 --- a/0000_README +++ b/0000_README @@ -511,6 +511,10 @@ Patch: 1116_linux-5.4.117.patch From: http://www.kernel.org Desc: Linux 5.4.117 +Patch: 1117_linux-5.4.118.patch +From: http://www.kernel.org +Desc: Linux 5.4.118 + 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/1117_linux-5.4.118.patch b/1117_linux-5.4.118.patch new file mode 100644 index 00000000..28c410d3 --- /dev/null +++ b/1117_linux-5.4.118.patch @@ -0,0 +1,6569 @@ +diff --git a/Makefile b/Makefile +index f4115702996c5..05a19383b3964 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 4 +-SUBLEVEL = 117 ++SUBLEVEL = 118 + EXTRAVERSION = + NAME = Kleptomaniac Octopus + +@@ -765,16 +765,16 @@ KBUILD_CFLAGS += -Wno-tautological-compare + KBUILD_CFLAGS += -mno-global-merge + else + +-# These warnings generated too much noise in a regular build. +-# Use make W=1 to enable them (see scripts/Makefile.extrawarn) +-KBUILD_CFLAGS += -Wno-unused-but-set-variable +- + # Warn about unmarked fall-throughs in switch statement. + # Disabled for clang while comment to attribute conversion happens and + # https://github.com/ClangBuiltLinux/linux/issues/636 is discussed. + KBUILD_CFLAGS += $(call cc-option,-Wimplicit-fallthrough,) + endif + ++# These warnings generated too much noise in a regular build. ++# Use make W=1 to enable them (see scripts/Makefile.extrawarn) ++KBUILD_CFLAGS += $(call cc-disable-warning, unused-but-set-variable) ++ + KBUILD_CFLAGS += $(call cc-disable-warning, unused-const-variable) + ifdef CONFIG_FRAME_POINTER + KBUILD_CFLAGS += -fno-omit-frame-pointer -fno-optimize-sibling-calls +diff --git a/arch/arm/boot/compressed/Makefile b/arch/arm/boot/compressed/Makefile +index 6da67789ac221..f0b3a9281d69b 100644 +--- a/arch/arm/boot/compressed/Makefile ++++ b/arch/arm/boot/compressed/Makefile +@@ -122,8 +122,8 @@ asflags-y := -DZIMAGE + + # Supply kernel BSS size to the decompressor via a linker symbol. + KBSS_SZ = $(shell echo $$(($$($(NM) $(obj)/../../../../vmlinux | \ +- sed -n -e 's/^\([^ ]*\) [AB] __bss_start$$/-0x\1/p' \ +- -e 's/^\([^ ]*\) [AB] __bss_stop$$/+0x\1/p') )) ) ++ sed -n -e 's/^\([^ ]*\) [ABD] __bss_start$$/-0x\1/p' \ ++ -e 's/^\([^ ]*\) [ABD] __bss_stop$$/+0x\1/p') )) ) + LDFLAGS_vmlinux = --defsym _kernel_bss_size=$(KBSS_SZ) + # Supply ZRELADDR to the decompressor via a linker symbol. + ifneq ($(CONFIG_AUTO_ZRELADDR),y) +diff --git a/arch/arm64/boot/dts/marvell/armada-37xx.dtsi b/arch/arm64/boot/dts/marvell/armada-37xx.dtsi +index 000c135e39b73..28ad59ee6c34b 100644 +--- a/arch/arm64/boot/dts/marvell/armada-37xx.dtsi ++++ b/arch/arm64/boot/dts/marvell/armada-37xx.dtsi +@@ -156,7 +156,8 @@ + }; + + nb_periph_clk: nb-periph-clk@13000 { +- compatible = "marvell,armada-3700-periph-clock-nb"; ++ compatible = "marvell,armada-3700-periph-clock-nb", ++ "syscon"; + reg = <0x13000 0x100>; + clocks = <&tbg 0>, <&tbg 1>, <&tbg 2>, + <&tbg 3>, <&xtalclk>; +diff --git a/arch/arm64/boot/dts/mediatek/mt8173.dtsi b/arch/arm64/boot/dts/mediatek/mt8173.dtsi +index dec5e4113ce4c..c4f742e6d1604 100644 +--- a/arch/arm64/boot/dts/mediatek/mt8173.dtsi ++++ b/arch/arm64/boot/dts/mediatek/mt8173.dtsi +@@ -1137,7 +1137,7 @@ + <&mmsys CLK_MM_DSI1_DIGITAL>, + <&mipi_tx1>; + clock-names = "engine", "digital", "hs"; +- phy = <&mipi_tx1>; ++ phys = <&mipi_tx1>; + phy-names = "dphy"; + status = "disabled"; + }; +diff --git a/arch/arm64/kernel/vdso/vdso.lds.S b/arch/arm64/kernel/vdso/vdso.lds.S +index 7ad2d3a0cd489..815df253f96e0 100644 +--- a/arch/arm64/kernel/vdso/vdso.lds.S ++++ b/arch/arm64/kernel/vdso/vdso.lds.S +@@ -28,6 +28,13 @@ SECTIONS + .gnu.version_d : { *(.gnu.version_d) } + .gnu.version_r : { *(.gnu.version_r) } + ++ /* ++ * Discard .note.gnu.property sections which are unused and have ++ * different alignment requirement from vDSO note sections. ++ */ ++ /DISCARD/ : { ++ *(.note.GNU-stack .note.gnu.property) ++ } + .note : { *(.note.*) } :text :note + + . = ALIGN(16); +@@ -48,7 +55,6 @@ SECTIONS + PROVIDE(end = .); + + /DISCARD/ : { +- *(.note.GNU-stack) + *(.data .data.* .gnu.linkonce.d.* .sdata*) + *(.bss .sbss .dynbss .dynsbss) + } +diff --git a/arch/powerpc/include/uapi/asm/errno.h b/arch/powerpc/include/uapi/asm/errno.h +index cc79856896a19..4ba87de32be00 100644 +--- a/arch/powerpc/include/uapi/asm/errno.h ++++ b/arch/powerpc/include/uapi/asm/errno.h +@@ -2,6 +2,7 @@ + #ifndef _ASM_POWERPC_ERRNO_H + #define _ASM_POWERPC_ERRNO_H + ++#undef EDEADLOCK + #include <asm-generic/errno.h> + + #undef EDEADLOCK +diff --git a/arch/powerpc/kernel/eeh.c b/arch/powerpc/kernel/eeh.c +index c35069294ecfb..8b0e523b2abbe 100644 +--- a/arch/powerpc/kernel/eeh.c ++++ b/arch/powerpc/kernel/eeh.c +@@ -368,14 +368,11 @@ static inline unsigned long eeh_token_to_phys(unsigned long token) + pa = pte_pfn(*ptep); + + /* On radix we can do hugepage mappings for io, so handle that */ +- if (hugepage_shift) { +- pa <<= hugepage_shift; +- pa |= token & ((1ul << hugepage_shift) - 1); +- } else { +- pa <<= PAGE_SHIFT; +- pa |= token & (PAGE_SIZE - 1); +- } ++ if (!hugepage_shift) ++ hugepage_shift = PAGE_SHIFT; + ++ pa <<= PAGE_SHIFT; ++ pa |= token & ((1ul << hugepage_shift) - 1); + return pa; + } + +diff --git a/arch/s390/crypto/arch_random.c b/arch/s390/crypto/arch_random.c +index dd95cdbd22ce8..4cbb4b6d85a83 100644 +--- a/arch/s390/crypto/arch_random.c ++++ b/arch/s390/crypto/arch_random.c +@@ -53,6 +53,10 @@ static DECLARE_DELAYED_WORK(arch_rng_work, arch_rng_refill_buffer); + + bool s390_arch_random_generate(u8 *buf, unsigned int nbytes) + { ++ /* max hunk is ARCH_RNG_BUF_SIZE */ ++ if (nbytes > ARCH_RNG_BUF_SIZE) ++ return false; ++ + /* lock rng buffer */ + if (!spin_trylock(&arch_rng_lock)) + return false; +diff --git a/arch/s390/kernel/dis.c b/arch/s390/kernel/dis.c +index f304802ecf7be..03e35b399c4ee 100644 +--- a/arch/s390/kernel/dis.c ++++ b/arch/s390/kernel/dis.c +@@ -557,7 +557,7 @@ void show_code(struct pt_regs *regs) + + void print_fn_code(unsigned char *code, unsigned long len) + { +- char buffer[64], *ptr; ++ char buffer[128], *ptr; + int opsize, i; + + while (len) { +diff --git a/arch/x86/Makefile b/arch/x86/Makefile +index 59942e349e5f0..69f0cb01c6662 100644 +--- a/arch/x86/Makefile ++++ b/arch/x86/Makefile +@@ -40,6 +40,7 @@ REALMODE_CFLAGS += $(call __cc-option, $(CC), $(REALMODE_CFLAGS), -ffreestanding + REALMODE_CFLAGS += $(call __cc-option, $(CC), $(REALMODE_CFLAGS), -fno-stack-protector) + REALMODE_CFLAGS += $(call __cc-option, $(CC), $(REALMODE_CFLAGS), -Wno-address-of-packed-member) + REALMODE_CFLAGS += $(call __cc-option, $(CC), $(REALMODE_CFLAGS), $(cc_stack_align4)) ++REALMODE_CFLAGS += $(CLANG_FLAGS) + export REALMODE_CFLAGS + + # BITS is used as extension for files which are available in a 32 bit +diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c +index 8a85c2e144a6f..f961a56e9da3f 100644 +--- a/arch/x86/kernel/cpu/common.c ++++ b/arch/x86/kernel/cpu/common.c +@@ -1826,7 +1826,7 @@ static void setup_getcpu(int cpu) + unsigned long cpudata = vdso_encode_cpunode(cpu, early_cpu_to_node(cpu)); + struct desc_struct d = { }; + +- if (boot_cpu_has(X86_FEATURE_RDTSCP)) ++ if (boot_cpu_has(X86_FEATURE_RDTSCP) || boot_cpu_has(X86_FEATURE_RDPID)) + write_rdtscp_aux(cpudata); + + /* Store CPU and node number in limit. */ +diff --git a/crypto/api.c b/crypto/api.c +index eda0c56b86154..c71d1485541c7 100644 +--- a/crypto/api.c ++++ b/crypto/api.c +@@ -568,7 +568,7 @@ void crypto_destroy_tfm(void *mem, struct crypto_tfm *tfm) + { + struct crypto_alg *alg; + +- if (unlikely(!mem)) ++ if (IS_ERR_OR_NULL(mem)) + return; + + alg = tfm->__crt_alg; +diff --git a/crypto/rng.c b/crypto/rng.c +index 1490d210f1a19..608d6ce1440a6 100644 +--- a/crypto/rng.c ++++ b/crypto/rng.c +@@ -34,22 +34,18 @@ int crypto_rng_reset(struct crypto_rng *tfm, const u8 *seed, unsigned int slen) + u8 *buf = NULL; + int err; + +- crypto_stats_get(alg); + if (!seed && slen) { + buf = kmalloc(slen, GFP_KERNEL); +- if (!buf) { +- crypto_alg_put(alg); ++ if (!buf) + return -ENOMEM; +- } + + err = get_random_bytes_wait(buf, slen); +- if (err) { +- crypto_alg_put(alg); ++ if (err) + goto out; +- } + seed = buf; + } + ++ crypto_stats_get(alg); + err = crypto_rng_alg(tfm)->seed(tfm, seed, slen); + crypto_stats_rng_seed(alg, err); + out: +diff --git a/drivers/acpi/arm64/gtdt.c b/drivers/acpi/arm64/gtdt.c +index 01962c63a7116..7d7497b856020 100644 +--- a/drivers/acpi/arm64/gtdt.c ++++ b/drivers/acpi/arm64/gtdt.c +@@ -329,7 +329,7 @@ static int __init gtdt_import_sbsa_gwdt(struct acpi_gtdt_watchdog *wd, + int index) + { + struct platform_device *pdev; +- int irq = map_gt_gsi(wd->timer_interrupt, wd->timer_flags); ++ int irq; + + /* + * According to SBSA specification the size of refresh and control +@@ -338,7 +338,7 @@ static int __init gtdt_import_sbsa_gwdt(struct acpi_gtdt_watchdog *wd, + struct resource res[] = { + DEFINE_RES_MEM(wd->control_frame_address, SZ_4K), + DEFINE_RES_MEM(wd->refresh_frame_address, SZ_4K), +- DEFINE_RES_IRQ(irq), ++ {}, + }; + int nr_res = ARRAY_SIZE(res); + +@@ -348,10 +348,11 @@ static int __init gtdt_import_sbsa_gwdt(struct acpi_gtdt_watchdog *wd, + + if (!(wd->refresh_frame_address && wd->control_frame_address)) { + pr_err(FW_BUG "failed to get the Watchdog base address.\n"); +- acpi_unregister_gsi(wd->timer_interrupt); + return -EINVAL; + } + ++ irq = map_gt_gsi(wd->timer_interrupt, wd->timer_flags); ++ res[2] = (struct resource)DEFINE_RES_IRQ(irq); + if (irq <= 0) { + pr_warn("failed to map the Watchdog interrupt.\n"); + nr_res--; +@@ -364,7 +365,8 @@ static int __init gtdt_import_sbsa_gwdt(struct acpi_gtdt_watchdog *wd, + */ + pdev = platform_device_register_simple("sbsa-gwdt", index, res, nr_res); + if (IS_ERR(pdev)) { +- acpi_unregister_gsi(wd->timer_interrupt); ++ if (irq > 0) ++ acpi_unregister_gsi(wd->timer_interrupt); + return PTR_ERR(pdev); + } + +diff --git a/drivers/acpi/custom_method.c b/drivers/acpi/custom_method.c +index b097ef209313f..e7716c7b9be76 100644 +--- a/drivers/acpi/custom_method.c ++++ b/drivers/acpi/custom_method.c +@@ -44,6 +44,8 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf, + sizeof(struct acpi_table_header))) + return -EFAULT; + uncopied_bytes = max_size = table.length; ++ /* make sure the buf is not allocated */ ++ kfree(buf); + buf = kzalloc(max_size, GFP_KERNEL); + if (!buf) + return -ENOMEM; +@@ -57,6 +59,7 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf, + (*ppos + count < count) || + (count > uncopied_bytes)) { + kfree(buf); ++ buf = NULL; + return -EINVAL; + } + +@@ -78,7 +81,6 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf, + add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE); + } + +- kfree(buf); + return count; + } + +diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c +index d33528033042c..8beb418ce167b 100644 +--- a/drivers/ata/ahci.c ++++ b/drivers/ata/ahci.c +@@ -1728,6 +1728,11 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) + hpriv->flags |= AHCI_HFLAG_NO_DEVSLP; + + #ifdef CONFIG_ARM64 ++ if (pdev->vendor == PCI_VENDOR_ID_HUAWEI && ++ pdev->device == 0xa235 && ++ pdev->revision < 0x30) ++ hpriv->flags |= AHCI_HFLAG_NO_SXS; ++ + if (pdev->vendor == 0x177d && pdev->device == 0xa01c) + hpriv->irq_handler = ahci_thunderx_irq_handler; + #endif +diff --git a/drivers/ata/ahci.h b/drivers/ata/ahci.h +index 9ef62e647cd20..732912cd4e083 100644 +--- a/drivers/ata/ahci.h ++++ b/drivers/ata/ahci.h +@@ -242,6 +242,7 @@ enum { + suspend/resume */ + AHCI_HFLAG_IGN_NOTSUPP_POWER_ON = (1 << 27), /* ignore -EOPNOTSUPP + from phy_power_on() */ ++ AHCI_HFLAG_NO_SXS = (1 << 28), /* SXS not supported */ + + /* ap->flags bits */ + +diff --git a/drivers/ata/libahci.c b/drivers/ata/libahci.c +index ea5bf5f4cbed5..fec2e9754aed2 100644 +--- a/drivers/ata/libahci.c ++++ b/drivers/ata/libahci.c +@@ -493,6 +493,11 @@ void ahci_save_initial_config(struct device *dev, struct ahci_host_priv *hpriv) + cap |= HOST_CAP_ALPM; + } + ++ if ((cap & HOST_CAP_SXS) && (hpriv->flags & AHCI_HFLAG_NO_SXS)) { ++ dev_info(dev, "controller does not support SXS, disabling CAP_SXS\n"); ++ cap &= ~HOST_CAP_SXS; ++ } ++ + if (hpriv->force_port_map && port_map != hpriv->force_port_map) { + dev_info(dev, "forcing port_map 0x%x -> 0x%x\n", + port_map, hpriv->force_port_map); +diff --git a/drivers/bus/ti-sysc.c b/drivers/bus/ti-sysc.c +index f9ff6d433dfe1..d59e1ca9990b6 100644 +--- a/drivers/bus/ti-sysc.c ++++ b/drivers/bus/ti-sysc.c +@@ -602,6 +602,51 @@ static int sysc_parse_and_check_child_range(struct sysc *ddata) + return 0; + } + ++/* Interconnect instances to probe before l4_per instances */ ++static struct resource early_bus_ranges[] = { ++ /* am3/4 l4_wkup */ ++ { .start = 0x44c00000, .end = 0x44c00000 + 0x300000, }, ++ /* omap4/5 and dra7 l4_cfg */ ++ { .start = 0x4a000000, .end = 0x4a000000 + 0x300000, }, ++ /* omap4 l4_wkup */ ++ { .start = 0x4a300000, .end = 0x4a300000 + 0x30000, }, ++ /* omap5 and dra7 l4_wkup without dra7 dcan segment */ ++ { .start = 0x4ae00000, .end = 0x4ae00000 + 0x30000, }, ++}; ++ ++static atomic_t sysc_defer = ATOMIC_INIT(10); ++ ++/** ++ * sysc_defer_non_critical - defer non_critical interconnect probing ++ * @ddata: device driver data ++ * ++ * We want to probe l4_cfg and l4_wkup interconnect instances before any ++ * l4_per instances as l4_per instances depend on resources on l4_cfg and ++ * l4_wkup interconnects. ++ */ ++static int sysc_defer_non_critical(struct sysc *ddata) ++{ ++ struct resource *res; ++ int i; ++ ++ if (!atomic_read(&sysc_defer)) ++ return 0; ++ ++ for (i = 0; i < ARRAY_SIZE(early_bus_ranges); i++) { ++ res = &early_bus_ranges[i]; ++ if (ddata->module_pa >= res->start && ++ ddata->module_pa <= res->end) { ++ atomic_set(&sysc_defer, 0); ++ ++ return 0; ++ } ++ } ++ ++ atomic_dec_if_positive(&sysc_defer); ++ ++ return -EPROBE_DEFER; ++} ++ + static struct device_node *stdout_path; + + static void sysc_init_stdout_path(struct sysc *ddata) +@@ -826,6 +871,10 @@ static int sysc_map_and_check_registers(struct sysc *ddata) + if (error) + return error; + ++ error = sysc_defer_non_critical(ddata); ++ if (error) ++ return error; ++ + sysc_check_children(ddata); + + error = sysc_parse_registers(ddata); +diff --git a/drivers/char/tpm/eventlog/common.c b/drivers/char/tpm/eventlog/common.c +index 7460f230bae4c..8512ec76d5260 100644 +--- a/drivers/char/tpm/eventlog/common.c ++++ b/drivers/char/tpm/eventlog/common.c +@@ -107,6 +107,9 @@ void tpm_bios_log_setup(struct tpm_chip *chip) + int log_version; + int rc = 0; + ++ if (chip->flags & TPM_CHIP_FLAG_VIRTUAL) ++ return; ++ + rc = tpm_read_log(chip); + if (rc < 0) + return; +diff --git a/drivers/char/tpm/eventlog/efi.c b/drivers/char/tpm/eventlog/efi.c +index 35229e5143cac..e6cb9d525e30c 100644 +--- a/drivers/char/tpm/eventlog/efi.c ++++ b/drivers/char/tpm/eventlog/efi.c +@@ -17,6 +17,7 @@ int tpm_read_log_efi(struct tpm_chip *chip) + { + + struct efi_tcg2_final_events_table *final_tbl = NULL; ++ int final_events_log_size = efi_tpm_final_log_size; + struct linux_efi_tpm_eventlog *log_tbl; + struct tpm_bios_log *log; + u32 log_size; +@@ -66,12 +67,12 @@ int tpm_read_log_efi(struct tpm_chip *chip) + ret = tpm_log_version; + + if (efi.tpm_final_log == EFI_INVALID_TABLE_ADDR || +- efi_tpm_final_log_size == 0 || ++ final_events_log_size == 0 || + tpm_log_version != EFI_TCG2_EVENT_LOG_FORMAT_TCG_2) + goto out; + + final_tbl = memremap(efi.tpm_final_log, +- sizeof(*final_tbl) + efi_tpm_final_log_size, ++ sizeof(*final_tbl) + final_events_log_size, + MEMREMAP_WB); + if (!final_tbl) { + pr_err("Could not map UEFI TPM final log\n"); +@@ -80,10 +81,18 @@ int tpm_read_log_efi(struct tpm_chip *chip) + goto out; + } + +- efi_tpm_final_log_size -= log_tbl->final_events_preboot_size; ++ /* ++ * The 'final events log' size excludes the 'final events preboot log' ++ * at its beginning. ++ */ ++ final_events_log_size -= log_tbl->final_events_preboot_size; + ++ /* ++ * Allocate memory for the 'combined log' where we will append the ++ * 'final events log' to. ++ */ + tmp = krealloc(log->bios_event_log, +- log_size + efi_tpm_final_log_size, ++ log_size + final_events_log_size, + GFP_KERNEL); + if (!tmp) { + kfree(log->bios_event_log); +@@ -94,15 +103,19 @@ int tpm_read_log_efi(struct tpm_chip *chip) + log->bios_event_log = tmp; + + /* +- * Copy any of the final events log that didn't also end up in the +- * main log. Events can be logged in both if events are generated ++ * Append any of the 'final events log' that didn't also end up in the ++ * 'main log'. Events can be logged in both if events are generated + * between GetEventLog() and ExitBootServices(). + */ + memcpy((void *)log->bios_event_log + log_size, + final_tbl->events + log_tbl->final_events_preboot_size, +- efi_tpm_final_log_size); ++ final_events_log_size); ++ /* ++ * The size of the 'combined log' is the size of the 'main log' plus ++ * the size of the 'final events log'. ++ */ + log->bios_event_log_end = log->bios_event_log + +- log_size + efi_tpm_final_log_size; ++ log_size + final_events_log_size; + + out: + memunmap(final_tbl); +diff --git a/drivers/clk/socfpga/clk-gate-a10.c b/drivers/clk/socfpga/clk-gate-a10.c +index cd5df91036142..d62778884208c 100644 +--- a/drivers/clk/socfpga/clk-gate-a10.c ++++ b/drivers/clk/socfpga/clk-gate-a10.c +@@ -146,6 +146,7 @@ static void __init __socfpga_gate_init(struct device_node *node, + if (IS_ERR(socfpga_clk->sys_mgr_base_addr)) { + pr_err("%s: failed to find altr,sys-mgr regmap!\n", + __func__); ++ kfree(socfpga_clk); + return; + } + } +diff --git a/drivers/crypto/omap-aes.c b/drivers/crypto/omap-aes.c +index 103e704c14697..72edb10181b86 100644 +--- a/drivers/crypto/omap-aes.c ++++ b/drivers/crypto/omap-aes.c +@@ -103,7 +103,7 @@ static int omap_aes_hw_init(struct omap_aes_dev *dd) + dd->err = 0; + } + +- err = pm_runtime_get_sync(dd->dev); ++ err = pm_runtime_resume_and_get(dd->dev); + if (err < 0) { + dev_err(dd->dev, "failed to get sync: %d\n", err); + return err; +@@ -1153,7 +1153,7 @@ static int omap_aes_probe(struct platform_device *pdev) + pm_runtime_set_autosuspend_delay(dev, DEFAULT_AUTOSUSPEND_DELAY); + + pm_runtime_enable(dev); +- err = pm_runtime_get_sync(dev); ++ err = pm_runtime_resume_and_get(dev); + if (err < 0) { + dev_err(dev, "%s: failed to get_sync(%d)\n", + __func__, err); +@@ -1318,7 +1318,7 @@ static int omap_aes_suspend(struct device *dev) + + static int omap_aes_resume(struct device *dev) + { +- pm_runtime_get_sync(dev); ++ pm_runtime_resume_and_get(dev); + return 0; + } + #endif +diff --git a/drivers/crypto/qat/qat_common/qat_algs.c b/drivers/crypto/qat/qat_common/qat_algs.c +index 0d67cf5ede514..6b8ad3d67481a 100644 +--- a/drivers/crypto/qat/qat_common/qat_algs.c ++++ b/drivers/crypto/qat/qat_common/qat_algs.c +@@ -715,7 +715,7 @@ static int qat_alg_sgl_to_bufl(struct qat_crypto_instance *inst, + struct qat_alg_buf_list *bufl; + struct qat_alg_buf_list *buflout = NULL; + dma_addr_t blp; +- dma_addr_t bloutp = 0; ++ dma_addr_t bloutp; + struct scatterlist *sg; + size_t sz_out, sz = struct_size(bufl, bufers, n + 1); + +@@ -727,6 +727,9 @@ static int qat_alg_sgl_to_bufl(struct qat_crypto_instance *inst, + if (unlikely(!bufl)) + return -ENOMEM; + ++ for_each_sg(sgl, sg, n, i) ++ bufl->bufers[i].addr = DMA_MAPPING_ERROR; ++ + blp = dma_map_single(dev, bufl, sz, DMA_TO_DEVICE); + if (unlikely(dma_mapping_error(dev, blp))) + goto err_in; +@@ -760,10 +763,14 @@ static int qat_alg_sgl_to_bufl(struct qat_crypto_instance *inst, + dev_to_node(&GET_DEV(inst->accel_dev))); + if (unlikely(!buflout)) + goto err_in; ++ ++ bufers = buflout->bufers; ++ for_each_sg(sglout, sg, n, i) ++ bufers[i].addr = DMA_MAPPING_ERROR; ++ + bloutp = dma_map_single(dev, buflout, sz_out, DMA_TO_DEVICE); + if (unlikely(dma_mapping_error(dev, bloutp))) + goto err_out; +- bufers = buflout->bufers; + for_each_sg(sglout, sg, n, i) { + int y = sg_nctr; + +diff --git a/drivers/crypto/stm32/stm32-cryp.c b/drivers/crypto/stm32/stm32-cryp.c +index ba5ea6434f9ca..9b3511236ba25 100644 +--- a/drivers/crypto/stm32/stm32-cryp.c ++++ b/drivers/crypto/stm32/stm32-cryp.c +@@ -537,7 +537,7 @@ static int stm32_cryp_hw_init(struct stm32_cryp *cryp) + int ret; + u32 cfg, hw_mode; + +- pm_runtime_get_sync(cryp->dev); ++ pm_runtime_resume_and_get(cryp->dev); + + /* Disable interrupt */ + stm32_cryp_write(cryp, CRYP_IMSCR, 0); +@@ -2054,7 +2054,7 @@ static int stm32_cryp_remove(struct platform_device *pdev) + if (!cryp) + return -ENODEV; + +- ret = pm_runtime_get_sync(cryp->dev); ++ ret = pm_runtime_resume_and_get(cryp->dev); + if (ret < 0) + return ret; + +diff --git a/drivers/crypto/stm32/stm32-hash.c b/drivers/crypto/stm32/stm32-hash.c +index cfc8e0e37beec..dcce15b558091 100644 +--- a/drivers/crypto/stm32/stm32-hash.c ++++ b/drivers/crypto/stm32/stm32-hash.c +@@ -810,7 +810,7 @@ static void stm32_hash_finish_req(struct ahash_request *req, int err) + static int stm32_hash_hw_init(struct stm32_hash_dev *hdev, + struct stm32_hash_request_ctx *rctx) + { +- pm_runtime_get_sync(hdev->dev); ++ pm_runtime_resume_and_get(hdev->dev); + + if (!(HASH_FLAGS_INIT & hdev->flags)) { + stm32_hash_write(hdev, HASH_CR, HASH_CR_INIT); +@@ -959,7 +959,7 @@ static int stm32_hash_export(struct ahash_request *req, void *out) + u32 *preg; + unsigned int i; + +- pm_runtime_get_sync(hdev->dev); ++ pm_runtime_resume_and_get(hdev->dev); + + while ((stm32_hash_read(hdev, HASH_SR) & HASH_SR_BUSY)) + cpu_relax(); +@@ -997,7 +997,7 @@ static int stm32_hash_import(struct ahash_request *req, const void *in) + + preg = rctx->hw_context; + +- pm_runtime_get_sync(hdev->dev); ++ pm_runtime_resume_and_get(hdev->dev); + + stm32_hash_write(hdev, HASH_IMR, *preg++); + stm32_hash_write(hdev, HASH_STR, *preg++); +@@ -1553,7 +1553,7 @@ static int stm32_hash_remove(struct platform_device *pdev) + if (!hdev) + return -ENODEV; + +- ret = pm_runtime_get_sync(hdev->dev); ++ ret = pm_runtime_resume_and_get(hdev->dev); + if (ret < 0) + return ret; + +diff --git a/drivers/extcon/extcon-arizona.c b/drivers/extcon/extcon-arizona.c +index e970134c95fab..9a6103ac7118a 100644 +--- a/drivers/extcon/extcon-arizona.c ++++ b/drivers/extcon/extcon-arizona.c +@@ -597,7 +597,7 @@ static irqreturn_t arizona_hpdet_irq(int irq, void *data) + struct arizona *arizona = info->arizona; + int id_gpio = arizona->pdata.hpdet_id_gpio; + unsigned int report = EXTCON_JACK_HEADPHONE; +- int ret, reading; ++ int ret, reading, state; + bool mic = false; + + mutex_lock(&info->lock); +@@ -610,12 +610,11 @@ static irqreturn_t arizona_hpdet_irq(int irq, void *data) + } + + /* If the cable was removed while measuring ignore the result */ +- ret = extcon_get_state(info->edev, EXTCON_MECHANICAL); +- if (ret < 0) { +- dev_err(arizona->dev, "Failed to check cable state: %d\n", +- ret); ++ state = extcon_get_state(info->edev, EXTCON_MECHANICAL); ++ if (state < 0) { ++ dev_err(arizona->dev, "Failed to check cable state: %d\n", state); + goto out; +- } else if (!ret) { ++ } else if (!state) { + dev_dbg(arizona->dev, "Ignoring HPDET for removed cable\n"); + goto done; + } +@@ -668,7 +667,7 @@ done: + ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC); + + /* If we have a mic then reenable MICDET */ +- if (mic || info->mic) ++ if (state && (mic || info->mic)) + arizona_start_mic(info); + + if (info->hpdet_active) { +@@ -676,7 +675,9 @@ done: + info->hpdet_active = false; + } + +- info->hpdet_done = true; ++ /* Do not set hp_det done when the cable has been unplugged */ ++ if (state) ++ info->hpdet_done = true; + + out: + mutex_unlock(&info->lock); +@@ -1724,25 +1725,6 @@ static int arizona_extcon_remove(struct platform_device *pdev) + bool change; + int ret; + +- ret = regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1, +- ARIZONA_MICD_ENA, 0, +- &change); +- if (ret < 0) { +- dev_err(&pdev->dev, "Failed to disable micd on remove: %d\n", +- ret); +- } else if (change) { +- regulator_disable(info->micvdd); +- pm_runtime_put(info->dev); +- } +- +- gpiod_put(info->micd_pol_gpio); +- +- pm_runtime_disable(&pdev->dev); +- +- regmap_update_bits(arizona->regmap, +- ARIZONA_MICD_CLAMP_CONTROL, +- ARIZONA_MICD_CLAMP_MODE_MASK, 0); +- + if (info->micd_clamp) { + jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE; + jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL; +@@ -1758,10 +1740,31 @@ static int arizona_extcon_remove(struct platform_device *pdev) + arizona_free_irq(arizona, jack_irq_rise, info); + arizona_free_irq(arizona, jack_irq_fall, info); + cancel_delayed_work_sync(&info->hpdet_work); ++ cancel_delayed_work_sync(&info->micd_detect_work); ++ cancel_delayed_work_sync(&info->micd_timeout_work); ++ ++ ret = regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1, ++ ARIZONA_MICD_ENA, 0, ++ &change); ++ if (ret < 0) { ++ dev_err(&pdev->dev, "Failed to disable micd on remove: %d\n", ++ ret); ++ } else if (change) { ++ regulator_disable(info->micvdd); ++ pm_runtime_put(info->dev); ++ } ++ ++ regmap_update_bits(arizona->regmap, ++ ARIZONA_MICD_CLAMP_CONTROL, ++ ARIZONA_MICD_CLAMP_MODE_MASK, 0); + regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE, + ARIZONA_JD1_ENA, 0); + arizona_clk32k_disable(arizona); + ++ gpiod_put(info->micd_pol_gpio); ++ ++ pm_runtime_disable(&pdev->dev); ++ + return 0; + } + +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_irq.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_irq.c +index 2a3f5ec298dbc..76429932035e1 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_irq.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_irq.c +@@ -469,7 +469,7 @@ void amdgpu_irq_gpu_reset_resume_helper(struct amdgpu_device *adev) + for (j = 0; j < AMDGPU_MAX_IRQ_SRC_ID; ++j) { + struct amdgpu_irq_src *src = adev->irq.client[i].sources[j]; + +- if (!src) ++ if (!src || !src->funcs || !src->funcs->set) + continue; + for (k = 0; k < src->num_types; k++) + amdgpu_irq_update(adev, src, k); +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c +index c6a1dfe79e809..91e3a87b1de83 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c +@@ -984,7 +984,7 @@ static void amdgpu_ttm_tt_unpin_userptr(struct ttm_tt *ttm) + DMA_BIDIRECTIONAL : DMA_TO_DEVICE; + + /* double check that we don't free the table twice */ +- if (!ttm->sg->sgl) ++ if (!ttm->sg || !ttm->sg->sgl) + return; + + /* unmap the pages mapped to the device */ +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c +index b2c364b8695f9..cfa8324b9f51a 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c +@@ -231,7 +231,7 @@ int amdgpu_uvd_sw_init(struct amdgpu_device *adev) + if ((adev->asic_type == CHIP_POLARIS10 || + adev->asic_type == CHIP_POLARIS11) && + (adev->uvd.fw_version < FW_1_66_16)) +- DRM_ERROR("POLARIS10/11 UVD firmware version %hu.%hu is too old.\n", ++ DRM_ERROR("POLARIS10/11 UVD firmware version %u.%u is too old.\n", + version_major, version_minor); + } else { + unsigned int enc_major, enc_minor, dec_minor; +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_xgmi.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_xgmi.c +index 65aae75f80fd5..ce1048bad1586 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_xgmi.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_xgmi.c +@@ -311,15 +311,22 @@ int amdgpu_xgmi_update_topology(struct amdgpu_hive_info *hive, struct amdgpu_dev + } + + ++/* ++ * NOTE psp_xgmi_node_info.num_hops layout is as follows: ++ * num_hops[7:6] = link type (0 = xGMI2, 1 = xGMI3, 2/3 = reserved) ++ * num_hops[5:3] = reserved ++ * num_hops[2:0] = number of hops ++ */ + int amdgpu_xgmi_get_hops_count(struct amdgpu_device *adev, + struct amdgpu_device *peer_adev) + { + struct psp_xgmi_topology_info *top = &adev->psp.xgmi_context.top_info; ++ uint8_t num_hops_mask = 0x7; + int i; + + for (i = 0 ; i < top->num_nodes; ++i) + if (top->nodes[i].node_id == peer_adev->gmc.xgmi.node_id) +- return top->nodes[i].num_hops; ++ return top->nodes[i].num_hops & num_hops_mask; + return -EINVAL; + } + +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_debugfs.c b/drivers/gpu/drm/amd/amdkfd/kfd_debugfs.c +index 511712c2e382d..673d5e34f213c 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_debugfs.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_debugfs.c +@@ -33,6 +33,11 @@ static int kfd_debugfs_open(struct inode *inode, struct file *file) + + return single_open(file, show, NULL); + } ++static int kfd_debugfs_hang_hws_read(struct seq_file *m, void *data) ++{ ++ seq_printf(m, "echo gpu_id > hang_hws\n"); ++ return 0; ++} + + static ssize_t kfd_debugfs_hang_hws_write(struct file *file, + const char __user *user_buf, size_t size, loff_t *ppos) +@@ -94,7 +99,7 @@ void kfd_debugfs_init(void) + debugfs_create_file("rls", S_IFREG | 0444, debugfs_root, + kfd_debugfs_rls_by_device, &kfd_debugfs_fops); + debugfs_create_file("hang_hws", S_IFREG | 0200, debugfs_root, +- NULL, &kfd_debugfs_hang_hws_fops); ++ kfd_debugfs_hang_hws_read, &kfd_debugfs_hang_hws_fops); + } + + void kfd_debugfs_fini(void) +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +index e9a2784400792..ab69898c9cb72 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +@@ -1011,6 +1011,9 @@ static int set_sched_resources(struct device_queue_manager *dqm) + + static int initialize_cpsch(struct device_queue_manager *dqm) + { ++ uint64_t num_sdma_queues; ++ uint64_t num_xgmi_sdma_queues; ++ + pr_debug("num of pipes: %d\n", get_pipes_per_mec(dqm)); + + mutex_init(&dqm->lock_hidden); +@@ -1019,8 +1022,18 @@ static int initialize_cpsch(struct device_queue_manager *dqm) + dqm->sdma_queue_count = 0; + dqm->xgmi_sdma_queue_count = 0; + dqm->active_runlist = false; +- dqm->sdma_bitmap = ~0ULL >> (64 - get_num_sdma_queues(dqm)); +- dqm->xgmi_sdma_bitmap = ~0ULL >> (64 - get_num_xgmi_sdma_queues(dqm)); ++ ++ num_sdma_queues = get_num_sdma_queues(dqm); ++ if (num_sdma_queues >= BITS_PER_TYPE(dqm->sdma_bitmap)) ++ dqm->sdma_bitmap = ULLONG_MAX; ++ else ++ dqm->sdma_bitmap = (BIT_ULL(num_sdma_queues) - 1); ++ ++ num_xgmi_sdma_queues = get_num_xgmi_sdma_queues(dqm); ++ if (num_xgmi_sdma_queues >= BITS_PER_TYPE(dqm->xgmi_sdma_bitmap)) ++ dqm->xgmi_sdma_bitmap = ULLONG_MAX; ++ else ++ dqm->xgmi_sdma_bitmap = (BIT_ULL(num_xgmi_sdma_queues) - 1); + + INIT_WORK(&dqm->hw_exception_work, kfd_process_hw_exception); + +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 fbbe611d4873f..1aec841fda359 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -5372,10 +5372,6 @@ static int get_cursor_position(struct drm_plane *plane, struct drm_crtc *crtc, + int x, y; + int xorigin = 0, yorigin = 0; + +- position->enable = false; +- position->x = 0; +- position->y = 0; +- + if (!crtc || !plane->state->fb) + return 0; + +@@ -5427,7 +5423,7 @@ static void handle_cursor_update(struct drm_plane *plane, + struct dm_crtc_state *crtc_state = crtc ? to_dm_crtc_state(crtc->state) : NULL; + struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc); + uint64_t address = afb ? afb->address : 0; +- struct dc_cursor_position position; ++ struct dc_cursor_position position = {0}; + struct dc_cursor_attributes attributes; + int ret; + +@@ -7330,7 +7326,7 @@ static int amdgpu_dm_atomic_check(struct drm_device *dev, + } + + #if defined(CONFIG_DRM_AMD_DC_DCN) +- if (adev->asic_type >= CHIP_NAVI10) { ++ if (dc_resource_is_dsc_encoding_supported(dc)) { + for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) { + if (drm_atomic_crtc_needs_modeset(new_crtc_state)) { + ret = add_affected_mst_dsc_crtcs(state, crtc); +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc.c b/drivers/gpu/drm/amd/display/dc/core/dc.c +index 68d56a91d44b7..092db590087c9 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc.c +@@ -1961,7 +1961,8 @@ static void commit_planes_do_stream_update(struct dc *dc, + if (pipe_ctx->stream_res.audio && !dc->debug.az_endpoint_mute_only) + pipe_ctx->stream_res.audio->funcs->az_disable(pipe_ctx->stream_res.audio); + +- dc->hwss.optimize_bandwidth(dc, dc->current_state); ++ dc->optimized_required = true; ++ + } else { + if (!dc->optimize_seamless_boot) + dc->hwss.prepare_bandwidth(dc, dc->current_state); +diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_mode_vba_20.c b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_mode_vba_20.c +index 6c6c486b774a4..945d23ca36777 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_mode_vba_20.c ++++ b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_mode_vba_20.c +@@ -3435,6 +3435,7 @@ void dml20_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_l + mode_lib->vba.DCCEnabledInAnyPlane = true; + } + } ++ mode_lib->vba.UrgentLatency = mode_lib->vba.UrgentLatencyPixelDataOnly; + for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { + locals->FabricAndDRAMBandwidthPerState[i] = dml_min( + mode_lib->vba.DRAMSpeedPerState[i] * mode_lib->vba.NumberOfChannels +diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_mode_vba_20v2.c b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_mode_vba_20v2.c +index 0fafd693ffb41..5b5ed1be19bad 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_mode_vba_20v2.c ++++ b/drivers/gpu/drm/amd/display/dc/dml/dcn20/display_mode_vba_20v2.c +@@ -3467,6 +3467,7 @@ void dml20v2_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode + mode_lib->vba.DCCEnabledInAnyPlane = true; + } + } ++ mode_lib->vba.UrgentLatency = mode_lib->vba.UrgentLatencyPixelDataOnly; + for (i = 0; i <= mode_lib->vba.soc.num_states; i++) { + locals->FabricAndDRAMBandwidthPerState[i] = dml_min( + mode_lib->vba.DRAMSpeedPerState[i] * mode_lib->vba.NumberOfChannels +diff --git a/drivers/gpu/drm/drm_panel_orientation_quirks.c b/drivers/gpu/drm/drm_panel_orientation_quirks.c +index 58f5dc2f6dd52..f6bdec7fa9253 100644 +--- a/drivers/gpu/drm/drm_panel_orientation_quirks.c ++++ b/drivers/gpu/drm/drm_panel_orientation_quirks.c +@@ -84,6 +84,13 @@ static const struct drm_dmi_panel_orientation_data itworks_tw891 = { + .orientation = DRM_MODE_PANEL_ORIENTATION_RIGHT_UP, + }; + ++static const struct drm_dmi_panel_orientation_data onegx1_pro = { ++ .width = 1200, ++ .height = 1920, ++ .bios_dates = (const char * const []){ "12/17/2020", NULL }, ++ .orientation = DRM_MODE_PANEL_ORIENTATION_RIGHT_UP, ++}; ++ + static const struct drm_dmi_panel_orientation_data lcd720x1280_rightside_up = { + .width = 720, + .height = 1280, +@@ -211,6 +218,13 @@ static const struct dmi_system_id orientation_data[] = { + DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "Lenovo ideapad D330-10IGM"), + }, + .driver_data = (void *)&lcd1200x1920_rightside_up, ++ }, { /* OneGX1 Pro */ ++ .matches = { ++ DMI_EXACT_MATCH(DMI_SYS_VENDOR, "SYSTEM_MANUFACTURER"), ++ DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "SYSTEM_PRODUCT_NAME"), ++ DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "Default string"), ++ }, ++ .driver_data = (void *)&onegx1_pro, + }, { /* VIOS LTH17 */ + .matches = { + DMI_EXACT_MATCH(DMI_SYS_VENDOR, "VIOS"), +diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c +index ade607d93e45d..91afeca0c6f82 100644 +--- a/drivers/gpu/drm/i915/intel_pm.c ++++ b/drivers/gpu/drm/i915/intel_pm.c +@@ -2966,7 +2966,7 @@ int ilk_wm_max_level(const struct drm_i915_private *dev_priv) + + static void intel_print_wm_latency(struct drm_i915_private *dev_priv, + const char *name, +- const u16 wm[8]) ++ const u16 wm[]) + { + int level, max_level = ilk_wm_max_level(dev_priv); + +diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_cmd_encoder.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_cmd_encoder.c +index eeef41fcd4e1a..0425400f44db9 100644 +--- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_cmd_encoder.c ++++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_cmd_encoder.c +@@ -41,7 +41,7 @@ static int pingpong_tearcheck_setup(struct drm_encoder *encoder, + { + struct mdp5_kms *mdp5_kms = get_kms(encoder); + struct device *dev = encoder->dev->dev; +- u32 total_lines_x100, vclks_line, cfg; ++ u32 total_lines, vclks_line, cfg; + long vsync_clk_speed; + struct mdp5_hw_mixer *mixer = mdp5_crtc_get_mixer(encoder->crtc); + int pp_id = mixer->pp; +@@ -51,8 +51,8 @@ static int pingpong_tearcheck_setup(struct drm_encoder *encoder, + return -EINVAL; + } + +- total_lines_x100 = mode->vtotal * drm_mode_vrefresh(mode); +- if (!total_lines_x100) { ++ total_lines = mode->vtotal * drm_mode_vrefresh(mode); ++ if (!total_lines) { + DRM_DEV_ERROR(dev, "%s: vtotal(%d) or vrefresh(%d) is 0\n", + __func__, mode->vtotal, drm_mode_vrefresh(mode)); + return -EINVAL; +@@ -64,15 +64,23 @@ static int pingpong_tearcheck_setup(struct drm_encoder *encoder, + vsync_clk_speed); + return -EINVAL; + } +- vclks_line = vsync_clk_speed * 100 / total_lines_x100; ++ vclks_line = vsync_clk_speed / total_lines; + + cfg = MDP5_PP_SYNC_CONFIG_VSYNC_COUNTER_EN + | MDP5_PP_SYNC_CONFIG_VSYNC_IN_EN; + cfg |= MDP5_PP_SYNC_CONFIG_VSYNC_COUNT(vclks_line); + ++ /* ++ * Tearcheck emits a blanking signal every vclks_line * vtotal * 2 ticks on ++ * the vsync_clk equating to roughly half the desired panel refresh rate. ++ * This is only necessary as stability fallback if interrupts from the ++ * panel arrive too late or not at all, but is currently used by default ++ * because these panel interrupts are not wired up yet. ++ */ + mdp5_write(mdp5_kms, REG_MDP5_PP_SYNC_CONFIG_VSYNC(pp_id), cfg); + mdp5_write(mdp5_kms, +- REG_MDP5_PP_SYNC_CONFIG_HEIGHT(pp_id), 0xfff0); ++ REG_MDP5_PP_SYNC_CONFIG_HEIGHT(pp_id), (2 * mode->vtotal)); ++ + mdp5_write(mdp5_kms, + REG_MDP5_PP_VSYNC_INIT_VAL(pp_id), mode->vdisplay); + mdp5_write(mdp5_kms, REG_MDP5_PP_RD_PTR_IRQ(pp_id), mode->vdisplay + 1); +diff --git a/drivers/gpu/drm/qxl/qxl_display.c b/drivers/gpu/drm/qxl/qxl_display.c +index 9abf3dc5ef990..a6ee10cbcfdd6 100644 +--- a/drivers/gpu/drm/qxl/qxl_display.c ++++ b/drivers/gpu/drm/qxl/qxl_display.c +@@ -1237,6 +1237,10 @@ int qxl_modeset_init(struct qxl_device *qdev) + + void qxl_modeset_fini(struct qxl_device *qdev) + { ++ if (qdev->dumb_shadow_bo) { ++ drm_gem_object_put(&qdev->dumb_shadow_bo->tbo.base); ++ qdev->dumb_shadow_bo = NULL; ++ } + qxl_destroy_monitors_object(qdev); + drm_mode_config_cleanup(&qdev->ddev); + } +diff --git a/drivers/gpu/drm/vkms/vkms_crtc.c b/drivers/gpu/drm/vkms/vkms_crtc.c +index 927dafaebc766..8b01fae65f43b 100644 +--- a/drivers/gpu/drm/vkms/vkms_crtc.c ++++ b/drivers/gpu/drm/vkms/vkms_crtc.c +@@ -20,7 +20,8 @@ static enum hrtimer_restart vkms_vblank_simulate(struct hrtimer *timer) + + ret_overrun = hrtimer_forward_now(&output->vblank_hrtimer, + output->period_ns); +- WARN_ON(ret_overrun != 1); ++ if (ret_overrun != 1) ++ pr_warn("%s: vblank timer overrun\n", __func__); + + ret = drm_crtc_handle_vblank(crtc); + if (!ret) +diff --git a/drivers/hwtracing/intel_th/gth.c b/drivers/hwtracing/intel_th/gth.c +index f72803a023910..28509b02a0b56 100644 +--- a/drivers/hwtracing/intel_th/gth.c ++++ b/drivers/hwtracing/intel_th/gth.c +@@ -543,7 +543,7 @@ static void intel_th_gth_disable(struct intel_th_device *thdev, + output->active = false; + + for_each_set_bit(master, gth->output[output->port].master, +- TH_CONFIGURABLE_MASTERS) { ++ TH_CONFIGURABLE_MASTERS + 1) { + gth_master_set(gth, master, -1); + } + spin_unlock(>h->gth_lock); +@@ -697,7 +697,7 @@ static void intel_th_gth_unassign(struct intel_th_device *thdev, + othdev->output.port = -1; + othdev->output.active = false; + gth->output[port].output = NULL; +- for (master = 0; master <= TH_CONFIGURABLE_MASTERS; master++) ++ for (master = 0; master < TH_CONFIGURABLE_MASTERS + 1; master++) + if (gth->master[master] == port) + gth->master[master] = -1; + spin_unlock(>h->gth_lock); +diff --git a/drivers/hwtracing/intel_th/pci.c b/drivers/hwtracing/intel_th/pci.c +index d7d99acac52f2..a723c8c330876 100644 +--- a/drivers/hwtracing/intel_th/pci.c ++++ b/drivers/hwtracing/intel_th/pci.c +@@ -268,6 +268,16 @@ static const struct pci_device_id intel_th_pci_id_table[] = { + PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x1bcc), + .driver_data = (kernel_ulong_t)&intel_th_2x, + }, ++ { ++ /* Alder Lake-M */ ++ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x54a6), ++ .driver_data = (kernel_ulong_t)&intel_th_2x, ++ }, ++ { ++ /* Rocket Lake CPU */ ++ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x4c19), ++ .driver_data = (kernel_ulong_t)&intel_th_2x, ++ }, + { 0 }, + }; + +diff --git a/drivers/input/touchscreen/ili210x.c b/drivers/input/touchscreen/ili210x.c +index f4ebdab062806..22839dde1d09f 100644 +--- a/drivers/input/touchscreen/ili210x.c ++++ b/drivers/input/touchscreen/ili210x.c +@@ -109,7 +109,7 @@ static bool ili210x_touchdata_to_coords(struct ili210x *priv, u8 *touchdata, + if (finger >= ILI210X_TOUCHES) + return false; + +- if (touchdata[0] & BIT(finger)) ++ if (!(touchdata[0] & BIT(finger))) + return false; + + *x = get_unaligned_be16(touchdata + 1 + (finger * 4) + 0); +diff --git a/drivers/irqchip/irq-gic-v3.c b/drivers/irqchip/irq-gic-v3.c +index 446603efbc90b..9d0b42cb9903e 100644 +--- a/drivers/irqchip/irq-gic-v3.c ++++ b/drivers/irqchip/irq-gic-v3.c +@@ -621,6 +621,10 @@ static asmlinkage void __exception_irq_entry gic_handle_irq(struct pt_regs *regs + + irqnr = gic_read_iar(); + ++ /* Check for special IDs first */ ++ if ((irqnr >= 1020 && irqnr <= 1023)) ++ return; ++ + if (gic_supports_nmi() && + unlikely(gic_read_rpr() == GICD_INT_NMI_PRI)) { + gic_handle_nmi(irqnr, regs); +@@ -632,10 +636,6 @@ static asmlinkage void __exception_irq_entry gic_handle_irq(struct pt_regs *regs + gic_arch_enable_irqs(); + } + +- /* Check for special IDs first */ +- if ((irqnr >= 1020 && irqnr <= 1023)) +- return; +- + /* Treat anything but SGIs in a uniform way */ + if (likely(irqnr > 15)) { + int err; +diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c +index c967c2cdba870..9f4d657dd36c8 100644 +--- a/drivers/md/dm-integrity.c ++++ b/drivers/md/dm-integrity.c +@@ -3762,6 +3762,7 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned argc, char **argv) + if (val >= (uint64_t)UINT_MAX * 1000 / HZ) { + r = -EINVAL; + ti->error = "Invalid bitmap_flush_interval argument"; ++ goto bad; + } + ic->bitmap_flush_interval = msecs_to_jiffies(val); + } else if (!strncmp(opt_string, "internal_hash:", strlen("internal_hash:"))) { +diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c +index 70210a7e4bc80..5e73cc6ad0ce4 100644 +--- a/drivers/md/dm-raid.c ++++ b/drivers/md/dm-raid.c +@@ -1892,6 +1892,14 @@ static bool rs_takeover_requested(struct raid_set *rs) + return rs->md.new_level != rs->md.level; + } + ++/* True if layout is set to reshape. */ ++static bool rs_is_layout_change(struct raid_set *rs, bool use_mddev) ++{ ++ return (use_mddev ? rs->md.delta_disks : rs->delta_disks) || ++ rs->md.new_layout != rs->md.layout || ++ rs->md.new_chunk_sectors != rs->md.chunk_sectors; ++} ++ + /* True if @rs is requested to reshape by ctr */ + static bool rs_reshape_requested(struct raid_set *rs) + { +@@ -1904,9 +1912,7 @@ static bool rs_reshape_requested(struct raid_set *rs) + if (rs_is_raid0(rs)) + return false; + +- change = mddev->new_layout != mddev->layout || +- mddev->new_chunk_sectors != mddev->chunk_sectors || +- rs->delta_disks; ++ change = rs_is_layout_change(rs, false); + + /* Historical case to support raid1 reshape without delta disks */ + if (rs_is_raid1(rs)) { +@@ -2843,7 +2849,7 @@ static sector_t _get_reshape_sectors(struct raid_set *rs) + } + + /* +- * ++ * Reshape: + * - change raid layout + * - change chunk size + * - add disks +@@ -2952,6 +2958,20 @@ static int rs_setup_reshape(struct raid_set *rs) + return r; + } + ++/* ++ * If the md resync thread has updated superblock with max reshape position ++ * at the end of a reshape but not (yet) reset the layout configuration ++ * changes -> reset the latter. ++ */ ++static void rs_reset_inconclusive_reshape(struct raid_set *rs) ++{ ++ if (!rs_is_reshaping(rs) && rs_is_layout_change(rs, true)) { ++ rs_set_cur(rs); ++ rs->md.delta_disks = 0; ++ rs->md.reshape_backwards = 0; ++ } ++} ++ + /* + * Enable/disable discard support on RAID set depending on + * RAID level and discard properties of underlying RAID members. +@@ -3216,11 +3236,14 @@ static int raid_ctr(struct dm_target *ti, unsigned int argc, char **argv) + if (r) + goto bad; + ++ /* Catch any inconclusive reshape superblock content. */ ++ rs_reset_inconclusive_reshape(rs); ++ + /* Start raid set read-only and assumed clean to change in raid_resume() */ + rs->md.ro = 1; + rs->md.in_sync = 1; + +- /* Keep array frozen */ ++ /* Keep array frozen until resume. */ + set_bit(MD_RECOVERY_FROZEN, &rs->md.recovery); + + /* Has to be held on running the array */ +@@ -3234,7 +3257,6 @@ static int raid_ctr(struct dm_target *ti, unsigned int argc, char **argv) + } + + r = md_start(&rs->md); +- + if (r) { + ti->error = "Failed to start raid array"; + mddev_unlock(&rs->md); +diff --git a/drivers/md/dm-rq.c b/drivers/md/dm-rq.c +index 2bd2444ad99c6..6bc61927d3205 100644 +--- a/drivers/md/dm-rq.c ++++ b/drivers/md/dm-rq.c +@@ -572,6 +572,7 @@ out_tag_set: + blk_mq_free_tag_set(md->tag_set); + out_kfree_tag_set: + kfree(md->tag_set); ++ md->tag_set = NULL; + + return err; + } +@@ -581,6 +582,7 @@ void dm_mq_cleanup_mapped_device(struct mapped_device *md) + if (md->tag_set) { + blk_mq_free_tag_set(md->tag_set); + kfree(md->tag_set); ++ md->tag_set = NULL; + } + } + +diff --git a/drivers/md/persistent-data/dm-btree-internal.h b/drivers/md/persistent-data/dm-btree-internal.h +index a240990a7f333..5673f8eb5f88f 100644 +--- a/drivers/md/persistent-data/dm-btree-internal.h ++++ b/drivers/md/persistent-data/dm-btree-internal.h +@@ -34,12 +34,12 @@ struct node_header { + __le32 max_entries; + __le32 value_size; + __le32 padding; +-} __packed; ++} __attribute__((packed, aligned(8))); + + struct btree_node { + struct node_header header; + __le64 keys[0]; +-} __packed; ++} __attribute__((packed, aligned(8))); + + + /* +diff --git a/drivers/md/persistent-data/dm-space-map-common.c b/drivers/md/persistent-data/dm-space-map-common.c +index d8b4125e338ca..a213bf11738fb 100644 +--- a/drivers/md/persistent-data/dm-space-map-common.c ++++ b/drivers/md/persistent-data/dm-space-map-common.c +@@ -339,6 +339,8 @@ int sm_ll_find_free_block(struct ll_disk *ll, dm_block_t begin, + */ + begin = do_div(index_begin, ll->entries_per_block); + end = do_div(end, ll->entries_per_block); ++ if (end == 0) ++ end = ll->entries_per_block; + + for (i = index_begin; i < index_end; i++, begin = 0) { + struct dm_block *blk; +diff --git a/drivers/md/persistent-data/dm-space-map-common.h b/drivers/md/persistent-data/dm-space-map-common.h +index 8de63ce39bdd5..87e17909ef521 100644 +--- a/drivers/md/persistent-data/dm-space-map-common.h ++++ b/drivers/md/persistent-data/dm-space-map-common.h +@@ -33,7 +33,7 @@ struct disk_index_entry { + __le64 blocknr; + __le32 nr_free; + __le32 none_free_before; +-} __packed; ++} __attribute__ ((packed, aligned(8))); + + + #define MAX_METADATA_BITMAPS 255 +@@ -43,7 +43,7 @@ struct disk_metadata_index { + __le64 blocknr; + + struct disk_index_entry index[MAX_METADATA_BITMAPS]; +-} __packed; ++} __attribute__ ((packed, aligned(8))); + + struct ll_disk; + +@@ -86,7 +86,7 @@ struct disk_sm_root { + __le64 nr_allocated; + __le64 bitmap_root; + __le64 ref_count_root; +-} __packed; ++} __attribute__ ((packed, aligned(8))); + + #define ENTRIES_PER_BYTE 4 + +@@ -94,7 +94,7 @@ struct disk_bitmap_header { + __le32 csum; + __le32 not_used; + __le64 blocknr; +-} __packed; ++} __attribute__ ((packed, aligned(8))); + + enum allocation_event { + SM_NONE, +diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c +index c7137f50bd1d3..a715cb88052c2 100644 +--- a/drivers/md/raid1.c ++++ b/drivers/md/raid1.c +@@ -458,6 +458,8 @@ static void raid1_end_write_request(struct bio *bio) + if (!test_bit(Faulty, &rdev->flags)) + set_bit(R1BIO_WriteError, &r1_bio->state); + else { ++ /* Fail the request */ ++ set_bit(R1BIO_Degraded, &r1_bio->state); + /* Finished with this branch */ + r1_bio->bios[mirror] = NULL; + to_put = bio; +diff --git a/drivers/media/dvb-core/dvbdev.c b/drivers/media/dvb-core/dvbdev.c +index 032b6d7dd5821..197cf17b246f7 100644 +--- a/drivers/media/dvb-core/dvbdev.c ++++ b/drivers/media/dvb-core/dvbdev.c +@@ -241,6 +241,7 @@ static void dvb_media_device_free(struct dvb_device *dvbdev) + + if (dvbdev->adapter->conn) { + media_device_unregister_entity(dvbdev->adapter->conn); ++ kfree(dvbdev->adapter->conn); + dvbdev->adapter->conn = NULL; + kfree(dvbdev->adapter->conn_pads); + dvbdev->adapter->conn_pads = NULL; +diff --git a/drivers/media/i2c/adv7511-v4l2.c b/drivers/media/i2c/adv7511-v4l2.c +index 62763ec4cd073..809fa44ed9880 100644 +--- a/drivers/media/i2c/adv7511-v4l2.c ++++ b/drivers/media/i2c/adv7511-v4l2.c +@@ -1964,7 +1964,7 @@ static int adv7511_remove(struct i2c_client *client) + + adv7511_set_isr(sd, false); + adv7511_init_setup(sd); +- cancel_delayed_work(&state->edid_handler); ++ cancel_delayed_work_sync(&state->edid_handler); + i2c_unregister_device(state->i2c_edid); + i2c_unregister_device(state->i2c_cec); + i2c_unregister_device(state->i2c_pktmem); +diff --git a/drivers/media/i2c/adv7604.c b/drivers/media/i2c/adv7604.c +index 2dedd6ebb2361..b887299ac195f 100644 +--- a/drivers/media/i2c/adv7604.c ++++ b/drivers/media/i2c/adv7604.c +@@ -3606,7 +3606,7 @@ static int adv76xx_remove(struct i2c_client *client) + io_write(sd, 0x6e, 0); + io_write(sd, 0x73, 0); + +- cancel_delayed_work(&state->delayed_work_enable_hotplug); ++ cancel_delayed_work_sync(&state->delayed_work_enable_hotplug); + v4l2_async_unregister_subdev(sd); + media_entity_cleanup(&sd->entity); + adv76xx_unregister_clients(to_state(sd)); +diff --git a/drivers/media/i2c/adv7842.c b/drivers/media/i2c/adv7842.c +index 885619841719b..02cbab826d0b6 100644 +--- a/drivers/media/i2c/adv7842.c ++++ b/drivers/media/i2c/adv7842.c +@@ -3586,7 +3586,7 @@ static int adv7842_remove(struct i2c_client *client) + struct adv7842_state *state = to_state(sd); + + adv7842_irq_enable(sd, false); +- cancel_delayed_work(&state->delayed_work_enable_hotplug); ++ cancel_delayed_work_sync(&state->delayed_work_enable_hotplug); + v4l2_device_unregister_subdev(sd); + media_entity_cleanup(&sd->entity); + adv7842_unregister_clients(sd); +diff --git a/drivers/media/i2c/tc358743.c b/drivers/media/i2c/tc358743.c +index cff99cf61ed4d..114c084c4aec1 100644 +--- a/drivers/media/i2c/tc358743.c ++++ b/drivers/media/i2c/tc358743.c +@@ -2192,7 +2192,7 @@ static int tc358743_remove(struct i2c_client *client) + del_timer_sync(&state->timer); + flush_work(&state->work_i2c_poll); + } +- cancel_delayed_work(&state->delayed_work_enable_hotplug); ++ cancel_delayed_work_sync(&state->delayed_work_enable_hotplug); + cec_unregister_adapter(state->cec_adap); + v4l2_async_unregister_subdev(sd); + v4l2_device_unregister_subdev(sd); +diff --git a/drivers/media/i2c/tda1997x.c b/drivers/media/i2c/tda1997x.c +index 5e68182001ecc..e43d8327b8103 100644 +--- a/drivers/media/i2c/tda1997x.c ++++ b/drivers/media/i2c/tda1997x.c +@@ -2804,7 +2804,7 @@ static int tda1997x_remove(struct i2c_client *client) + media_entity_cleanup(&sd->entity); + v4l2_ctrl_handler_free(&state->hdl); + regulator_bulk_disable(TDA1997X_NUM_SUPPLIES, state->supplies); +- cancel_delayed_work(&state->delayed_work_enable_hpd); ++ cancel_delayed_work_sync(&state->delayed_work_enable_hpd); + mutex_destroy(&state->page_lock); + mutex_destroy(&state->lock); + +diff --git a/drivers/media/pci/saa7164/saa7164-encoder.c b/drivers/media/pci/saa7164/saa7164-encoder.c +index 3fca7257a7201..df494644b5b64 100644 +--- a/drivers/media/pci/saa7164/saa7164-encoder.c ++++ b/drivers/media/pci/saa7164/saa7164-encoder.c +@@ -1008,7 +1008,7 @@ int saa7164_encoder_register(struct saa7164_port *port) + printk(KERN_ERR "%s() failed (errno = %d), NO PCI configuration\n", + __func__, result); + result = -ENOMEM; +- goto failed; ++ goto fail_pci; + } + + /* Establish encoder defaults here */ +@@ -1062,7 +1062,7 @@ int saa7164_encoder_register(struct saa7164_port *port) + 100000, ENCODER_DEF_BITRATE); + if (hdl->error) { + result = hdl->error; +- goto failed; ++ goto fail_hdl; + } + + port->std = V4L2_STD_NTSC_M; +@@ -1080,7 +1080,7 @@ int saa7164_encoder_register(struct saa7164_port *port) + printk(KERN_INFO "%s: can't allocate mpeg device\n", + dev->name); + result = -ENOMEM; +- goto failed; ++ goto fail_hdl; + } + + port->v4l_device->ctrl_handler = hdl; +@@ -1091,10 +1091,7 @@ int saa7164_encoder_register(struct saa7164_port *port) + if (result < 0) { + printk(KERN_INFO "%s: can't register mpeg device\n", + dev->name); +- /* TODO: We're going to leak here if we don't dealloc +- The buffers above. The unreg function can't deal wit it. +- */ +- goto failed; ++ goto fail_reg; + } + + printk(KERN_INFO "%s: registered device video%d [mpeg]\n", +@@ -1116,9 +1113,14 @@ int saa7164_encoder_register(struct saa7164_port *port) + + saa7164_api_set_encoder(port); + saa7164_api_get_encoder(port); ++ return 0; + +- result = 0; +-failed: ++fail_reg: ++ video_device_release(port->v4l_device); ++ port->v4l_device = NULL; ++fail_hdl: ++ v4l2_ctrl_handler_free(hdl); ++fail_pci: + return result; + } + +diff --git a/drivers/media/pci/sta2x11/Kconfig b/drivers/media/pci/sta2x11/Kconfig +index 011b766f0bffd..d613feee81767 100644 +--- a/drivers/media/pci/sta2x11/Kconfig ++++ b/drivers/media/pci/sta2x11/Kconfig +@@ -2,6 +2,7 @@ + config STA2X11_VIP + tristate "STA2X11 VIP Video For Linux" + depends on STA2X11 || COMPILE_TEST ++ select GPIOLIB if MEDIA_SUBDRV_AUTOSELECT + select VIDEO_ADV7180 if MEDIA_SUBDRV_AUTOSELECT + select VIDEOBUF2_DMA_CONTIG + depends on PCI && VIDEO_V4L2 && VIRT_TO_BUS +diff --git a/drivers/media/platform/sti/bdisp/bdisp-debug.c b/drivers/media/platform/sti/bdisp/bdisp-debug.c +index 77ca7517fa3e2..bae62af826434 100644 +--- a/drivers/media/platform/sti/bdisp/bdisp-debug.c ++++ b/drivers/media/platform/sti/bdisp/bdisp-debug.c +@@ -480,7 +480,7 @@ static int regs_show(struct seq_file *s, void *data) + int ret; + unsigned int i; + +- ret = pm_runtime_get_sync(bdisp->dev); ++ ret = pm_runtime_resume_and_get(bdisp->dev); + if (ret < 0) { + seq_puts(s, "Cannot wake up IP\n"); + return 0; +diff --git a/drivers/media/platform/vivid/vivid-core.c b/drivers/media/platform/vivid/vivid-core.c +index f6a5cdbd74e74..cc71aa4255972 100644 +--- a/drivers/media/platform/vivid/vivid-core.c ++++ b/drivers/media/platform/vivid/vivid-core.c +@@ -174,13 +174,13 @@ static const u8 vivid_hdmi_edid[256] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x7b, + +- 0x02, 0x03, 0x3f, 0xf0, 0x51, 0x61, 0x60, 0x5f, ++ 0x02, 0x03, 0x3f, 0xf1, 0x51, 0x61, 0x60, 0x5f, + 0x5e, 0x5d, 0x10, 0x1f, 0x04, 0x13, 0x22, 0x21, + 0x20, 0x05, 0x14, 0x02, 0x11, 0x01, 0x23, 0x09, + 0x07, 0x07, 0x83, 0x01, 0x00, 0x00, 0x6d, 0x03, + 0x0c, 0x00, 0x10, 0x00, 0x00, 0x3c, 0x21, 0x00, + 0x60, 0x01, 0x02, 0x03, 0x67, 0xd8, 0x5d, 0xc4, +- 0x01, 0x78, 0x00, 0x00, 0xe2, 0x00, 0xea, 0xe3, ++ 0x01, 0x78, 0x00, 0x00, 0xe2, 0x00, 0xca, 0xe3, + 0x05, 0x00, 0x00, 0xe3, 0x06, 0x01, 0x00, 0x4d, + 0xd0, 0x00, 0xa0, 0xf0, 0x70, 0x3e, 0x80, 0x30, + 0x20, 0x35, 0x00, 0xc0, 0x1c, 0x32, 0x00, 0x00, +@@ -189,7 +189,7 @@ static const u8 vivid_hdmi_edid[256] = { + 0x00, 0x00, 0x1a, 0x1a, 0x1d, 0x00, 0x80, 0x51, + 0xd0, 0x1c, 0x20, 0x40, 0x80, 0x35, 0x00, 0xc0, + 0x1c, 0x32, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, + }; + + static int vidioc_querycap(struct file *file, void *priv, +diff --git a/drivers/media/rc/ite-cir.c b/drivers/media/rc/ite-cir.c +index 3ab6cec0dc3bc..4b8aee390518d 100644 +--- a/drivers/media/rc/ite-cir.c ++++ b/drivers/media/rc/ite-cir.c +@@ -276,8 +276,14 @@ static irqreturn_t ite_cir_isr(int irq, void *data) + /* read the interrupt flags */ + iflags = dev->params.get_irq_causes(dev); + ++ /* Check for RX overflow */ ++ if (iflags & ITE_IRQ_RX_FIFO_OVERRUN) { ++ dev_warn(&dev->rdev->dev, "receive overflow\n"); ++ ir_raw_event_reset(dev->rdev); ++ } ++ + /* check for the receive interrupt */ +- if (iflags & (ITE_IRQ_RX_FIFO | ITE_IRQ_RX_FIFO_OVERRUN)) { ++ if (iflags & ITE_IRQ_RX_FIFO) { + /* read the FIFO bytes */ + rx_bytes = + dev->params.get_rx_bytes(dev, rx_buf, +diff --git a/drivers/media/usb/dvb-usb/dvb-usb-init.c b/drivers/media/usb/dvb-usb/dvb-usb-init.c +index 16a0b4a359eac..f57c4627624f5 100644 +--- a/drivers/media/usb/dvb-usb/dvb-usb-init.c ++++ b/drivers/media/usb/dvb-usb/dvb-usb-init.c +@@ -79,11 +79,17 @@ static int dvb_usb_adapter_init(struct dvb_usb_device *d, short *adapter_nrs) + } + } + +- if ((ret = dvb_usb_adapter_stream_init(adap)) || +- (ret = dvb_usb_adapter_dvb_init(adap, adapter_nrs)) || +- (ret = dvb_usb_adapter_frontend_init(adap))) { ++ ret = dvb_usb_adapter_stream_init(adap); ++ if (ret) + return ret; +- } ++ ++ ret = dvb_usb_adapter_dvb_init(adap, adapter_nrs); ++ if (ret) ++ goto dvb_init_err; ++ ++ ret = dvb_usb_adapter_frontend_init(adap); ++ if (ret) ++ goto frontend_init_err; + + /* use exclusive FE lock if there is multiple shared FEs */ + if (adap->fe_adap[1].fe) +@@ -103,6 +109,12 @@ static int dvb_usb_adapter_init(struct dvb_usb_device *d, short *adapter_nrs) + } + + return 0; ++ ++frontend_init_err: ++ dvb_usb_adapter_dvb_exit(adap); ++dvb_init_err: ++ dvb_usb_adapter_stream_exit(adap); ++ return ret; + } + + static int dvb_usb_adapter_exit(struct dvb_usb_device *d) +@@ -158,22 +170,20 @@ static int dvb_usb_init(struct dvb_usb_device *d, short *adapter_nums) + + if (d->props.priv_init != NULL) { + ret = d->props.priv_init(d); +- if (ret != 0) { +- kfree(d->priv); +- d->priv = NULL; +- return ret; +- } ++ if (ret != 0) ++ goto err_priv_init; + } + } + + /* check the capabilities and set appropriate variables */ + dvb_usb_device_power_ctrl(d, 1); + +- if ((ret = dvb_usb_i2c_init(d)) || +- (ret = dvb_usb_adapter_init(d, adapter_nums))) { +- dvb_usb_exit(d); +- return ret; +- } ++ ret = dvb_usb_i2c_init(d); ++ if (ret) ++ goto err_i2c_init; ++ ret = dvb_usb_adapter_init(d, adapter_nums); ++ if (ret) ++ goto err_adapter_init; + + if ((ret = dvb_usb_remote_init(d))) + err("could not initialize remote control."); +@@ -181,6 +191,17 @@ static int dvb_usb_init(struct dvb_usb_device *d, short *adapter_nums) + dvb_usb_device_power_ctrl(d, 0); + + return 0; ++ ++err_adapter_init: ++ dvb_usb_adapter_exit(d); ++err_i2c_init: ++ dvb_usb_i2c_exit(d); ++ if (d->priv && d->props.priv_destroy) ++ d->props.priv_destroy(d); ++err_priv_init: ++ kfree(d->priv); ++ d->priv = NULL; ++ return ret; + } + + /* determine the name and the state of the just found USB device */ +@@ -255,41 +276,50 @@ int dvb_usb_device_init(struct usb_interface *intf, + if (du != NULL) + *du = NULL; + +- if ((desc = dvb_usb_find_device(udev, props, &cold)) == NULL) { ++ d = kzalloc(sizeof(*d), GFP_KERNEL); ++ if (!d) { ++ err("no memory for 'struct dvb_usb_device'"); ++ return -ENOMEM; ++ } ++ ++ memcpy(&d->props, props, sizeof(struct dvb_usb_device_properties)); ++ ++ desc = dvb_usb_find_device(udev, &d->props, &cold); ++ if (!desc) { + deb_err("something went very wrong, device was not found in current device list - let's see what comes next.\n"); +- return -ENODEV; ++ ret = -ENODEV; ++ goto error; + } + + if (cold) { + info("found a '%s' in cold state, will try to load a firmware", desc->name); + ret = dvb_usb_download_firmware(udev, props); + if (!props->no_reconnect || ret != 0) +- return ret; ++ goto error; + } + + info("found a '%s' in warm state.", desc->name); +- d = kzalloc(sizeof(struct dvb_usb_device), GFP_KERNEL); +- if (d == NULL) { +- err("no memory for 'struct dvb_usb_device'"); +- return -ENOMEM; +- } +- + d->udev = udev; +- memcpy(&d->props, props, sizeof(struct dvb_usb_device_properties)); + d->desc = desc; + d->owner = owner; + + usb_set_intfdata(intf, d); + +- if (du != NULL) ++ ret = dvb_usb_init(d, adapter_nums); ++ if (ret) { ++ info("%s error while loading driver (%d)", desc->name, ret); ++ goto error; ++ } ++ ++ if (du) + *du = d; + +- ret = dvb_usb_init(d, adapter_nums); ++ info("%s successfully initialized and connected.", desc->name); ++ return 0; + +- if (ret == 0) +- info("%s successfully initialized and connected.", desc->name); +- else +- info("%s error while loading driver (%d)", desc->name, ret); ++ error: ++ usb_set_intfdata(intf, NULL); ++ kfree(d); + return ret; + } + EXPORT_SYMBOL(dvb_usb_device_init); +diff --git a/drivers/media/usb/dvb-usb/dvb-usb.h b/drivers/media/usb/dvb-usb/dvb-usb.h +index 2eb0e24e89434..20830b365f39e 100644 +--- a/drivers/media/usb/dvb-usb/dvb-usb.h ++++ b/drivers/media/usb/dvb-usb/dvb-usb.h +@@ -485,7 +485,7 @@ extern int __must_check + dvb_usb_generic_write(struct dvb_usb_device *, u8 *, u16); + + /* commonly used remote control parsing */ +-extern int dvb_usb_nec_rc_key_to_event(struct dvb_usb_device *, u8[], u32 *, int *); ++extern int dvb_usb_nec_rc_key_to_event(struct dvb_usb_device *, u8[5], u32 *, int *); + + /* commonly used firmware download types and function */ + struct hexline { +diff --git a/drivers/media/usb/em28xx/em28xx-dvb.c b/drivers/media/usb/em28xx/em28xx-dvb.c +index a73faf12f7e47..e1946237ac8cd 100644 +--- a/drivers/media/usb/em28xx/em28xx-dvb.c ++++ b/drivers/media/usb/em28xx/em28xx-dvb.c +@@ -1924,6 +1924,7 @@ ret: + return result; + + out_free: ++ em28xx_uninit_usb_xfer(dev, EM28XX_DIGITAL_MODE); + kfree(dvb); + dev->dvb = NULL; + goto ret; +diff --git a/drivers/media/usb/gspca/gspca.c b/drivers/media/usb/gspca/gspca.c +index 4210826cc9106..e4d78e676e74a 100644 +--- a/drivers/media/usb/gspca/gspca.c ++++ b/drivers/media/usb/gspca/gspca.c +@@ -1576,6 +1576,8 @@ out: + #endif + v4l2_ctrl_handler_free(gspca_dev->vdev.ctrl_handler); + v4l2_device_unregister(&gspca_dev->v4l2_dev); ++ if (sd_desc->probe_error) ++ sd_desc->probe_error(gspca_dev); + kfree(gspca_dev->usb_buf); + kfree(gspca_dev); + return ret; +diff --git a/drivers/media/usb/gspca/gspca.h b/drivers/media/usb/gspca/gspca.h +index b0ced2e140064..a6554d5e9e1a5 100644 +--- a/drivers/media/usb/gspca/gspca.h ++++ b/drivers/media/usb/gspca/gspca.h +@@ -105,6 +105,7 @@ struct sd_desc { + cam_cf_op config; /* called on probe */ + cam_op init; /* called on probe and resume */ + cam_op init_controls; /* called on probe */ ++ cam_v_op probe_error; /* called if probe failed, do cleanup here */ + cam_op start; /* called on stream on after URBs creation */ + cam_pkt_op pkt_scan; + /* optional operations */ +diff --git a/drivers/media/usb/gspca/sq905.c b/drivers/media/usb/gspca/sq905.c +index 863c485f42753..65a74060986a7 100644 +--- a/drivers/media/usb/gspca/sq905.c ++++ b/drivers/media/usb/gspca/sq905.c +@@ -158,7 +158,7 @@ static int + sq905_read_data(struct gspca_dev *gspca_dev, u8 *data, int size, int need_lock) + { + int ret; +- int act_len; ++ int act_len = 0; + + gspca_dev->usb_buf[0] = '\0'; + if (need_lock) +diff --git a/drivers/media/usb/gspca/stv06xx/stv06xx.c b/drivers/media/usb/gspca/stv06xx/stv06xx.c +index 95673fc0a99c5..d9bc2aacc8851 100644 +--- a/drivers/media/usb/gspca/stv06xx/stv06xx.c ++++ b/drivers/media/usb/gspca/stv06xx/stv06xx.c +@@ -529,12 +529,21 @@ static int sd_int_pkt_scan(struct gspca_dev *gspca_dev, + static int stv06xx_config(struct gspca_dev *gspca_dev, + const struct usb_device_id *id); + ++static void stv06xx_probe_error(struct gspca_dev *gspca_dev) ++{ ++ struct sd *sd = (struct sd *)gspca_dev; ++ ++ kfree(sd->sensor_priv); ++ sd->sensor_priv = NULL; ++} ++ + /* sub-driver description */ + static const struct sd_desc sd_desc = { + .name = MODULE_NAME, + .config = stv06xx_config, + .init = stv06xx_init, + .init_controls = stv06xx_init_controls, ++ .probe_error = stv06xx_probe_error, + .start = stv06xx_start, + .stopN = stv06xx_stopN, + .pkt_scan = stv06xx_pkt_scan, +diff --git a/drivers/mfd/arizona-irq.c b/drivers/mfd/arizona-irq.c +index 077d9ab112b71..d919ae9691e23 100644 +--- a/drivers/mfd/arizona-irq.c ++++ b/drivers/mfd/arizona-irq.c +@@ -100,7 +100,7 @@ static irqreturn_t arizona_irq_thread(int irq, void *data) + unsigned int val; + int ret; + +- ret = pm_runtime_get_sync(arizona->dev); ++ ret = pm_runtime_resume_and_get(arizona->dev); + if (ret < 0) { + dev_err(arizona->dev, "Failed to resume device: %d\n", ret); + return IRQ_NONE; +diff --git a/drivers/mmc/core/block.c b/drivers/mmc/core/block.c +index 63e838ec8af84..39f2864455a60 100644 +--- a/drivers/mmc/core/block.c ++++ b/drivers/mmc/core/block.c +@@ -621,6 +621,18 @@ static int __mmc_blk_ioctl_cmd(struct mmc_card *card, struct mmc_blk_data *md, + main_md->part_curr = value & EXT_CSD_PART_CONFIG_ACC_MASK; + } + ++ /* ++ * Make sure to update CACHE_CTRL in case it was changed. The cache ++ * will get turned back on if the card is re-initialized, e.g. ++ * suspend/resume or hw reset in recovery. ++ */ ++ if ((MMC_EXTRACT_INDEX_FROM_ARG(cmd.arg) == EXT_CSD_CACHE_CTRL) && ++ (cmd.opcode == MMC_SWITCH)) { ++ u8 value = MMC_EXTRACT_VALUE_FROM_ARG(cmd.arg) & 1; ++ ++ card->ext_csd.cache_ctrl = value; ++ } ++ + /* + * According to the SD specs, some commands require a delay after + * issuing the command. +@@ -2215,6 +2227,10 @@ enum mmc_issued mmc_blk_mq_issue_rq(struct mmc_queue *mq, struct request *req) + case MMC_ISSUE_ASYNC: + switch (req_op(req)) { + case REQ_OP_FLUSH: ++ if (!mmc_cache_enabled(host)) { ++ blk_mq_end_request(req, BLK_STS_OK); ++ return MMC_REQ_FINISHED; ++ } + ret = mmc_blk_cqe_issue_flush(mq, req); + break; + case REQ_OP_READ: +diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c +index 26644b7ec13e3..460a456bcdd20 100644 +--- a/drivers/mmc/core/core.c ++++ b/drivers/mmc/core/core.c +@@ -1221,7 +1221,7 @@ int mmc_set_uhs_voltage(struct mmc_host *host, u32 ocr) + + err = mmc_wait_for_cmd(host, &cmd, 0); + if (err) +- return err; ++ goto power_cycle; + + if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR)) + return -EIO; +@@ -2392,80 +2392,6 @@ void mmc_stop_host(struct mmc_host *host) + mmc_release_host(host); + } + +-#ifdef CONFIG_PM_SLEEP +-/* Do the card removal on suspend if card is assumed removeable +- * Do that in pm notifier while userspace isn't yet frozen, so we will be able +- to sync the card. +-*/ +-static int mmc_pm_notify(struct notifier_block *notify_block, +- unsigned long mode, void *unused) +-{ +- struct mmc_host *host = container_of( +- notify_block, struct mmc_host, pm_notify); +- unsigned long flags; +- int err = 0; +- +- switch (mode) { +- case PM_HIBERNATION_PREPARE: +- case PM_SUSPEND_PREPARE: +- case PM_RESTORE_PREPARE: +- spin_lock_irqsave(&host->lock, flags); +- host->rescan_disable = 1; +- spin_unlock_irqrestore(&host->lock, flags); +- cancel_delayed_work_sync(&host->detect); +- +- if (!host->bus_ops) +- break; +- +- /* Validate prerequisites for suspend */ +- if (host->bus_ops->pre_suspend) +- err = host->bus_ops->pre_suspend(host); +- if (!err) +- break; +- +- if (!mmc_card_is_removable(host)) { +- dev_warn(mmc_dev(host), +- "pre_suspend failed for non-removable host: " +- "%d\n", err); +- /* Avoid removing non-removable hosts */ +- break; +- } +- +- /* Calling bus_ops->remove() with a claimed host can deadlock */ +- host->bus_ops->remove(host); +- mmc_claim_host(host); +- mmc_detach_bus(host); +- mmc_power_off(host); +- mmc_release_host(host); +- host->pm_flags = 0; +- break; +- +- case PM_POST_SUSPEND: +- case PM_POST_HIBERNATION: +- case PM_POST_RESTORE: +- +- spin_lock_irqsave(&host->lock, flags); +- host->rescan_disable = 0; +- spin_unlock_irqrestore(&host->lock, flags); +- _mmc_detect_change(host, 0, false); +- +- } +- +- return 0; +-} +- +-void mmc_register_pm_notifier(struct mmc_host *host) +-{ +- host->pm_notify.notifier_call = mmc_pm_notify; +- register_pm_notifier(&host->pm_notify); +-} +- +-void mmc_unregister_pm_notifier(struct mmc_host *host) +-{ +- unregister_pm_notifier(&host->pm_notify); +-} +-#endif +- + static int __init mmc_init(void) + { + int ret; +diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h +index 575ac0257af2f..db3c9c68875d8 100644 +--- a/drivers/mmc/core/core.h ++++ b/drivers/mmc/core/core.h +@@ -29,6 +29,7 @@ struct mmc_bus_ops { + int (*shutdown)(struct mmc_host *); + int (*hw_reset)(struct mmc_host *); + int (*sw_reset)(struct mmc_host *); ++ bool (*cache_enabled)(struct mmc_host *); + }; + + void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops); +@@ -93,14 +94,6 @@ int mmc_execute_tuning(struct mmc_card *card); + int mmc_hs200_to_hs400(struct mmc_card *card); + int mmc_hs400_to_hs200(struct mmc_card *card); + +-#ifdef CONFIG_PM_SLEEP +-void mmc_register_pm_notifier(struct mmc_host *host); +-void mmc_unregister_pm_notifier(struct mmc_host *host); +-#else +-static inline void mmc_register_pm_notifier(struct mmc_host *host) { } +-static inline void mmc_unregister_pm_notifier(struct mmc_host *host) { } +-#endif +- + void mmc_wait_for_req_done(struct mmc_host *host, struct mmc_request *mrq); + bool mmc_is_req_done(struct mmc_host *host, struct mmc_request *mrq); + +@@ -171,4 +164,12 @@ static inline void mmc_post_req(struct mmc_host *host, struct mmc_request *mrq, + host->ops->post_req(host, mrq, err); + } + ++static inline bool mmc_cache_enabled(struct mmc_host *host) ++{ ++ if (host->bus_ops->cache_enabled) ++ return host->bus_ops->cache_enabled(host); ++ ++ return false; ++} ++ + #endif +diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c +index b3484def0a8b0..f7339590a84c8 100644 +--- a/drivers/mmc/core/host.c ++++ b/drivers/mmc/core/host.c +@@ -33,6 +33,42 @@ + + static DEFINE_IDA(mmc_host_ida); + ++#ifdef CONFIG_PM_SLEEP ++static int mmc_host_class_prepare(struct device *dev) ++{ ++ struct mmc_host *host = cls_dev_to_mmc_host(dev); ++ ++ /* ++ * It's safe to access the bus_ops pointer, as both userspace and the ++ * workqueue for detecting cards are frozen at this point. ++ */ ++ if (!host->bus_ops) ++ return 0; ++ ++ /* Validate conditions for system suspend. */ ++ if (host->bus_ops->pre_suspend) ++ return host->bus_ops->pre_suspend(host); ++ ++ return 0; ++} ++ ++static void mmc_host_class_complete(struct device *dev) ++{ ++ struct mmc_host *host = cls_dev_to_mmc_host(dev); ++ ++ _mmc_detect_change(host, 0, false); ++} ++ ++static const struct dev_pm_ops mmc_host_class_dev_pm_ops = { ++ .prepare = mmc_host_class_prepare, ++ .complete = mmc_host_class_complete, ++}; ++ ++#define MMC_HOST_CLASS_DEV_PM_OPS (&mmc_host_class_dev_pm_ops) ++#else ++#define MMC_HOST_CLASS_DEV_PM_OPS NULL ++#endif ++ + static void mmc_host_classdev_release(struct device *dev) + { + struct mmc_host *host = cls_dev_to_mmc_host(dev); +@@ -43,6 +79,7 @@ static void mmc_host_classdev_release(struct device *dev) + static struct class mmc_host_class = { + .name = "mmc_host", + .dev_release = mmc_host_classdev_release, ++ .pm = MMC_HOST_CLASS_DEV_PM_OPS, + }; + + int mmc_register_host_class(void) +@@ -477,8 +514,6 @@ int mmc_add_host(struct mmc_host *host) + #endif + + mmc_start_host(host); +- mmc_register_pm_notifier(host); +- + return 0; + } + +@@ -494,7 +529,6 @@ EXPORT_SYMBOL(mmc_add_host); + */ + void mmc_remove_host(struct mmc_host *host) + { +- mmc_unregister_pm_notifier(host); + mmc_stop_host(host); + + #ifdef CONFIG_DEBUG_FS +diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c +index 9f29288f2c9a9..ed939bb2f7006 100644 +--- a/drivers/mmc/core/mmc.c ++++ b/drivers/mmc/core/mmc.c +@@ -2019,6 +2019,12 @@ static void mmc_detect(struct mmc_host *host) + } + } + ++static bool _mmc_cache_enabled(struct mmc_host *host) ++{ ++ return host->card->ext_csd.cache_size > 0 && ++ host->card->ext_csd.cache_ctrl & 1; ++} ++ + static int _mmc_suspend(struct mmc_host *host, bool is_suspend) + { + int err = 0; +@@ -2197,6 +2203,7 @@ static const struct mmc_bus_ops mmc_ops = { + .alive = mmc_alive, + .shutdown = mmc_shutdown, + .hw_reset = _mmc_hw_reset, ++ .cache_enabled = _mmc_cache_enabled, + }; + + /* +diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c +index 18a7afb2a5b23..09311c2bd8588 100644 +--- a/drivers/mmc/core/mmc_ops.c ++++ b/drivers/mmc/core/mmc_ops.c +@@ -959,9 +959,7 @@ int mmc_flush_cache(struct mmc_card *card) + { + int err = 0; + +- if (mmc_card_mmc(card) && +- (card->ext_csd.cache_size > 0) && +- (card->ext_csd.cache_ctrl & 1)) { ++ if (mmc_cache_enabled(card->host)) { + err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, + EXT_CSD_FLUSH_CACHE, 1, 0); + if (err) +diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c +index fe914ff5f5d66..4f7c08e68f8cb 100644 +--- a/drivers/mmc/core/sd.c ++++ b/drivers/mmc/core/sd.c +@@ -135,6 +135,9 @@ static int mmc_decode_csd(struct mmc_card *card) + csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1; + csd->erase_size <<= csd->write_blkbits - 9; + } ++ ++ if (UNSTUFF_BITS(resp, 13, 1)) ++ mmc_card_set_readonly(card); + break; + case 1: + /* +@@ -169,6 +172,9 @@ static int mmc_decode_csd(struct mmc_card *card) + csd->write_blkbits = 9; + csd->write_partial = 0; + csd->erase_size = 1; ++ ++ if (UNSTUFF_BITS(resp, 13, 1)) ++ mmc_card_set_readonly(card); + break; + default: + pr_err("%s: unrecognised CSD structure version %d\n", +diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c +index 20eed28ea60da..0bf33786fc5c5 100644 +--- a/drivers/mmc/core/sdio.c ++++ b/drivers/mmc/core/sdio.c +@@ -924,21 +924,37 @@ out: + */ + static int mmc_sdio_pre_suspend(struct mmc_host *host) + { +- int i, err = 0; ++ int i; + + for (i = 0; i < host->card->sdio_funcs; i++) { + struct sdio_func *func = host->card->sdio_func[i]; + if (func && sdio_func_present(func) && func->dev.driver) { + const struct dev_pm_ops *pmops = func->dev.driver->pm; +- if (!pmops || !pmops->suspend || !pmops->resume) { ++ if (!pmops || !pmops->suspend || !pmops->resume) + /* force removal of entire card in that case */ +- err = -ENOSYS; +- break; +- } ++ goto remove; + } + } + +- return err; ++ return 0; ++ ++remove: ++ if (!mmc_card_is_removable(host)) { ++ dev_warn(mmc_dev(host), ++ "missing suspend/resume ops for non-removable SDIO card\n"); ++ /* Don't remove a non-removable card - we can't re-detect it. */ ++ return 0; ++ } ++ ++ /* Remove the SDIO card and let it be re-detected later on. */ ++ mmc_sdio_remove(host); ++ mmc_claim_host(host); ++ mmc_detach_bus(host); ++ mmc_power_off(host); ++ mmc_release_host(host); ++ host->pm_flags = 0; ++ ++ return 0; + } + + /* +diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c +index afbccfceaaf85..a9151bd27211a 100644 +--- a/drivers/mmc/host/sdhci-pci-core.c ++++ b/drivers/mmc/host/sdhci-pci-core.c +@@ -520,6 +520,7 @@ struct intel_host { + int drv_strength; + bool d3_retune; + bool rpm_retune_ok; ++ bool needs_pwr_off; + u32 glk_rx_ctrl1; + u32 glk_tun_val; + u32 active_ltr; +@@ -647,9 +648,25 @@ out: + static void sdhci_intel_set_power(struct sdhci_host *host, unsigned char mode, + unsigned short vdd) + { ++ struct sdhci_pci_slot *slot = sdhci_priv(host); ++ struct intel_host *intel_host = sdhci_pci_priv(slot); + int cntr; + u8 reg; + ++ /* ++ * Bus power may control card power, but a full reset still may not ++ * reset the power, whereas a direct write to SDHCI_POWER_CONTROL can. ++ * That might be needed to initialize correctly, if the card was left ++ * powered on previously. ++ */ ++ if (intel_host->needs_pwr_off) { ++ intel_host->needs_pwr_off = false; ++ if (mode != MMC_POWER_OFF) { ++ sdhci_writeb(host, 0, SDHCI_POWER_CONTROL); ++ usleep_range(10000, 12500); ++ } ++ } ++ + sdhci_set_power(host, mode, vdd); + + if (mode == MMC_POWER_OFF) +@@ -1139,6 +1156,14 @@ static int byt_sdio_probe_slot(struct sdhci_pci_slot *slot) + return 0; + } + ++static void byt_needs_pwr_off(struct sdhci_pci_slot *slot) ++{ ++ struct intel_host *intel_host = sdhci_pci_priv(slot); ++ u8 reg = sdhci_readb(slot->host, SDHCI_POWER_CONTROL); ++ ++ intel_host->needs_pwr_off = reg & SDHCI_POWER_ON; ++} ++ + static int byt_sd_probe_slot(struct sdhci_pci_slot *slot) + { + byt_probe_slot(slot); +@@ -1156,6 +1181,8 @@ static int byt_sd_probe_slot(struct sdhci_pci_slot *slot) + slot->chip->pdev->subsystem_device == PCI_SUBDEVICE_ID_NI_78E3) + slot->host->mmc->caps2 |= MMC_CAP2_AVOID_3_3V; + ++ byt_needs_pwr_off(slot); ++ + return 0; + } + +@@ -1907,6 +1934,8 @@ static const struct pci_device_id pci_ids[] = { + SDHCI_PCI_DEVICE(INTEL, CMLH_SD, intel_byt_sd), + SDHCI_PCI_DEVICE(INTEL, JSL_EMMC, intel_glk_emmc), + SDHCI_PCI_DEVICE(INTEL, JSL_SD, intel_byt_sd), ++ SDHCI_PCI_DEVICE(INTEL, LKF_EMMC, intel_glk_emmc), ++ SDHCI_PCI_DEVICE(INTEL, LKF_SD, intel_byt_sd), + SDHCI_PCI_DEVICE(O2, 8120, o2), + SDHCI_PCI_DEVICE(O2, 8220, o2), + SDHCI_PCI_DEVICE(O2, 8221, o2), +diff --git a/drivers/mmc/host/sdhci-pci.h b/drivers/mmc/host/sdhci-pci.h +index 981bbbe63aff5..779156ce1ee17 100644 +--- a/drivers/mmc/host/sdhci-pci.h ++++ b/drivers/mmc/host/sdhci-pci.h +@@ -57,6 +57,8 @@ + #define PCI_DEVICE_ID_INTEL_CMLH_SD 0x06f5 + #define PCI_DEVICE_ID_INTEL_JSL_EMMC 0x4dc4 + #define PCI_DEVICE_ID_INTEL_JSL_SD 0x4df8 ++#define PCI_DEVICE_ID_INTEL_LKF_EMMC 0x98c4 ++#define PCI_DEVICE_ID_INTEL_LKF_SD 0x98f8 + + #define PCI_DEVICE_ID_SYSKONNECT_8000 0x8000 + #define PCI_DEVICE_ID_VIA_95D0 0x95d0 +diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c +index a1aeb2e105641..92709232529a6 100644 +--- a/drivers/mmc/host/sdhci.c ++++ b/drivers/mmc/host/sdhci.c +@@ -2647,6 +2647,37 @@ static bool sdhci_request_done(struct sdhci_host *host) + return true; + } + ++ /* ++ * The controller needs a reset of internal state machines ++ * upon error conditions. ++ */ ++ if (sdhci_needs_reset(host, mrq)) { ++ /* ++ * Do not finish until command and data lines are available for ++ * reset. Note there can only be one other mrq, so it cannot ++ * also be in mrqs_done, otherwise host->cmd and host->data_cmd ++ * would both be null. ++ */ ++ if (host->cmd || host->data_cmd) { ++ spin_unlock_irqrestore(&host->lock, flags); ++ return true; ++ } ++ ++ /* Some controllers need this kick or reset won't work here */ ++ if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET) ++ /* This is to force an update */ ++ host->ops->set_clock(host, host->clock); ++ ++ /* ++ * Spec says we should do both at the same time, but Ricoh ++ * controllers do not like that. ++ */ ++ sdhci_do_reset(host, SDHCI_RESET_CMD); ++ sdhci_do_reset(host, SDHCI_RESET_DATA); ++ ++ host->pending_reset = false; ++ } ++ + /* + * Always unmap the data buffers if they were mapped by + * sdhci_prepare_data() whenever we finish with a request. +@@ -2699,35 +2730,6 @@ static bool sdhci_request_done(struct sdhci_host *host) + } + } + +- /* +- * The controller needs a reset of internal state machines +- * upon error conditions. +- */ +- if (sdhci_needs_reset(host, mrq)) { +- /* +- * Do not finish until command and data lines are available for +- * reset. Note there can only be one other mrq, so it cannot +- * also be in mrqs_done, otherwise host->cmd and host->data_cmd +- * would both be null. +- */ +- if (host->cmd || host->data_cmd) { +- spin_unlock_irqrestore(&host->lock, flags); +- return true; +- } +- +- /* Some controllers need this kick or reset won't work here */ +- if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET) +- /* This is to force an update */ +- host->ops->set_clock(host, host->clock); +- +- /* Spec says we should do both at the same time, but Ricoh +- controllers do not like that. */ +- sdhci_do_reset(host, SDHCI_RESET_CMD); +- sdhci_do_reset(host, SDHCI_RESET_DATA); +- +- host->pending_reset = false; +- } +- + host->mrqs_done[i] = NULL; + + spin_unlock_irqrestore(&host->lock, flags); +diff --git a/drivers/mmc/host/uniphier-sd.c b/drivers/mmc/host/uniphier-sd.c +index aec9c8ae694c7..b2e28ecae4a54 100644 +--- a/drivers/mmc/host/uniphier-sd.c ++++ b/drivers/mmc/host/uniphier-sd.c +@@ -639,7 +639,7 @@ static int uniphier_sd_probe(struct platform_device *pdev) + + ret = tmio_mmc_host_probe(host); + if (ret) +- goto free_host; ++ goto disable_clk; + + ret = devm_request_irq(dev, irq, tmio_mmc_irq, IRQF_SHARED, + dev_name(dev), host); +@@ -650,6 +650,8 @@ static int uniphier_sd_probe(struct platform_device *pdev) + + remove_host: + tmio_mmc_host_remove(host); ++disable_clk: ++ uniphier_sd_clk_disable(host); + free_host: + tmio_mmc_host_free(host); + +@@ -662,6 +664,7 @@ static int uniphier_sd_remove(struct platform_device *pdev) + + tmio_mmc_host_remove(host); + uniphier_sd_clk_disable(host); ++ tmio_mmc_host_free(host); + + return 0; + } +diff --git a/drivers/mtd/nand/raw/atmel/nand-controller.c b/drivers/mtd/nand/raw/atmel/nand-controller.c +index 8d6be90a6fe8a..23d11e8b56441 100644 +--- a/drivers/mtd/nand/raw/atmel/nand-controller.c ++++ b/drivers/mtd/nand/raw/atmel/nand-controller.c +@@ -813,10 +813,12 @@ static int atmel_nand_pmecc_correct_data(struct nand_chip *chip, void *buf, + NULL, 0, + chip->ecc.strength); + +- if (ret >= 0) ++ if (ret >= 0) { ++ mtd->ecc_stats.corrected += ret; + max_bitflips = max(ret, max_bitflips); +- else ++ } else { + mtd->ecc_stats.failed++; ++ } + + databuf += chip->ecc.size; + eccbuf += chip->ecc.bytes; +diff --git a/drivers/mtd/nand/spi/core.c b/drivers/mtd/nand/spi/core.c +index 0d21c68bfe245..55e636efcc8b7 100644 +--- a/drivers/mtd/nand/spi/core.c ++++ b/drivers/mtd/nand/spi/core.c +@@ -1133,12 +1133,14 @@ static const struct spi_device_id spinand_ids[] = { + { .name = "spi-nand" }, + { /* sentinel */ }, + }; ++MODULE_DEVICE_TABLE(spi, spinand_ids); + + #ifdef CONFIG_OF + static const struct of_device_id spinand_of_ids[] = { + { .compatible = "spi-nand" }, + { /* sentinel */ }, + }; ++MODULE_DEVICE_TABLE(of, spinand_of_ids); + #endif + + static struct spi_mem_driver spinand_drv = { +diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_mr.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_mr.c +index 336e5ecc68f86..f1874578aa141 100644 +--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_mr.c ++++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_mr.c +@@ -524,6 +524,16 @@ mlxsw_sp_mr_route_evif_resolve(struct mlxsw_sp_mr_table *mr_table, + u16 erif_index = 0; + int err; + ++ /* Add the eRIF */ ++ if (mlxsw_sp_mr_vif_valid(rve->mr_vif)) { ++ erif_index = mlxsw_sp_rif_index(rve->mr_vif->rif); ++ err = mr->mr_ops->route_erif_add(mlxsw_sp, ++ rve->mr_route->route_priv, ++ erif_index); ++ if (err) ++ return err; ++ } ++ + /* Update the route action, as the new eVIF can be a tunnel or a pimreg + * device which will require updating the action. + */ +@@ -533,17 +543,7 @@ mlxsw_sp_mr_route_evif_resolve(struct mlxsw_sp_mr_table *mr_table, + rve->mr_route->route_priv, + route_action); + if (err) +- return err; +- } +- +- /* Add the eRIF */ +- if (mlxsw_sp_mr_vif_valid(rve->mr_vif)) { +- erif_index = mlxsw_sp_rif_index(rve->mr_vif->rif); +- err = mr->mr_ops->route_erif_add(mlxsw_sp, +- rve->mr_route->route_priv, +- erif_index); +- if (err) +- goto err_route_erif_add; ++ goto err_route_action_update; + } + + /* Update the minimum MTU */ +@@ -561,14 +561,14 @@ mlxsw_sp_mr_route_evif_resolve(struct mlxsw_sp_mr_table *mr_table, + return 0; + + err_route_min_mtu_update: +- if (mlxsw_sp_mr_vif_valid(rve->mr_vif)) +- mr->mr_ops->route_erif_del(mlxsw_sp, rve->mr_route->route_priv, +- erif_index); +-err_route_erif_add: + if (route_action != rve->mr_route->route_action) + mr->mr_ops->route_action_update(mlxsw_sp, + rve->mr_route->route_priv, + rve->mr_route->route_action); ++err_route_action_update: ++ if (mlxsw_sp_mr_vif_valid(rve->mr_vif)) ++ mr->mr_ops->route_erif_del(mlxsw_sp, rve->mr_route->route_priv, ++ erif_index); + return err; + } + +diff --git a/drivers/net/wimax/i2400m/op-rfkill.c b/drivers/net/wimax/i2400m/op-rfkill.c +index 5c79f052cad20..34f81f16b5a0c 100644 +--- a/drivers/net/wimax/i2400m/op-rfkill.c ++++ b/drivers/net/wimax/i2400m/op-rfkill.c +@@ -86,7 +86,7 @@ int i2400m_op_rfkill_sw_toggle(struct wimax_dev *wimax_dev, + if (cmd == NULL) + goto error_alloc; + cmd->hdr.type = cpu_to_le16(I2400M_MT_CMD_RF_CONTROL); +- cmd->hdr.length = sizeof(cmd->sw_rf); ++ cmd->hdr.length = cpu_to_le16(sizeof(cmd->sw_rf)); + cmd->hdr.version = cpu_to_le16(I2400M_L3L4_VERSION); + cmd->sw_rf.hdr.type = cpu_to_le16(I2400M_TLV_RF_OPERATION); + cmd->sw_rf.hdr.length = cpu_to_le16(sizeof(cmd->sw_rf.status)); +diff --git a/drivers/net/wireless/rsi/rsi_91x_sdio.c b/drivers/net/wireless/rsi/rsi_91x_sdio.c +index d1e8c6593ef51..d51ec7104fb7c 100644 +--- a/drivers/net/wireless/rsi/rsi_91x_sdio.c ++++ b/drivers/net/wireless/rsi/rsi_91x_sdio.c +@@ -1511,7 +1511,7 @@ static int rsi_restore(struct device *dev) + } + static const struct dev_pm_ops rsi_pm_ops = { + .suspend = rsi_suspend, +- .resume = rsi_resume, ++ .resume_noirq = rsi_resume, + .freeze = rsi_freeze, + .thaw = rsi_thaw, + .restore = rsi_restore, +diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c +index 3c3bc9f584983..34a06e89e176a 100644 +--- a/drivers/pci/pci.c ++++ b/drivers/pci/pci.c +@@ -1666,20 +1666,10 @@ static int pci_enable_device_flags(struct pci_dev *dev, unsigned long flags) + int err; + int i, bars = 0; + +- /* +- * Power state could be unknown at this point, either due to a fresh +- * boot or a device removal call. So get the current power state +- * so that things like MSI message writing will behave as expected +- * (e.g. if the device really is in D0 at enable time). +- */ +- if (dev->pm_cap) { +- u16 pmcsr; +- pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr); +- dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK); +- } +- +- if (atomic_inc_return(&dev->enable_cnt) > 1) ++ if (atomic_inc_return(&dev->enable_cnt) > 1) { ++ pci_update_current_state(dev, dev->current_state); + return 0; /* already enabled */ ++ } + + bridge = pci_upstream_bridge(dev); + if (bridge) +diff --git a/drivers/perf/arm_pmu_platform.c b/drivers/perf/arm_pmu_platform.c +index 933bd8410fc2a..e35cb76c8d104 100644 +--- a/drivers/perf/arm_pmu_platform.c ++++ b/drivers/perf/arm_pmu_platform.c +@@ -236,7 +236,7 @@ int arm_pmu_device_probe(struct platform_device *pdev, + + ret = armpmu_register(pmu); + if (ret) +- goto out_free; ++ goto out_free_irqs; + + return 0; + +diff --git a/drivers/phy/ti/phy-twl4030-usb.c b/drivers/phy/ti/phy-twl4030-usb.c +index 9887f908f5401..812e5409d3595 100644 +--- a/drivers/phy/ti/phy-twl4030-usb.c ++++ b/drivers/phy/ti/phy-twl4030-usb.c +@@ -779,7 +779,7 @@ static int twl4030_usb_remove(struct platform_device *pdev) + + usb_remove_phy(&twl->phy); + pm_runtime_get_sync(twl->dev); +- cancel_delayed_work(&twl->id_workaround_work); ++ cancel_delayed_work_sync(&twl->id_workaround_work); + device_remove_file(twl->dev, &dev_attr_vbus); + + /* set transceiver mode to power on defaults */ +diff --git a/drivers/platform/x86/intel_pmc_core.c b/drivers/platform/x86/intel_pmc_core.c +index 571b4754477c5..4c1312f1616c3 100644 +--- a/drivers/platform/x86/intel_pmc_core.c ++++ b/drivers/platform/x86/intel_pmc_core.c +@@ -831,9 +831,15 @@ static const struct pci_device_id pmc_pci_ids[] = { + * the platform BIOS enforces 24Mhx Crystal to shutdown + * before PMC can assert SLP_S0#. + */ ++static bool xtal_ignore; + static int quirk_xtal_ignore(const struct dmi_system_id *id) + { +- struct pmc_dev *pmcdev = &pmc; ++ xtal_ignore = true; ++ return 0; ++} ++ ++static void pmc_core_xtal_ignore(struct pmc_dev *pmcdev) ++{ + u32 value; + + value = pmc_core_reg_read(pmcdev, pmcdev->map->pm_vric1_offset); +@@ -842,7 +848,6 @@ static int quirk_xtal_ignore(const struct dmi_system_id *id) + /* Low Voltage Mode Enable */ + value &= ~SPT_PMC_VRIC1_SLPS0LVEN; + pmc_core_reg_write(pmcdev, pmcdev->map->pm_vric1_offset, value); +- return 0; + } + + static const struct dmi_system_id pmc_core_dmi_table[] = { +@@ -857,6 +862,14 @@ static const struct dmi_system_id pmc_core_dmi_table[] = { + {} + }; + ++static void pmc_core_do_dmi_quirks(struct pmc_dev *pmcdev) ++{ ++ dmi_check_system(pmc_core_dmi_table); ++ ++ if (xtal_ignore) ++ pmc_core_xtal_ignore(pmcdev); ++} ++ + static int pmc_core_probe(struct platform_device *pdev) + { + static bool device_initialized; +@@ -898,7 +911,7 @@ static int pmc_core_probe(struct platform_device *pdev) + mutex_init(&pmcdev->lock); + platform_set_drvdata(pdev, pmcdev); + pmcdev->pmc_xram_read_bit = pmc_core_check_read_lock_bit(); +- dmi_check_system(pmc_core_dmi_table); ++ pmc_core_do_dmi_quirks(pmcdev); + + pmc_core_dbgfs_register(pmcdev); + +diff --git a/drivers/power/supply/bq27xxx_battery.c b/drivers/power/supply/bq27xxx_battery.c +index aff0a0a5e7f8c..b1a37aa388800 100644 +--- a/drivers/power/supply/bq27xxx_battery.c ++++ b/drivers/power/supply/bq27xxx_battery.c +@@ -1499,27 +1499,6 @@ static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg) + return tval * 60; + } + +-/* +- * Read an average power register. +- * Return < 0 if something fails. +- */ +-static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di) +-{ +- int tval; +- +- tval = bq27xxx_read(di, BQ27XXX_REG_AP, false); +- if (tval < 0) { +- dev_err(di->dev, "error reading average power register %02x: %d\n", +- BQ27XXX_REG_AP, tval); +- return tval; +- } +- +- if (di->opts & BQ27XXX_O_ZERO) +- return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS; +- else +- return tval; +-} +- + /* + * Returns true if a battery over temperature condition is detected + */ +@@ -1604,8 +1583,6 @@ void bq27xxx_battery_update(struct bq27xxx_device_info *di) + } + if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR) + cache.cycle_count = bq27xxx_battery_read_cyct(di); +- if (di->regs[BQ27XXX_REG_AP] != INVALID_REG_ADDR) +- cache.power_avg = bq27xxx_battery_read_pwr_avg(di); + + /* We only have to read charge design full once */ + if (di->charge_design_full <= 0) +@@ -1668,6 +1645,32 @@ static int bq27xxx_battery_current(struct bq27xxx_device_info *di, + return 0; + } + ++/* ++ * Get the average power in µW ++ * Return < 0 if something fails. ++ */ ++static int bq27xxx_battery_pwr_avg(struct bq27xxx_device_info *di, ++ union power_supply_propval *val) ++{ ++ int power; ++ ++ power = bq27xxx_read(di, BQ27XXX_REG_AP, false); ++ if (power < 0) { ++ dev_err(di->dev, ++ "error reading average power register %02x: %d\n", ++ BQ27XXX_REG_AP, power); ++ return power; ++ } ++ ++ if (di->opts & BQ27XXX_O_ZERO) ++ val->intval = (power * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS; ++ else ++ /* Other gauges return a signed value in units of 10mW */ ++ val->intval = (int)((s16)power) * 10000; ++ ++ return 0; ++} ++ + static int bq27xxx_battery_status(struct bq27xxx_device_info *di, + union power_supply_propval *val) + { +@@ -1835,7 +1838,7 @@ static int bq27xxx_battery_get_property(struct power_supply *psy, + ret = bq27xxx_simple_value(di->cache.energy, val); + break; + case POWER_SUPPLY_PROP_POWER_AVG: +- ret = bq27xxx_simple_value(di->cache.power_avg, val); ++ ret = bq27xxx_battery_pwr_avg(di, val); + break; + case POWER_SUPPLY_PROP_HEALTH: + ret = bq27xxx_simple_value(di->cache.health, val); +diff --git a/drivers/power/supply/generic-adc-battery.c b/drivers/power/supply/generic-adc-battery.c +index bc462d1ec9630..97b0e873e87d2 100644 +--- a/drivers/power/supply/generic-adc-battery.c ++++ b/drivers/power/supply/generic-adc-battery.c +@@ -382,7 +382,7 @@ static int gab_remove(struct platform_device *pdev) + } + + kfree(adc_bat->psy_desc.properties); +- cancel_delayed_work(&adc_bat->bat_work); ++ cancel_delayed_work_sync(&adc_bat->bat_work); + return 0; + } + +diff --git a/drivers/power/supply/lp8788-charger.c b/drivers/power/supply/lp8788-charger.c +index e7931ffb7151d..397e5a03b7d9a 100644 +--- a/drivers/power/supply/lp8788-charger.c ++++ b/drivers/power/supply/lp8788-charger.c +@@ -501,7 +501,7 @@ static int lp8788_set_irqs(struct platform_device *pdev, + + ret = request_threaded_irq(virq, NULL, + lp8788_charger_irq_thread, +- 0, name, pchg); ++ IRQF_ONESHOT, name, pchg); + if (ret) + break; + } +diff --git a/drivers/power/supply/pm2301_charger.c b/drivers/power/supply/pm2301_charger.c +index 17749fc90e165..d2aff1cf4f793 100644 +--- a/drivers/power/supply/pm2301_charger.c ++++ b/drivers/power/supply/pm2301_charger.c +@@ -1095,7 +1095,7 @@ static int pm2xxx_wall_charger_probe(struct i2c_client *i2c_client, + ret = request_threaded_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), + NULL, + pm2xxx_charger_irq[0].isr, +- pm2->pdata->irq_type, ++ pm2->pdata->irq_type | IRQF_ONESHOT, + pm2xxx_charger_irq[0].name, pm2); + + if (ret != 0) { +diff --git a/drivers/power/supply/s3c_adc_battery.c b/drivers/power/supply/s3c_adc_battery.c +index 3d00b35cafc9e..8be31f80035c6 100644 +--- a/drivers/power/supply/s3c_adc_battery.c ++++ b/drivers/power/supply/s3c_adc_battery.c +@@ -394,7 +394,7 @@ static int s3c_adc_bat_remove(struct platform_device *pdev) + gpio_free(pdata->gpio_charge_finished); + } + +- cancel_delayed_work(&bat_work); ++ cancel_delayed_work_sync(&bat_work); + + if (pdata->exit) + pdata->exit(); +diff --git a/drivers/power/supply/tps65090-charger.c b/drivers/power/supply/tps65090-charger.c +index 6b0098e5a88b5..0990b2fa6cd8d 100644 +--- a/drivers/power/supply/tps65090-charger.c ++++ b/drivers/power/supply/tps65090-charger.c +@@ -301,7 +301,7 @@ static int tps65090_charger_probe(struct platform_device *pdev) + + if (irq != -ENXIO) { + ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, +- tps65090_charger_isr, 0, "tps65090-charger", cdata); ++ tps65090_charger_isr, IRQF_ONESHOT, "tps65090-charger", cdata); + if (ret) { + dev_err(cdata->dev, + "Unable to register irq %d err %d\n", irq, +diff --git a/drivers/power/supply/tps65217_charger.c b/drivers/power/supply/tps65217_charger.c +index 814c2b81fdfec..ba33d1617e0b6 100644 +--- a/drivers/power/supply/tps65217_charger.c ++++ b/drivers/power/supply/tps65217_charger.c +@@ -238,7 +238,7 @@ static int tps65217_charger_probe(struct platform_device *pdev) + for (i = 0; i < NUM_CHARGER_IRQS; i++) { + ret = devm_request_threaded_irq(&pdev->dev, irq[i], NULL, + tps65217_charger_irq, +- 0, "tps65217-charger", ++ IRQF_ONESHOT, "tps65217-charger", + charger); + if (ret) { + dev_err(charger->dev, +diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c +index 308bda2e9c000..df5a3bbeba5eb 100644 +--- a/drivers/scsi/device_handler/scsi_dh_alua.c ++++ b/drivers/scsi/device_handler/scsi_dh_alua.c +@@ -565,10 +565,11 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg) + * even though it shouldn't according to T10. + * The retry without rtpg_ext_hdr_req set + * handles this. ++ * Note: some arrays return a sense key of ILLEGAL_REQUEST ++ * with ASC 00h if they don't support the extended header. + */ + if (!(pg->flags & ALUA_RTPG_EXT_HDR_UNSUPP) && +- sense_hdr.sense_key == ILLEGAL_REQUEST && +- sense_hdr.asc == 0x24 && sense_hdr.ascq == 0) { ++ sense_hdr.sense_key == ILLEGAL_REQUEST) { + pg->flags |= ALUA_RTPG_EXT_HDR_UNSUPP; + goto retry; + } +diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c +index 684c5e361a286..9399e1455d597 100644 +--- a/drivers/scsi/libfc/fc_lport.c ++++ b/drivers/scsi/libfc/fc_lport.c +@@ -1729,7 +1729,7 @@ void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp, + + if (mfs < FC_SP_MIN_MAX_PAYLOAD || mfs > FC_SP_MAX_MAX_PAYLOAD) { + FC_LPORT_DBG(lport, "FLOGI bad mfs:%hu response, " +- "lport->mfs:%hu\n", mfs, lport->mfs); ++ "lport->mfs:%u\n", mfs, lport->mfs); + fc_lport_error(lport, fp); + goto out; + } +diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c +index bb973901b672d..45db19e31b348 100644 +--- a/drivers/scsi/lpfc/lpfc_attr.c ++++ b/drivers/scsi/lpfc/lpfc_attr.c +@@ -1691,8 +1691,7 @@ lpfc_set_trunking(struct lpfc_hba *phba, char *buff_out) + lpfc_printf_log(phba, KERN_ERR, LOG_MBOX, + "0071 Set trunk mode failed with status: %d", + rc); +- if (rc != MBX_TIMEOUT) +- mempool_free(mbox, phba->mbox_mem_pool); ++ mempool_free(mbox, phba->mbox_mem_pool); + + return 0; + } +@@ -6608,15 +6607,19 @@ lpfc_get_stats(struct Scsi_Host *shost) + pmboxq->ctx_buf = NULL; + pmboxq->vport = vport; + +- if (vport->fc_flag & FC_OFFLINE_MODE) ++ if (vport->fc_flag & FC_OFFLINE_MODE) { + rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); +- else +- rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); +- +- if (rc != MBX_SUCCESS) { +- if (rc != MBX_TIMEOUT) ++ if (rc != MBX_SUCCESS) { + mempool_free(pmboxq, phba->mbox_mem_pool); +- return NULL; ++ return NULL; ++ } ++ } else { ++ rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); ++ if (rc != MBX_SUCCESS) { ++ if (rc != MBX_TIMEOUT) ++ mempool_free(pmboxq, phba->mbox_mem_pool); ++ return NULL; ++ } + } + + memset(hs, 0, sizeof (struct fc_host_statistics)); +@@ -6640,15 +6643,19 @@ lpfc_get_stats(struct Scsi_Host *shost) + pmboxq->ctx_buf = NULL; + pmboxq->vport = vport; + +- if (vport->fc_flag & FC_OFFLINE_MODE) ++ if (vport->fc_flag & FC_OFFLINE_MODE) { + rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); +- else +- rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); +- +- if (rc != MBX_SUCCESS) { +- if (rc != MBX_TIMEOUT) ++ if (rc != MBX_SUCCESS) { + mempool_free(pmboxq, phba->mbox_mem_pool); +- return NULL; ++ return NULL; ++ } ++ } else { ++ rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); ++ if (rc != MBX_SUCCESS) { ++ if (rc != MBX_TIMEOUT) ++ mempool_free(pmboxq, phba->mbox_mem_pool); ++ return NULL; ++ } + } + + hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt; +@@ -6721,15 +6728,19 @@ lpfc_reset_stats(struct Scsi_Host *shost) + pmboxq->vport = vport; + + if ((vport->fc_flag & FC_OFFLINE_MODE) || +- (!(psli->sli_flag & LPFC_SLI_ACTIVE))) ++ (!(psli->sli_flag & LPFC_SLI_ACTIVE))) { + rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); +- else +- rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); +- +- if (rc != MBX_SUCCESS) { +- if (rc != MBX_TIMEOUT) ++ if (rc != MBX_SUCCESS) { + mempool_free(pmboxq, phba->mbox_mem_pool); +- return; ++ return; ++ } ++ } else { ++ rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); ++ if (rc != MBX_SUCCESS) { ++ if (rc != MBX_TIMEOUT) ++ mempool_free(pmboxq, phba->mbox_mem_pool); ++ return; ++ } + } + + memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t)); +@@ -6739,15 +6750,19 @@ lpfc_reset_stats(struct Scsi_Host *shost) + pmboxq->vport = vport; + + if ((vport->fc_flag & FC_OFFLINE_MODE) || +- (!(psli->sli_flag & LPFC_SLI_ACTIVE))) ++ (!(psli->sli_flag & LPFC_SLI_ACTIVE))) { + rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL); +- else ++ if (rc != MBX_SUCCESS) { ++ mempool_free(pmboxq, phba->mbox_mem_pool); ++ return; ++ } ++ } else { + rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2); +- +- if (rc != MBX_SUCCESS) { +- if (rc != MBX_TIMEOUT) +- mempool_free( pmboxq, phba->mbox_mem_pool); +- return; ++ if (rc != MBX_SUCCESS) { ++ if (rc != MBX_TIMEOUT) ++ mempool_free(pmboxq, phba->mbox_mem_pool); ++ return; ++ } + } + + lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt; +diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h +index 0f019e889ba6b..bdb1f380e7d8c 100644 +--- a/drivers/scsi/lpfc/lpfc_crtn.h ++++ b/drivers/scsi/lpfc/lpfc_crtn.h +@@ -56,9 +56,6 @@ void lpfc_register_new_vport(struct lpfc_hba *, struct lpfc_vport *, + void lpfc_unreg_vpi(struct lpfc_hba *, uint16_t, LPFC_MBOXQ_t *); + void lpfc_init_link(struct lpfc_hba *, LPFC_MBOXQ_t *, uint32_t, uint32_t); + void lpfc_request_features(struct lpfc_hba *, struct lpfcMboxq *); +-void lpfc_supported_pages(struct lpfcMboxq *); +-void lpfc_pc_sli4_params(struct lpfcMboxq *); +-int lpfc_pc_sli4_params_get(struct lpfc_hba *, LPFC_MBOXQ_t *); + int lpfc_sli4_mbox_rsrc_extent(struct lpfc_hba *, struct lpfcMboxq *, + uint16_t, uint16_t, bool); + int lpfc_get_sli4_parameters(struct lpfc_hba *, LPFC_MBOXQ_t *); +diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h +index bd533475c86a4..b8a772f80d6c5 100644 +--- a/drivers/scsi/lpfc/lpfc_hw4.h ++++ b/drivers/scsi/lpfc/lpfc_hw4.h +@@ -122,6 +122,7 @@ struct lpfc_sli_intf { + /* Define SLI4 Alignment requirements. */ + #define LPFC_ALIGN_16_BYTE 16 + #define LPFC_ALIGN_64_BYTE 64 ++#define SLI4_PAGE_SIZE 4096 + + /* Define SLI4 specific definitions. */ + #define LPFC_MQ_CQE_BYTE_OFFSET 256 +@@ -2962,62 +2963,6 @@ struct lpfc_mbx_request_features { + #define lpfc_mbx_rq_ftr_rsp_mrqp_WORD word3 + }; + +-struct lpfc_mbx_supp_pages { +- uint32_t word1; +-#define qs_SHIFT 0 +-#define qs_MASK 0x00000001 +-#define qs_WORD word1 +-#define wr_SHIFT 1 +-#define wr_MASK 0x00000001 +-#define wr_WORD word1 +-#define pf_SHIFT 8 +-#define pf_MASK 0x000000ff +-#define pf_WORD word1 +-#define cpn_SHIFT 16 +-#define cpn_MASK 0x000000ff +-#define cpn_WORD word1 +- uint32_t word2; +-#define list_offset_SHIFT 0 +-#define list_offset_MASK 0x000000ff +-#define list_offset_WORD word2 +-#define next_offset_SHIFT 8 +-#define next_offset_MASK 0x000000ff +-#define next_offset_WORD word2 +-#define elem_cnt_SHIFT 16 +-#define elem_cnt_MASK 0x000000ff +-#define elem_cnt_WORD word2 +- uint32_t word3; +-#define pn_0_SHIFT 24 +-#define pn_0_MASK 0x000000ff +-#define pn_0_WORD word3 +-#define pn_1_SHIFT 16 +-#define pn_1_MASK 0x000000ff +-#define pn_1_WORD word3 +-#define pn_2_SHIFT 8 +-#define pn_2_MASK 0x000000ff +-#define pn_2_WORD word3 +-#define pn_3_SHIFT 0 +-#define pn_3_MASK 0x000000ff +-#define pn_3_WORD word3 +- uint32_t word4; +-#define pn_4_SHIFT 24 +-#define pn_4_MASK 0x000000ff +-#define pn_4_WORD word4 +-#define pn_5_SHIFT 16 +-#define pn_5_MASK 0x000000ff +-#define pn_5_WORD word4 +-#define pn_6_SHIFT 8 +-#define pn_6_MASK 0x000000ff +-#define pn_6_WORD word4 +-#define pn_7_SHIFT 0 +-#define pn_7_MASK 0x000000ff +-#define pn_7_WORD word4 +- uint32_t rsvd[27]; +-#define LPFC_SUPP_PAGES 0 +-#define LPFC_BLOCK_GUARD_PROFILES 1 +-#define LPFC_SLI4_PARAMETERS 2 +-}; +- + struct lpfc_mbx_memory_dump_type3 { + uint32_t word1; + #define lpfc_mbx_memory_dump_type3_type_SHIFT 0 +@@ -3234,121 +3179,6 @@ struct user_eeprom { + uint8_t reserved191[57]; + }; + +-struct lpfc_mbx_pc_sli4_params { +- uint32_t word1; +-#define qs_SHIFT 0 +-#define qs_MASK 0x00000001 +-#define qs_WORD word1 +-#define wr_SHIFT 1 +-#define wr_MASK 0x00000001 +-#define wr_WORD word1 +-#define pf_SHIFT 8 +-#define pf_MASK 0x000000ff +-#define pf_WORD word1 +-#define cpn_SHIFT 16 +-#define cpn_MASK 0x000000ff +-#define cpn_WORD word1 +- uint32_t word2; +-#define if_type_SHIFT 0 +-#define if_type_MASK 0x00000007 +-#define if_type_WORD word2 +-#define sli_rev_SHIFT 4 +-#define sli_rev_MASK 0x0000000f +-#define sli_rev_WORD word2 +-#define sli_family_SHIFT 8 +-#define sli_family_MASK 0x000000ff +-#define sli_family_WORD word2 +-#define featurelevel_1_SHIFT 16 +-#define featurelevel_1_MASK 0x000000ff +-#define featurelevel_1_WORD word2 +-#define featurelevel_2_SHIFT 24 +-#define featurelevel_2_MASK 0x0000001f +-#define featurelevel_2_WORD word2 +- uint32_t word3; +-#define fcoe_SHIFT 0 +-#define fcoe_MASK 0x00000001 +-#define fcoe_WORD word3 +-#define fc_SHIFT 1 +-#define fc_MASK 0x00000001 +-#define fc_WORD word3 +-#define nic_SHIFT 2 +-#define nic_MASK 0x00000001 +-#define nic_WORD word3 +-#define iscsi_SHIFT 3 +-#define iscsi_MASK 0x00000001 +-#define iscsi_WORD word3 +-#define rdma_SHIFT 4 +-#define rdma_MASK 0x00000001 +-#define rdma_WORD word3 +- uint32_t sge_supp_len; +-#define SLI4_PAGE_SIZE 4096 +- uint32_t word5; +-#define if_page_sz_SHIFT 0 +-#define if_page_sz_MASK 0x0000ffff +-#define if_page_sz_WORD word5 +-#define loopbk_scope_SHIFT 24 +-#define loopbk_scope_MASK 0x0000000f +-#define loopbk_scope_WORD word5 +-#define rq_db_window_SHIFT 28 +-#define rq_db_window_MASK 0x0000000f +-#define rq_db_window_WORD word5 +- uint32_t word6; +-#define eq_pages_SHIFT 0 +-#define eq_pages_MASK 0x0000000f +-#define eq_pages_WORD word6 +-#define eqe_size_SHIFT 8 +-#define eqe_size_MASK 0x000000ff +-#define eqe_size_WORD word6 +- uint32_t word7; +-#define cq_pages_SHIFT 0 +-#define cq_pages_MASK 0x0000000f +-#define cq_pages_WORD word7 +-#define cqe_size_SHIFT 8 +-#define cqe_size_MASK 0x000000ff +-#define cqe_size_WORD word7 +- uint32_t word8; +-#define mq_pages_SHIFT 0 +-#define mq_pages_MASK 0x0000000f +-#define mq_pages_WORD word8 +-#define mqe_size_SHIFT 8 +-#define mqe_size_MASK 0x000000ff +-#define mqe_size_WORD word8 +-#define mq_elem_cnt_SHIFT 16 +-#define mq_elem_cnt_MASK 0x000000ff +-#define mq_elem_cnt_WORD word8 +- uint32_t word9; +-#define wq_pages_SHIFT 0 +-#define wq_pages_MASK 0x0000ffff +-#define wq_pages_WORD word9 +-#define wqe_size_SHIFT 8 +-#define wqe_size_MASK 0x000000ff +-#define wqe_size_WORD word9 +- uint32_t word10; +-#define rq_pages_SHIFT 0 +-#define rq_pages_MASK 0x0000ffff +-#define rq_pages_WORD word10 +-#define rqe_size_SHIFT 8 +-#define rqe_size_MASK 0x000000ff +-#define rqe_size_WORD word10 +- uint32_t word11; +-#define hdr_pages_SHIFT 0 +-#define hdr_pages_MASK 0x0000000f +-#define hdr_pages_WORD word11 +-#define hdr_size_SHIFT 8 +-#define hdr_size_MASK 0x0000000f +-#define hdr_size_WORD word11 +-#define hdr_pp_align_SHIFT 16 +-#define hdr_pp_align_MASK 0x0000ffff +-#define hdr_pp_align_WORD word11 +- uint32_t word12; +-#define sgl_pages_SHIFT 0 +-#define sgl_pages_MASK 0x0000000f +-#define sgl_pages_WORD word12 +-#define sgl_pp_align_SHIFT 16 +-#define sgl_pp_align_MASK 0x0000ffff +-#define sgl_pp_align_WORD word12 +- uint32_t rsvd_13_63[51]; +-}; + #define SLI4_PAGE_ALIGN(addr) (((addr)+((SLI4_PAGE_SIZE)-1)) \ + &(~((SLI4_PAGE_SIZE)-1))) + +@@ -3958,8 +3788,6 @@ struct lpfc_mqe { + struct lpfc_mbx_post_hdr_tmpl hdr_tmpl; + struct lpfc_mbx_query_fw_config query_fw_cfg; + struct lpfc_mbx_set_beacon_config beacon_config; +- struct lpfc_mbx_supp_pages supp_pages; +- struct lpfc_mbx_pc_sli4_params sli4_params; + struct lpfc_mbx_get_sli4_parameters get_sli4_parameters; + struct lpfc_mbx_set_link_diag_state link_diag_state; + struct lpfc_mbx_set_link_diag_loopback link_diag_loopback; +diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c +index d4c83eca0ad2c..b5cee2a2ac66c 100644 +--- a/drivers/scsi/lpfc/lpfc_init.c ++++ b/drivers/scsi/lpfc/lpfc_init.c +@@ -6415,8 +6415,6 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) + LPFC_MBOXQ_t *mboxq; + MAILBOX_t *mb; + int rc, i, max_buf_size; +- uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0}; +- struct lpfc_mqe *mqe; + int longs; + int extra; + uint64_t wwn; +@@ -6640,32 +6638,6 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) + + lpfc_nvme_mod_param_dep(phba); + +- /* Get the Supported Pages if PORT_CAPABILITIES is supported by port. */ +- lpfc_supported_pages(mboxq); +- rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL); +- if (!rc) { +- mqe = &mboxq->u.mqe; +- memcpy(&pn_page[0], ((uint8_t *)&mqe->un.supp_pages.word3), +- LPFC_MAX_SUPPORTED_PAGES); +- for (i = 0; i < LPFC_MAX_SUPPORTED_PAGES; i++) { +- switch (pn_page[i]) { +- case LPFC_SLI4_PARAMETERS: +- phba->sli4_hba.pc_sli4_params.supported = 1; +- break; +- default: +- break; +- } +- } +- /* Read the port's SLI4 Parameters capabilities if supported. */ +- if (phba->sli4_hba.pc_sli4_params.supported) +- rc = lpfc_pc_sli4_params_get(phba, mboxq); +- if (rc) { +- mempool_free(mboxq, phba->mbox_mem_pool); +- rc = -EIO; +- goto out_free_bsmbx; +- } +- } +- + /* + * Get sli4 parameters that override parameters from Port capabilities. + * If this call fails, it isn't critical unless the SLI4 parameters come +@@ -9387,8 +9359,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) + "3250 QUERY_FW_CFG mailbox failed with status " + "x%x add_status x%x, mbx status x%x\n", + shdr_status, shdr_add_status, rc); +- if (rc != MBX_TIMEOUT) +- mempool_free(mboxq, phba->mbox_mem_pool); ++ mempool_free(mboxq, phba->mbox_mem_pool); + rc = -ENXIO; + goto out_error; + } +@@ -9404,8 +9375,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) + "ulp1_mode:x%x\n", phba->sli4_hba.fw_func_mode, + phba->sli4_hba.ulp0_mode, phba->sli4_hba.ulp1_mode); + +- if (rc != MBX_TIMEOUT) +- mempool_free(mboxq, phba->mbox_mem_pool); ++ mempool_free(mboxq, phba->mbox_mem_pool); + + /* + * Set up HBA Event Queues (EQs) +@@ -10001,8 +9971,7 @@ lpfc_pci_function_reset(struct lpfc_hba *phba) + shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response); + shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, + &shdr->response); +- if (rc != MBX_TIMEOUT) +- mempool_free(mboxq, phba->mbox_mem_pool); ++ mempool_free(mboxq, phba->mbox_mem_pool); + if (shdr_status || shdr_add_status || rc) { + lpfc_printf_log(phba, KERN_ERR, LOG_INIT, + "0495 SLI_FUNCTION_RESET mailbox " +@@ -11577,78 +11546,6 @@ lpfc_sli4_hba_unset(struct lpfc_hba *phba) + phba->pport->work_port_events = 0; + } + +- /** +- * lpfc_pc_sli4_params_get - Get the SLI4_PARAMS port capabilities. +- * @phba: Pointer to HBA context object. +- * @mboxq: Pointer to the mailboxq memory for the mailbox command response. +- * +- * This function is called in the SLI4 code path to read the port's +- * sli4 capabilities. +- * +- * This function may be be called from any context that can block-wait +- * for the completion. The expectation is that this routine is called +- * typically from probe_one or from the online routine. +- **/ +-int +-lpfc_pc_sli4_params_get(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) +-{ +- int rc; +- struct lpfc_mqe *mqe; +- struct lpfc_pc_sli4_params *sli4_params; +- uint32_t mbox_tmo; +- +- rc = 0; +- mqe = &mboxq->u.mqe; +- +- /* Read the port's SLI4 Parameters port capabilities */ +- lpfc_pc_sli4_params(mboxq); +- if (!phba->sli4_hba.intr_enable) +- rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL); +- else { +- mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq); +- rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo); +- } +- +- if (unlikely(rc)) +- return 1; +- +- sli4_params = &phba->sli4_hba.pc_sli4_params; +- sli4_params->if_type = bf_get(if_type, &mqe->un.sli4_params); +- sli4_params->sli_rev = bf_get(sli_rev, &mqe->un.sli4_params); +- sli4_params->sli_family = bf_get(sli_family, &mqe->un.sli4_params); +- sli4_params->featurelevel_1 = bf_get(featurelevel_1, +- &mqe->un.sli4_params); +- sli4_params->featurelevel_2 = bf_get(featurelevel_2, +- &mqe->un.sli4_params); +- sli4_params->proto_types = mqe->un.sli4_params.word3; +- sli4_params->sge_supp_len = mqe->un.sli4_params.sge_supp_len; +- sli4_params->if_page_sz = bf_get(if_page_sz, &mqe->un.sli4_params); +- sli4_params->rq_db_window = bf_get(rq_db_window, &mqe->un.sli4_params); +- sli4_params->loopbk_scope = bf_get(loopbk_scope, &mqe->un.sli4_params); +- sli4_params->eq_pages_max = bf_get(eq_pages, &mqe->un.sli4_params); +- sli4_params->eqe_size = bf_get(eqe_size, &mqe->un.sli4_params); +- sli4_params->cq_pages_max = bf_get(cq_pages, &mqe->un.sli4_params); +- sli4_params->cqe_size = bf_get(cqe_size, &mqe->un.sli4_params); +- sli4_params->mq_pages_max = bf_get(mq_pages, &mqe->un.sli4_params); +- sli4_params->mqe_size = bf_get(mqe_size, &mqe->un.sli4_params); +- sli4_params->mq_elem_cnt = bf_get(mq_elem_cnt, &mqe->un.sli4_params); +- sli4_params->wq_pages_max = bf_get(wq_pages, &mqe->un.sli4_params); +- sli4_params->wqe_size = bf_get(wqe_size, &mqe->un.sli4_params); +- sli4_params->rq_pages_max = bf_get(rq_pages, &mqe->un.sli4_params); +- sli4_params->rqe_size = bf_get(rqe_size, &mqe->un.sli4_params); +- sli4_params->hdr_pages_max = bf_get(hdr_pages, &mqe->un.sli4_params); +- sli4_params->hdr_size = bf_get(hdr_size, &mqe->un.sli4_params); +- sli4_params->hdr_pp_align = bf_get(hdr_pp_align, &mqe->un.sli4_params); +- sli4_params->sgl_pages_max = bf_get(sgl_pages, &mqe->un.sli4_params); +- sli4_params->sgl_pp_align = bf_get(sgl_pp_align, &mqe->un.sli4_params); +- +- /* Make sure that sge_supp_len can be handled by the driver */ +- if (sli4_params->sge_supp_len > LPFC_MAX_SGE_SIZE) +- sli4_params->sge_supp_len = LPFC_MAX_SGE_SIZE; +- +- return rc; +-} +- + /** + * lpfc_get_sli4_parameters - Get the SLI4 Config PARAMETERS. + * @phba: Pointer to HBA context object. +@@ -11707,7 +11604,8 @@ lpfc_get_sli4_parameters(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) + else + phba->sli3_options &= ~LPFC_SLI4_PHWQ_ENABLED; + sli4_params->sge_supp_len = mbx_sli4_parameters->sge_supp_len; +- sli4_params->loopbk_scope = bf_get(loopbk_scope, mbx_sli4_parameters); ++ sli4_params->loopbk_scope = bf_get(cfg_loopbk_scope, ++ mbx_sli4_parameters); + sli4_params->oas_supported = bf_get(cfg_oas, mbx_sli4_parameters); + sli4_params->cqv = bf_get(cfg_cqv, mbx_sli4_parameters); + sli4_params->mqv = bf_get(cfg_mqv, mbx_sli4_parameters); +diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c +index 8abe933bad090..4a331164086e2 100644 +--- a/drivers/scsi/lpfc/lpfc_mbox.c ++++ b/drivers/scsi/lpfc/lpfc_mbox.c +@@ -2622,39 +2622,3 @@ lpfc_resume_rpi(struct lpfcMboxq *mbox, struct lpfc_nodelist *ndlp) + resume_rpi->event_tag = ndlp->phba->fc_eventTag; + } + +-/** +- * lpfc_supported_pages - Initialize the PORT_CAPABILITIES supported pages +- * mailbox command. +- * @mbox: pointer to lpfc mbox command to initialize. +- * +- * The PORT_CAPABILITIES supported pages mailbox command is issued to +- * retrieve the particular feature pages supported by the port. +- **/ +-void +-lpfc_supported_pages(struct lpfcMboxq *mbox) +-{ +- struct lpfc_mbx_supp_pages *supp_pages; +- +- memset(mbox, 0, sizeof(*mbox)); +- supp_pages = &mbox->u.mqe.un.supp_pages; +- bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_PORT_CAPABILITIES); +- bf_set(cpn, supp_pages, LPFC_SUPP_PAGES); +-} +- +-/** +- * lpfc_pc_sli4_params - Initialize the PORT_CAPABILITIES SLI4 Params mbox cmd. +- * @mbox: pointer to lpfc mbox command to initialize. +- * +- * The PORT_CAPABILITIES SLI4 parameters mailbox command is issued to +- * retrieve the particular SLI4 features supported by the port. +- **/ +-void +-lpfc_pc_sli4_params(struct lpfcMboxq *mbox) +-{ +- struct lpfc_mbx_pc_sli4_params *sli4_params; +- +- memset(mbox, 0, sizeof(*mbox)); +- sli4_params = &mbox->u.mqe.un.sli4_params; +- bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_PORT_CAPABILITIES); +- bf_set(cpn, sli4_params, LPFC_SLI4_PARAMETERS); +-} +diff --git a/drivers/scsi/lpfc/lpfc_nportdisc.c b/drivers/scsi/lpfc/lpfc_nportdisc.c +index 418d62e945544..fdd87508c804d 100644 +--- a/drivers/scsi/lpfc/lpfc_nportdisc.c ++++ b/drivers/scsi/lpfc/lpfc_nportdisc.c +@@ -888,9 +888,14 @@ lpfc_rcv_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, + } + } else if ((!(ndlp->nlp_type & NLP_FABRIC) && + ((ndlp->nlp_type & NLP_FCP_TARGET) || +- !(ndlp->nlp_type & NLP_FCP_INITIATOR))) || ++ (ndlp->nlp_type & NLP_NVME_TARGET) || ++ (vport->fc_flag & FC_PT2PT))) || + (ndlp->nlp_state == NLP_STE_ADISC_ISSUE)) { +- /* Only try to re-login if this is NOT a Fabric Node */ ++ /* Only try to re-login if this is NOT a Fabric Node ++ * AND the remote NPORT is a FCP/NVME Target or we ++ * are in pt2pt mode. NLP_STE_ADISC_ISSUE is a special ++ * case for LOGO as a response to ADISC behavior. ++ */ + mod_timer(&ndlp->nlp_delayfunc, + jiffies + msecs_to_jiffies(1000 * 1)); + spin_lock_irq(shost->host_lock); +@@ -1956,8 +1961,6 @@ lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_vport *vport, + ndlp->nlp_last_elscmd = ELS_CMD_PLOGI; + + lpfc_issue_els_logo(vport, ndlp, 0); +- ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE; +- lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); + return ndlp->nlp_state; + } + +diff --git a/drivers/scsi/lpfc/lpfc_nvmet.c b/drivers/scsi/lpfc/lpfc_nvmet.c +index f14394ab0e037..ce2e2b58fa7e6 100644 +--- a/drivers/scsi/lpfc/lpfc_nvmet.c ++++ b/drivers/scsi/lpfc/lpfc_nvmet.c +@@ -3204,7 +3204,6 @@ lpfc_nvmet_unsol_issue_abort(struct lpfc_hba *phba, + bf_set(wqe_rcvoxid, &wqe_abts->xmit_sequence.wqe_com, xri); + + /* Word 10 */ +- bf_set(wqe_dbde, &wqe_abts->xmit_sequence.wqe_com, 1); + bf_set(wqe_iod, &wqe_abts->xmit_sequence.wqe_com, LPFC_WQE_IOD_WRITE); + bf_set(wqe_lenloc, &wqe_abts->xmit_sequence.wqe_com, + LPFC_WQE_LENLOC_WORD12); +diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c +index b9857d7b224fb..ef7cef316d210 100644 +--- a/drivers/scsi/lpfc/lpfc_sli.c ++++ b/drivers/scsi/lpfc/lpfc_sli.c +@@ -5423,12 +5423,10 @@ lpfc_sli4_get_ctl_attr(struct lpfc_hba *phba) + phba->sli4_hba.lnk_info.lnk_no, + phba->BIOSVersion); + out_free_mboxq: +- if (rc != MBX_TIMEOUT) { +- if (bf_get(lpfc_mqe_command, &mboxq->u.mqe) == MBX_SLI4_CONFIG) +- lpfc_sli4_mbox_cmd_free(phba, mboxq); +- else +- mempool_free(mboxq, phba->mbox_mem_pool); +- } ++ if (bf_get(lpfc_mqe_command, &mboxq->u.mqe) == MBX_SLI4_CONFIG) ++ lpfc_sli4_mbox_cmd_free(phba, mboxq); ++ else ++ mempool_free(mboxq, phba->mbox_mem_pool); + return rc; + } + +@@ -5529,12 +5527,10 @@ retrieve_ppname: + } + + out_free_mboxq: +- if (rc != MBX_TIMEOUT) { +- if (bf_get(lpfc_mqe_command, &mboxq->u.mqe) == MBX_SLI4_CONFIG) +- lpfc_sli4_mbox_cmd_free(phba, mboxq); +- else +- mempool_free(mboxq, phba->mbox_mem_pool); +- } ++ if (bf_get(lpfc_mqe_command, &mboxq->u.mqe) == MBX_SLI4_CONFIG) ++ lpfc_sli4_mbox_cmd_free(phba, mboxq); ++ else ++ mempool_free(mboxq, phba->mbox_mem_pool); + return rc; + } + +@@ -16485,8 +16481,7 @@ lpfc_rq_destroy(struct lpfc_hba *phba, struct lpfc_queue *hrq, + "2509 RQ_DESTROY mailbox failed with " + "status x%x add_status x%x, mbx status x%x\n", + shdr_status, shdr_add_status, rc); +- if (rc != MBX_TIMEOUT) +- mempool_free(mbox, hrq->phba->mbox_mem_pool); ++ mempool_free(mbox, hrq->phba->mbox_mem_pool); + return -ENXIO; + } + bf_set(lpfc_mbx_rq_destroy_q_id, &mbox->u.mqe.un.rq_destroy.u.request, +@@ -16583,7 +16578,9 @@ lpfc_sli4_post_sgl(struct lpfc_hba *phba, + shdr = (union lpfc_sli4_cfg_shdr *) &post_sgl_pages->header.cfg_shdr; + shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response); + shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response); +- if (rc != MBX_TIMEOUT) ++ if (!phba->sli4_hba.intr_enable) ++ mempool_free(mbox, phba->mbox_mem_pool); ++ else if (rc != MBX_TIMEOUT) + mempool_free(mbox, phba->mbox_mem_pool); + if (shdr_status || shdr_add_status || rc) { + lpfc_printf_log(phba, KERN_ERR, LOG_INIT, +@@ -16778,7 +16775,9 @@ lpfc_sli4_post_sgl_list(struct lpfc_hba *phba, + shdr = (union lpfc_sli4_cfg_shdr *) &sgl->cfg_shdr; + shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response); + shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response); +- if (rc != MBX_TIMEOUT) ++ if (!phba->sli4_hba.intr_enable) ++ lpfc_sli4_mbox_cmd_free(phba, mbox); ++ else if (rc != MBX_TIMEOUT) + lpfc_sli4_mbox_cmd_free(phba, mbox); + if (shdr_status || shdr_add_status || rc) { + lpfc_printf_log(phba, KERN_ERR, LOG_SLI, +@@ -16891,7 +16890,9 @@ lpfc_sli4_post_io_sgl_block(struct lpfc_hba *phba, struct list_head *nblist, + shdr = (union lpfc_sli4_cfg_shdr *)&sgl->cfg_shdr; + shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response); + shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response); +- if (rc != MBX_TIMEOUT) ++ if (!phba->sli4_hba.intr_enable) ++ lpfc_sli4_mbox_cmd_free(phba, mbox); ++ else if (rc != MBX_TIMEOUT) + lpfc_sli4_mbox_cmd_free(phba, mbox); + if (shdr_status || shdr_add_status || rc) { + lpfc_printf_log(phba, KERN_ERR, LOG_SLI, +@@ -17472,7 +17473,6 @@ lpfc_sli4_seq_abort_rsp_cmpl(struct lpfc_hba *phba, + if (cmd_iocbq) { + ndlp = (struct lpfc_nodelist *)cmd_iocbq->context1; + lpfc_nlp_put(ndlp); +- lpfc_nlp_not_used(ndlp); + lpfc_sli_release_iocbq(phba, cmd_iocbq); + } + +@@ -18239,8 +18239,7 @@ lpfc_sli4_post_rpi_hdr(struct lpfc_hba *phba, struct lpfc_rpi_hdr *rpi_page) + shdr = (union lpfc_sli4_cfg_shdr *) &hdr_tmpl->header.cfg_shdr; + shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response); + shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response); +- if (rc != MBX_TIMEOUT) +- mempool_free(mboxq, phba->mbox_mem_pool); ++ mempool_free(mboxq, phba->mbox_mem_pool); + if (shdr_status || shdr_add_status || rc) { + lpfc_printf_log(phba, KERN_ERR, LOG_INIT, + "2514 POST_RPI_HDR mailbox failed with " +@@ -19465,7 +19464,9 @@ lpfc_wr_object(struct lpfc_hba *phba, struct list_head *dmabuf_list, + break; + } + } +- if (rc != MBX_TIMEOUT) ++ if (!phba->sli4_hba.intr_enable) ++ mempool_free(mbox, phba->mbox_mem_pool); ++ else if (rc != MBX_TIMEOUT) + mempool_free(mbox, phba->mbox_mem_pool); + if (shdr_status || shdr_add_status || rc) { + lpfc_printf_log(phba, KERN_ERR, LOG_INIT, +diff --git a/drivers/scsi/mpt3sas/mpt3sas_base.c b/drivers/scsi/mpt3sas/mpt3sas_base.c +index b6d42b2ce6fe4..e72f1dbc91f7f 100644 +--- a/drivers/scsi/mpt3sas/mpt3sas_base.c ++++ b/drivers/scsi/mpt3sas/mpt3sas_base.c +@@ -6572,6 +6572,8 @@ _base_diag_reset(struct MPT3SAS_ADAPTER *ioc) + + ioc_info(ioc, "sending diag reset !!\n"); + ++ pci_cfg_access_lock(ioc->pdev); ++ + drsprintk(ioc, ioc_info(ioc, "clear interrupts\n")); + + count = 0; +@@ -6653,10 +6655,12 @@ _base_diag_reset(struct MPT3SAS_ADAPTER *ioc) + goto out; + } + ++ pci_cfg_access_unlock(ioc->pdev); + ioc_info(ioc, "diag reset: SUCCESS\n"); + return 0; + + out: ++ pci_cfg_access_unlock(ioc->pdev); + ioc_err(ioc, "diag reset: FAILED\n"); + return -EFAULT; + } +diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c +index bed7e86372174..580d30cd5c35c 100644 +--- a/drivers/scsi/qla2xxx/qla_attr.c ++++ b/drivers/scsi/qla2xxx/qla_attr.c +@@ -2691,6 +2691,8 @@ qla2x00_reset_host_stats(struct Scsi_Host *shost) + vha->qla_stats.jiffies_at_last_reset = get_jiffies_64(); + + if (IS_FWI2_CAPABLE(ha)) { ++ int rval; ++ + stats = dma_alloc_coherent(&ha->pdev->dev, + sizeof(*stats), &stats_dma, GFP_KERNEL); + if (!stats) { +@@ -2700,7 +2702,11 @@ qla2x00_reset_host_stats(struct Scsi_Host *shost) + } + + /* reset firmware statistics */ +- qla24xx_get_isp_stats(base_vha, stats, stats_dma, BIT_0); ++ rval = qla24xx_get_isp_stats(base_vha, stats, stats_dma, BIT_0); ++ if (rval != QLA_SUCCESS) ++ ql_log(ql_log_warn, vha, 0x70de, ++ "Resetting ISP statistics failed: rval = %d\n", ++ rval); + + dma_free_coherent(&ha->pdev->dev, sizeof(*stats), + stats, stats_dma); +diff --git a/drivers/scsi/qla2xxx/qla_bsg.c b/drivers/scsi/qla2xxx/qla_bsg.c +index cbaf178fc9796..ce55121910e89 100644 +--- a/drivers/scsi/qla2xxx/qla_bsg.c ++++ b/drivers/scsi/qla2xxx/qla_bsg.c +@@ -17,10 +17,11 @@ void qla2x00_bsg_job_done(srb_t *sp, int res) + struct bsg_job *bsg_job = sp->u.bsg_job; + struct fc_bsg_reply *bsg_reply = bsg_job->reply; + ++ sp->free(sp); ++ + bsg_reply->result = res; + bsg_job_done(bsg_job, bsg_reply->result, + bsg_reply->reply_payload_rcv_len); +- sp->free(sp); + } + + void qla2x00_bsg_sp_free(srb_t *sp) +diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c +index af8306a9777fc..052ce78814075 100644 +--- a/drivers/scsi/qla2xxx/qla_os.c ++++ b/drivers/scsi/qla2xxx/qla_os.c +@@ -983,8 +983,6 @@ qla2xxx_mqueuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd, + if (rval != QLA_SUCCESS) { + ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x3078, + "Start scsi failed rval=%d for cmd=%p.\n", rval, cmd); +- if (rval == QLA_INTERFACE_ERROR) +- goto qc24_free_sp_fail_command; + goto qc24_host_busy_free_sp; + } + +@@ -996,11 +994,6 @@ qc24_host_busy_free_sp: + qc24_target_busy: + return SCSI_MLQUEUE_TARGET_BUSY; + +-qc24_free_sp_fail_command: +- sp->free(sp); +- CMD_SP(cmd) = NULL; +- qla2xxx_rel_qpair_sp(sp->qpair, sp); +- + qc24_fail_command: + cmd->scsi_done(cmd); + +diff --git a/drivers/scsi/smartpqi/smartpqi_init.c b/drivers/scsi/smartpqi/smartpqi_init.c +index 093ed5d1eef20..9bc451004184f 100644 +--- a/drivers/scsi/smartpqi/smartpqi_init.c ++++ b/drivers/scsi/smartpqi/smartpqi_init.c +@@ -5513,6 +5513,8 @@ static void pqi_fail_io_queued_for_device(struct pqi_ctrl_info *ctrl_info, + + list_del(&io_request->request_list_entry); + set_host_byte(scmd, DID_RESET); ++ pqi_free_io_request(io_request); ++ scsi_dma_unmap(scmd); + pqi_scsi_done(scmd); + } + +@@ -5549,6 +5551,8 @@ static void pqi_fail_io_queued_for_all_devices(struct pqi_ctrl_info *ctrl_info) + + list_del(&io_request->request_list_entry); + set_host_byte(scmd, DID_RESET); ++ pqi_free_io_request(io_request); ++ scsi_dma_unmap(scmd); + pqi_scsi_done(scmd); + } + +@@ -8142,6 +8146,10 @@ static const struct pci_device_id pqi_pci_id_table[] = { + PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, + 0x152d, 0x8a37) + }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ 0x193d, 0x8460) ++ }, + { + PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, + 0x193d, 0x1104) +@@ -8214,6 +8222,22 @@ static const struct pci_device_id pqi_pci_id_table[] = { + PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, + 0x1bd4, 0x004f) + }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ 0x1bd4, 0x0051) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ 0x1bd4, 0x0052) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ 0x1bd4, 0x0053) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ 0x1bd4, 0x0054) ++ }, + { + PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, + 0x19e5, 0xd227) +@@ -8370,6 +8394,122 @@ static const struct pci_device_id pqi_pci_id_table[] = { + PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, + PCI_VENDOR_ID_ADAPTEC2, 0x1380) + }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1400) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1402) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1410) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1411) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1412) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1420) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1430) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1440) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1441) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1450) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1452) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1460) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1461) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1462) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1470) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1471) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1472) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1480) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1490) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x1491) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x14a0) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x14a1) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x14b0) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x14b1) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x14c0) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x14c1) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x14d0) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x14e0) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_ADAPTEC2, 0x14f0) ++ }, + { + PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, + PCI_VENDOR_ID_ADVANTECH, 0x8312) +@@ -8434,6 +8574,10 @@ static const struct pci_device_id pqi_pci_id_table[] = { + PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, + PCI_VENDOR_ID_HP, 0x1001) + }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ PCI_VENDOR_ID_HP, 0x1002) ++ }, + { + PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, + PCI_VENDOR_ID_HP, 0x1100) +@@ -8442,6 +8586,22 @@ static const struct pci_device_id pqi_pci_id_table[] = { + PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, + PCI_VENDOR_ID_HP, 0x1101) + }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ 0x1590, 0x0294) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ 0x1590, 0x02db) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ 0x1590, 0x02dc) ++ }, ++ { ++ PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, ++ 0x1590, 0x032e) ++ }, + { + PCI_DEVICE_SUB(PCI_VENDOR_ID_ADAPTEC2, 0x028f, + 0x1d8d, 0x0800) +diff --git a/drivers/spi/spi-ath79.c b/drivers/spi/spi-ath79.c +index eb9a243e95265..98ace748cd986 100644 +--- a/drivers/spi/spi-ath79.c ++++ b/drivers/spi/spi-ath79.c +@@ -156,8 +156,7 @@ static int ath79_spi_probe(struct platform_device *pdev) + + master->use_gpio_descriptors = true; + master->bits_per_word_mask = SPI_BPW_RANGE_MASK(1, 32); +- master->setup = spi_bitbang_setup; +- master->cleanup = spi_bitbang_cleanup; ++ master->flags = SPI_MASTER_GPIO_SS; + if (pdata) { + master->bus_num = pdata->bus_num; + master->num_chipselect = pdata->num_chipselect; +diff --git a/drivers/spi/spi-dln2.c b/drivers/spi/spi-dln2.c +index 75b33d7d14b04..9a4d942fafcf5 100644 +--- a/drivers/spi/spi-dln2.c ++++ b/drivers/spi/spi-dln2.c +@@ -780,7 +780,7 @@ exit_free_master: + + static int dln2_spi_remove(struct platform_device *pdev) + { +- struct spi_master *master = spi_master_get(platform_get_drvdata(pdev)); ++ struct spi_master *master = platform_get_drvdata(pdev); + struct dln2_spi *dln2 = spi_master_get_devdata(master); + + pm_runtime_disable(&pdev->dev); +diff --git a/drivers/spi/spi-omap-100k.c b/drivers/spi/spi-omap-100k.c +index b955ca8796d2d..b8e201c094843 100644 +--- a/drivers/spi/spi-omap-100k.c ++++ b/drivers/spi/spi-omap-100k.c +@@ -426,7 +426,7 @@ err: + + static int omap1_spi100k_remove(struct platform_device *pdev) + { +- struct spi_master *master = spi_master_get(platform_get_drvdata(pdev)); ++ struct spi_master *master = platform_get_drvdata(pdev); + struct omap1_spi100k *spi100k = spi_master_get_devdata(master); + + pm_runtime_disable(&pdev->dev); +@@ -440,7 +440,7 @@ static int omap1_spi100k_remove(struct platform_device *pdev) + #ifdef CONFIG_PM + static int omap1_spi100k_runtime_suspend(struct device *dev) + { +- struct spi_master *master = spi_master_get(dev_get_drvdata(dev)); ++ struct spi_master *master = dev_get_drvdata(dev); + struct omap1_spi100k *spi100k = spi_master_get_devdata(master); + + clk_disable_unprepare(spi100k->ick); +@@ -451,7 +451,7 @@ static int omap1_spi100k_runtime_suspend(struct device *dev) + + static int omap1_spi100k_runtime_resume(struct device *dev) + { +- struct spi_master *master = spi_master_get(dev_get_drvdata(dev)); ++ struct spi_master *master = dev_get_drvdata(dev); + struct omap1_spi100k *spi100k = spi_master_get_devdata(master); + int ret; + +diff --git a/drivers/spi/spi-qup.c b/drivers/spi/spi-qup.c +index fa8079fbea77a..d1dfb52008b4a 100644 +--- a/drivers/spi/spi-qup.c ++++ b/drivers/spi/spi-qup.c +@@ -1263,7 +1263,7 @@ static int spi_qup_remove(struct platform_device *pdev) + struct spi_qup *controller = spi_master_get_devdata(master); + int ret; + +- ret = pm_runtime_get_sync(&pdev->dev); ++ ret = pm_runtime_resume_and_get(&pdev->dev); + if (ret < 0) + return ret; + +diff --git a/drivers/spi/spi-ti-qspi.c b/drivers/spi/spi-ti-qspi.c +index cad2abcbd9c78..6b6ef89442837 100644 +--- a/drivers/spi/spi-ti-qspi.c ++++ b/drivers/spi/spi-ti-qspi.c +@@ -656,6 +656,17 @@ static int ti_qspi_runtime_resume(struct device *dev) + return 0; + } + ++static void ti_qspi_dma_cleanup(struct ti_qspi *qspi) ++{ ++ if (qspi->rx_bb_addr) ++ dma_free_coherent(qspi->dev, QSPI_DMA_BUFFER_SIZE, ++ qspi->rx_bb_addr, ++ qspi->rx_bb_dma_addr); ++ ++ if (qspi->rx_chan) ++ dma_release_channel(qspi->rx_chan); ++} ++ + static const struct of_device_id ti_qspi_match[] = { + {.compatible = "ti,dra7xxx-qspi" }, + {.compatible = "ti,am4372-qspi" }, +@@ -809,6 +820,8 @@ no_dma: + if (!ret) + return 0; + ++ ti_qspi_dma_cleanup(qspi); ++ + pm_runtime_disable(&pdev->dev); + free_master: + spi_master_put(master); +@@ -827,12 +840,7 @@ static int ti_qspi_remove(struct platform_device *pdev) + pm_runtime_put_sync(&pdev->dev); + pm_runtime_disable(&pdev->dev); + +- if (qspi->rx_bb_addr) +- dma_free_coherent(qspi->dev, QSPI_DMA_BUFFER_SIZE, +- qspi->rx_bb_addr, +- qspi->rx_bb_dma_addr); +- if (qspi->rx_chan) +- dma_release_channel(qspi->rx_chan); ++ ti_qspi_dma_cleanup(qspi); + + return 0; + } +diff --git a/drivers/staging/media/imx/imx-media-capture.c b/drivers/staging/media/imx/imx-media-capture.c +index d151cd6d31884..fabbfceaa1077 100644 +--- a/drivers/staging/media/imx/imx-media-capture.c ++++ b/drivers/staging/media/imx/imx-media-capture.c +@@ -553,7 +553,7 @@ static int capture_validate_fmt(struct capture_priv *priv) + priv->vdev.fmt.fmt.pix.height != f.fmt.pix.height || + priv->vdev.cc->cs != cc->cs || + priv->vdev.compose.width != compose.width || +- priv->vdev.compose.height != compose.height) ? -EINVAL : 0; ++ priv->vdev.compose.height != compose.height) ? -EPIPE : 0; + } + + static int capture_start_streaming(struct vb2_queue *vq, unsigned int count) +diff --git a/drivers/staging/media/ipu3/ipu3-v4l2.c b/drivers/staging/media/ipu3/ipu3-v4l2.c +index c764cb55dc8d9..908ae74aa970d 100644 +--- a/drivers/staging/media/ipu3/ipu3-v4l2.c ++++ b/drivers/staging/media/ipu3/ipu3-v4l2.c +@@ -685,6 +685,7 @@ static int imgu_fmt(struct imgu_device *imgu, unsigned int pipe, int node, + + dev_dbg(dev, "IPU3 pipe %u pipe_id = %u", pipe, css_pipe->pipe_id); + ++ css_q = imgu_node_to_queue(node); + for (i = 0; i < IPU3_CSS_QUEUES; i++) { + unsigned int inode = imgu_map_node(imgu, i); + +@@ -692,6 +693,18 @@ static int imgu_fmt(struct imgu_device *imgu, unsigned int pipe, int node, + if (inode == IMGU_NODE_STAT_3A || inode == IMGU_NODE_PARAMS) + continue; + ++ /* CSS expects some format on OUT queue */ ++ if (i != IPU3_CSS_QUEUE_OUT && ++ !imgu_pipe->nodes[inode].enabled) { ++ fmts[i] = NULL; ++ continue; ++ } ++ ++ if (i == css_q) { ++ fmts[i] = &f->fmt.pix_mp; ++ continue; ++ } ++ + if (try) { + fmts[i] = kmemdup(&imgu_pipe->nodes[inode].vdev_fmt.fmt.pix_mp, + sizeof(struct v4l2_pix_format_mplane), +@@ -704,10 +717,6 @@ static int imgu_fmt(struct imgu_device *imgu, unsigned int pipe, int node, + fmts[i] = &imgu_pipe->nodes[inode].vdev_fmt.fmt.pix_mp; + } + +- /* CSS expects some format on OUT queue */ +- if (i != IPU3_CSS_QUEUE_OUT && +- !imgu_pipe->nodes[inode].enabled) +- fmts[i] = NULL; + } + + if (!try) { +@@ -724,16 +733,10 @@ static int imgu_fmt(struct imgu_device *imgu, unsigned int pipe, int node, + rects[IPU3_CSS_RECT_GDC]->height = pad_fmt.height; + } + +- /* +- * imgu doesn't set the node to the value given by user +- * before we return success from this function, so set it here. +- */ +- css_q = imgu_node_to_queue(node); + if (!fmts[css_q]) { + ret = -EINVAL; + goto out; + } +- *fmts[css_q] = f->fmt.pix_mp; + + if (try) + ret = imgu_css_fmt_try(&imgu->css, fmts, rects, pipe); +@@ -744,15 +747,18 @@ static int imgu_fmt(struct imgu_device *imgu, unsigned int pipe, int node, + if (ret < 0) + goto out; + +- if (try) +- f->fmt.pix_mp = *fmts[css_q]; +- else +- f->fmt = imgu_pipe->nodes[node].vdev_fmt.fmt; ++ /* ++ * imgu doesn't set the node to the value given by user ++ * before we return success from this function, so set it here. ++ */ ++ if (!try) ++ imgu_pipe->nodes[node].vdev_fmt.fmt.pix_mp = f->fmt.pix_mp; + + out: + if (try) { + for (i = 0; i < IPU3_CSS_QUEUES; i++) +- kfree(fmts[i]); ++ if (i != css_q) ++ kfree(fmts[i]); + } + + return ret; +diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c +index 5a047ce77bc0b..55fe93296deb4 100644 +--- a/drivers/target/target_core_pscsi.c ++++ b/drivers/target/target_core_pscsi.c +@@ -620,8 +620,9 @@ static void pscsi_complete_cmd(struct se_cmd *cmd, u8 scsi_status, + unsigned char *buf; + + buf = transport_kmap_data_sg(cmd); +- if (!buf) ++ if (!buf) { + ; /* XXX: TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE */ ++ } + + if (cdb[0] == MODE_SENSE_10) { + if (!(buf[3] & 0x80)) +diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c +index b830e0a87fbac..ba6cfba589a69 100644 +--- a/drivers/tee/optee/core.c ++++ b/drivers/tee/optee/core.c +@@ -78,16 +78,6 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params, + return rc; + p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa; + p->u.memref.shm = shm; +- +- /* Check that the memref is covered by the shm object */ +- if (p->u.memref.size) { +- size_t o = p->u.memref.shm_offs + +- p->u.memref.size - 1; +- +- rc = tee_shm_get_pa(shm, o, NULL); +- if (rc) +- return rc; +- } + break; + case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT: + case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT: +diff --git a/drivers/tty/n_gsm.c b/drivers/tty/n_gsm.c +index 75408b9f232da..38eb49ba361f0 100644 +--- a/drivers/tty/n_gsm.c ++++ b/drivers/tty/n_gsm.c +@@ -2377,8 +2377,18 @@ static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm) + /* Don't register device 0 - this is the control channel and not + a usable tty interface */ + base = mux_num_to_base(gsm); /* Base for this MUX */ +- for (i = 1; i < NUM_DLCI; i++) +- tty_register_device(gsm_tty_driver, base + i, NULL); ++ for (i = 1; i < NUM_DLCI; i++) { ++ struct device *dev; ++ ++ dev = tty_register_device(gsm_tty_driver, ++ base + i, NULL); ++ if (IS_ERR(dev)) { ++ for (i--; i >= 1; i--) ++ tty_unregister_device(gsm_tty_driver, ++ base + i); ++ return PTR_ERR(dev); ++ } ++ } + } + return ret; + } +diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c +index c55b6d7ccaf78..564e1fa2e4c94 100644 +--- a/drivers/tty/vt/vt.c ++++ b/drivers/tty/vt/vt.c +@@ -1377,6 +1377,7 @@ struct vc_data *vc_deallocate(unsigned int currcons) + atomic_notifier_call_chain(&vt_notifier_list, VT_DEALLOCATE, ¶m); + vcs_remove_sysfs(currcons); + visual_deinit(vc); ++ con_free_unimap(vc); + put_pid(vc->vt_pid); + vc_uniscr_set(vc, NULL); + kfree(vc->vc_screenbuf); +diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c +index 4d3de33885ffa..cd61860cada5e 100644 +--- a/drivers/usb/core/hub.c ++++ b/drivers/usb/core/hub.c +@@ -3537,7 +3537,7 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg) + u16 portchange, portstatus; + + if (!test_and_set_bit(port1, hub->child_usage_bits)) { +- status = pm_runtime_get_sync(&port_dev->dev); ++ status = pm_runtime_resume_and_get(&port_dev->dev); + if (status < 0) { + dev_dbg(&udev->dev, "can't resume usb port, status %d\n", + status); +diff --git a/drivers/usb/dwc2/core_intr.c b/drivers/usb/dwc2/core_intr.c +index 6272b4ae4740f..f73e78143ad14 100644 +--- a/drivers/usb/dwc2/core_intr.c ++++ b/drivers/usb/dwc2/core_intr.c +@@ -312,6 +312,7 @@ static void dwc2_handle_conn_id_status_change_intr(struct dwc2_hsotg *hsotg) + static void dwc2_handle_session_req_intr(struct dwc2_hsotg *hsotg) + { + int ret; ++ u32 hprt0; + + /* Clear interrupt */ + dwc2_writel(hsotg, GINTSTS_SESSREQINT, GINTSTS); +@@ -332,6 +333,13 @@ static void dwc2_handle_session_req_intr(struct dwc2_hsotg *hsotg) + * established + */ + dwc2_hsotg_disconnect(hsotg); ++ } else { ++ /* Turn on the port power bit. */ ++ hprt0 = dwc2_read_hprt0(hsotg); ++ hprt0 |= HPRT0_PWR; ++ dwc2_writel(hsotg, hprt0, HPRT0); ++ /* Connect hcd after port power is set. */ ++ dwc2_hcd_connect(hsotg); + } + } + +diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c +index 904b0043011cf..af8efebfaf110 100644 +--- a/drivers/usb/dwc3/gadget.c ++++ b/drivers/usb/dwc3/gadget.c +@@ -304,13 +304,12 @@ int dwc3_send_gadget_ep_cmd(struct dwc3_ep *dep, unsigned cmd, + } + + if (DWC3_DEPCMD_CMD(cmd) == DWC3_DEPCMD_STARTTRANSFER) { +- int needs_wakeup; ++ int link_state; + +- needs_wakeup = (dwc->link_state == DWC3_LINK_STATE_U1 || +- dwc->link_state == DWC3_LINK_STATE_U2 || +- dwc->link_state == DWC3_LINK_STATE_U3); +- +- if (unlikely(needs_wakeup)) { ++ link_state = dwc3_gadget_get_link_state(dwc); ++ if (link_state == DWC3_LINK_STATE_U1 || ++ link_state == DWC3_LINK_STATE_U2 || ++ link_state == DWC3_LINK_STATE_U3) { + ret = __dwc3_gadget_wakeup(dwc); + dev_WARN_ONCE(dwc->dev, ret, "wakeup failed --> %d\n", + ret); +@@ -1862,6 +1861,8 @@ static int __dwc3_gadget_wakeup(struct dwc3 *dwc) + case DWC3_LINK_STATE_RESET: + case DWC3_LINK_STATE_RX_DET: /* in HS, means Early Suspend */ + case DWC3_LINK_STATE_U3: /* in HS, means SUSPEND */ ++ case DWC3_LINK_STATE_U2: /* in HS, means Sleep (L1) */ ++ case DWC3_LINK_STATE_U1: + case DWC3_LINK_STATE_RESUME: + break; + default: +@@ -2986,6 +2987,15 @@ static void dwc3_gadget_reset_interrupt(struct dwc3 *dwc) + + dwc->connected = true; + ++ /* ++ * Ideally, dwc3_reset_gadget() would trigger the function ++ * drivers to stop any active transfers through ep disable. ++ * However, for functions which defer ep disable, such as mass ++ * storage, we will need to rely on the call to stop active ++ * transfers here, and avoid allowing of request queuing. ++ */ ++ dwc->connected = false; ++ + /* + * WORKAROUND: DWC3 revisions <1.88a have an issue which + * would cause a missing Disconnect Event if there's a +diff --git a/drivers/usb/gadget/config.c b/drivers/usb/gadget/config.c +index 2d115353424c2..8bb25773b61e9 100644 +--- a/drivers/usb/gadget/config.c ++++ b/drivers/usb/gadget/config.c +@@ -194,9 +194,13 @@ EXPORT_SYMBOL_GPL(usb_assign_descriptors); + void usb_free_all_descriptors(struct usb_function *f) + { + usb_free_descriptors(f->fs_descriptors); ++ f->fs_descriptors = NULL; + usb_free_descriptors(f->hs_descriptors); ++ f->hs_descriptors = NULL; + usb_free_descriptors(f->ss_descriptors); ++ f->ss_descriptors = NULL; + usb_free_descriptors(f->ssp_descriptors); ++ f->ssp_descriptors = NULL; + } + EXPORT_SYMBOL_GPL(usb_free_all_descriptors); + +diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c +index df003bc67da07..aa56a080235c7 100644 +--- a/drivers/usb/gadget/function/f_fs.c ++++ b/drivers/usb/gadget/function/f_fs.c +@@ -2658,6 +2658,7 @@ static int __ffs_data_got_strings(struct ffs_data *ffs, + + do { /* lang_count > 0 so we can use do-while */ + unsigned needed = needed_count; ++ u32 str_per_lang = str_count; + + if (unlikely(len < 3)) + goto error_free; +@@ -2693,7 +2694,7 @@ static int __ffs_data_got_strings(struct ffs_data *ffs, + + data += length + 1; + len -= length + 1; +- } while (--str_count); ++ } while (--str_per_lang); + + s->id = 0; /* terminator */ + s->s = NULL; +diff --git a/drivers/usb/gadget/function/f_uac1.c b/drivers/usb/gadget/function/f_uac1.c +index 560382e0a8f38..e65f474ad7b3b 100644 +--- a/drivers/usb/gadget/function/f_uac1.c ++++ b/drivers/usb/gadget/function/f_uac1.c +@@ -19,6 +19,9 @@ + #include "u_audio.h" + #include "u_uac1.h" + ++/* UAC1 spec: 3.7.2.3 Audio Channel Cluster Format */ ++#define UAC1_CHANNEL_MASK 0x0FFF ++ + struct f_uac1 { + struct g_audio g_audio; + u8 ac_intf, as_in_intf, as_out_intf; +@@ -30,6 +33,11 @@ static inline struct f_uac1 *func_to_uac1(struct usb_function *f) + return container_of(f, struct f_uac1, g_audio.func); + } + ++static inline struct f_uac1_opts *g_audio_to_uac1_opts(struct g_audio *audio) ++{ ++ return container_of(audio->func.fi, struct f_uac1_opts, func_inst); ++} ++ + /* + * DESCRIPTORS ... most are static, but strings and full + * configuration descriptors are built on demand. +@@ -505,11 +513,42 @@ static void f_audio_disable(struct usb_function *f) + + /*-------------------------------------------------------------------------*/ + ++static int f_audio_validate_opts(struct g_audio *audio, struct device *dev) ++{ ++ struct f_uac1_opts *opts = g_audio_to_uac1_opts(audio); ++ ++ if (!opts->p_chmask && !opts->c_chmask) { ++ dev_err(dev, "Error: no playback and capture channels\n"); ++ return -EINVAL; ++ } else if (opts->p_chmask & ~UAC1_CHANNEL_MASK) { ++ dev_err(dev, "Error: unsupported playback channels mask\n"); ++ return -EINVAL; ++ } else if (opts->c_chmask & ~UAC1_CHANNEL_MASK) { ++ dev_err(dev, "Error: unsupported capture channels mask\n"); ++ return -EINVAL; ++ } else if ((opts->p_ssize < 1) || (opts->p_ssize > 4)) { ++ dev_err(dev, "Error: incorrect playback sample size\n"); ++ return -EINVAL; ++ } else if ((opts->c_ssize < 1) || (opts->c_ssize > 4)) { ++ dev_err(dev, "Error: incorrect capture sample size\n"); ++ return -EINVAL; ++ } else if (!opts->p_srate) { ++ dev_err(dev, "Error: incorrect playback sampling rate\n"); ++ return -EINVAL; ++ } else if (!opts->c_srate) { ++ dev_err(dev, "Error: incorrect capture sampling rate\n"); ++ return -EINVAL; ++ } ++ ++ return 0; ++} ++ + /* audio function driver setup/binding */ + static int f_audio_bind(struct usb_configuration *c, struct usb_function *f) + { + struct usb_composite_dev *cdev = c->cdev; + struct usb_gadget *gadget = cdev->gadget; ++ struct device *dev = &gadget->dev; + struct f_uac1 *uac1 = func_to_uac1(f); + struct g_audio *audio = func_to_g_audio(f); + struct f_uac1_opts *audio_opts; +@@ -519,6 +558,10 @@ static int f_audio_bind(struct usb_configuration *c, struct usb_function *f) + int rate; + int status; + ++ status = f_audio_validate_opts(audio, dev); ++ if (status) ++ return status; ++ + audio_opts = container_of(f->fi, struct f_uac1_opts, func_inst); + + us = usb_gstrings_attach(cdev, uac1_strings, ARRAY_SIZE(strings_uac1)); +diff --git a/drivers/usb/gadget/function/f_uac2.c b/drivers/usb/gadget/function/f_uac2.c +index 6f03e944e0e31..dd960cea642f3 100644 +--- a/drivers/usb/gadget/function/f_uac2.c ++++ b/drivers/usb/gadget/function/f_uac2.c +@@ -14,6 +14,9 @@ + #include "u_audio.h" + #include "u_uac2.h" + ++/* UAC2 spec: 4.1 Audio Channel Cluster Descriptor */ ++#define UAC2_CHANNEL_MASK 0x07FFFFFF ++ + /* + * The driver implements a simple UAC_2 topology. + * USB-OUT -> IT_1 -> OT_3 -> ALSA_Capture +@@ -604,6 +607,36 @@ static void setup_descriptor(struct f_uac2_opts *opts) + hs_audio_desc[i] = NULL; + } + ++static int afunc_validate_opts(struct g_audio *agdev, struct device *dev) ++{ ++ struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev); ++ ++ if (!opts->p_chmask && !opts->c_chmask) { ++ dev_err(dev, "Error: no playback and capture channels\n"); ++ return -EINVAL; ++ } else if (opts->p_chmask & ~UAC2_CHANNEL_MASK) { ++ dev_err(dev, "Error: unsupported playback channels mask\n"); ++ return -EINVAL; ++ } else if (opts->c_chmask & ~UAC2_CHANNEL_MASK) { ++ dev_err(dev, "Error: unsupported capture channels mask\n"); ++ return -EINVAL; ++ } else if ((opts->p_ssize < 1) || (opts->p_ssize > 4)) { ++ dev_err(dev, "Error: incorrect playback sample size\n"); ++ return -EINVAL; ++ } else if ((opts->c_ssize < 1) || (opts->c_ssize > 4)) { ++ dev_err(dev, "Error: incorrect capture sample size\n"); ++ return -EINVAL; ++ } else if (!opts->p_srate) { ++ dev_err(dev, "Error: incorrect playback sampling rate\n"); ++ return -EINVAL; ++ } else if (!opts->c_srate) { ++ dev_err(dev, "Error: incorrect capture sampling rate\n"); ++ return -EINVAL; ++ } ++ ++ return 0; ++} ++ + static int + afunc_bind(struct usb_configuration *cfg, struct usb_function *fn) + { +@@ -612,11 +645,13 @@ afunc_bind(struct usb_configuration *cfg, struct usb_function *fn) + struct usb_composite_dev *cdev = cfg->cdev; + struct usb_gadget *gadget = cdev->gadget; + struct device *dev = &gadget->dev; +- struct f_uac2_opts *uac2_opts; ++ struct f_uac2_opts *uac2_opts = g_audio_to_uac2_opts(agdev); + struct usb_string *us; + int ret; + +- uac2_opts = container_of(fn->fi, struct f_uac2_opts, func_inst); ++ ret = afunc_validate_opts(agdev, dev); ++ if (ret) ++ return ret; + + us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn)); + if (IS_ERR(us)) +diff --git a/drivers/usb/gadget/function/f_uvc.c b/drivers/usb/gadget/function/f_uvc.c +index fb0a892687c0c..c03b67aab1a85 100644 +--- a/drivers/usb/gadget/function/f_uvc.c ++++ b/drivers/usb/gadget/function/f_uvc.c +@@ -633,7 +633,12 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f) + + uvc_hs_streaming_ep.wMaxPacketSize = + cpu_to_le16(max_packet_size | ((max_packet_mult - 1) << 11)); +- uvc_hs_streaming_ep.bInterval = opts->streaming_interval; ++ ++ /* A high-bandwidth endpoint must specify a bInterval value of 1 */ ++ if (max_packet_mult > 1) ++ uvc_hs_streaming_ep.bInterval = 1; ++ else ++ uvc_hs_streaming_ep.bInterval = opts->streaming_interval; + + uvc_ss_streaming_ep.wMaxPacketSize = cpu_to_le16(max_packet_size); + uvc_ss_streaming_ep.bInterval = opts->streaming_interval; +@@ -817,6 +822,7 @@ static struct usb_function_instance *uvc_alloc_inst(void) + pd->bmControls[0] = 1; + pd->bmControls[1] = 0; + pd->iProcessing = 0; ++ pd->bmVideoStandards = 0; + + od = &opts->uvc_output_terminal; + od->bLength = UVC_DT_OUTPUT_TERMINAL_SIZE; +diff --git a/drivers/usb/gadget/legacy/webcam.c b/drivers/usb/gadget/legacy/webcam.c +index a9f8eb8e1c767..2c9eab2b863d2 100644 +--- a/drivers/usb/gadget/legacy/webcam.c ++++ b/drivers/usb/gadget/legacy/webcam.c +@@ -125,6 +125,7 @@ static const struct uvc_processing_unit_descriptor uvc_processing = { + .bmControls[0] = 1, + .bmControls[1] = 0, + .iProcessing = 0, ++ .bmVideoStandards = 0, + }; + + static const struct uvc_output_terminal_descriptor uvc_output_terminal = { +diff --git a/drivers/usb/gadget/udc/dummy_hcd.c b/drivers/usb/gadget/udc/dummy_hcd.c +index a49c27b2ba16d..58261ec1300a8 100644 +--- a/drivers/usb/gadget/udc/dummy_hcd.c ++++ b/drivers/usb/gadget/udc/dummy_hcd.c +@@ -900,6 +900,21 @@ static int dummy_pullup(struct usb_gadget *_gadget, int value) + spin_lock_irqsave(&dum->lock, flags); + dum->pullup = (value != 0); + set_link_state(dum_hcd); ++ if (value == 0) { ++ /* ++ * Emulate synchronize_irq(): wait for callbacks to finish. ++ * This seems to be the best place to emulate the call to ++ * synchronize_irq() that's in usb_gadget_remove_driver(). ++ * Doing it in dummy_udc_stop() would be too late since it ++ * is called after the unbind callback and unbind shouldn't ++ * be invoked until all the other callbacks are finished. ++ */ ++ while (dum->callback_usage > 0) { ++ spin_unlock_irqrestore(&dum->lock, flags); ++ usleep_range(1000, 2000); ++ spin_lock_irqsave(&dum->lock, flags); ++ } ++ } + spin_unlock_irqrestore(&dum->lock, flags); + + usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd)); +@@ -1001,14 +1016,6 @@ static int dummy_udc_stop(struct usb_gadget *g) + spin_lock_irq(&dum->lock); + dum->ints_enabled = 0; + stop_activity(dum); +- +- /* emulate synchronize_irq(): wait for callbacks to finish */ +- while (dum->callback_usage > 0) { +- spin_unlock_irq(&dum->lock); +- usleep_range(1000, 2000); +- spin_lock_irq(&dum->lock); +- } +- + dum->driver = NULL; + spin_unlock_irq(&dum->lock); + +diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c +index 9764122c9cdf2..7f9f302a73cdf 100644 +--- a/drivers/usb/host/xhci-mem.c ++++ b/drivers/usb/host/xhci-mem.c +@@ -2134,6 +2134,15 @@ static void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports, + + if (major_revision == 0x03) { + rhub = &xhci->usb3_rhub; ++ /* ++ * Some hosts incorrectly use sub-minor version for minor ++ * version (i.e. 0x02 instead of 0x20 for bcdUSB 0x320 and 0x01 ++ * for bcdUSB 0x310). Since there is no USB release with sub ++ * minor version 0x301 to 0x309, we can assume that they are ++ * incorrect and fix it here. ++ */ ++ if (minor_revision > 0x00 && minor_revision < 0x10) ++ minor_revision <<= 4; + } else if (major_revision <= 0x02) { + rhub = &xhci->usb2_rhub; + } else { +diff --git a/drivers/usb/host/xhci-mtk.c b/drivers/usb/host/xhci-mtk.c +index 5fc3ea6d46c56..5c0eb35cd007a 100644 +--- a/drivers/usb/host/xhci-mtk.c ++++ b/drivers/usb/host/xhci-mtk.c +@@ -397,6 +397,8 @@ static void xhci_mtk_quirks(struct device *dev, struct xhci_hcd *xhci) + xhci->quirks |= XHCI_SPURIOUS_SUCCESS; + if (mtk->lpm_support) + xhci->quirks |= XHCI_LPM_SUPPORT; ++ if (mtk->u2_lpm_disable) ++ xhci->quirks |= XHCI_HW_LPM_DISABLE; + + /* + * MTK xHCI 0.96: PSA is 1 by default even if doesn't support stream, +@@ -469,6 +471,7 @@ static int xhci_mtk_probe(struct platform_device *pdev) + return ret; + + mtk->lpm_support = of_property_read_bool(node, "usb3-lpm-capable"); ++ mtk->u2_lpm_disable = of_property_read_bool(node, "usb2-lpm-disable"); + /* optional property, ignore the error if it does not exist */ + of_property_read_u32(node, "mediatek,u3p-dis-msk", + &mtk->u3p_dis_msk); +diff --git a/drivers/usb/host/xhci-mtk.h b/drivers/usb/host/xhci-mtk.h +index 734c5513aa1bf..d9f438d078daf 100644 +--- a/drivers/usb/host/xhci-mtk.h ++++ b/drivers/usb/host/xhci-mtk.h +@@ -150,6 +150,7 @@ struct xhci_hcd_mtk { + struct phy **phys; + int num_phys; + bool lpm_support; ++ bool u2_lpm_disable; + /* usb remote wakeup */ + bool uwk_en; + struct regmap *uwk; +diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c +index b5080bc1689e4..de05ac9d3ae15 100644 +--- a/drivers/usb/host/xhci.c ++++ b/drivers/usb/host/xhci.c +@@ -228,6 +228,7 @@ static void xhci_zero_64b_regs(struct xhci_hcd *xhci) + struct device *dev = xhci_to_hcd(xhci)->self.sysdev; + int err, i; + u64 val; ++ u32 intrs; + + /* + * Some Renesas controllers get into a weird state if they are +@@ -266,7 +267,10 @@ static void xhci_zero_64b_regs(struct xhci_hcd *xhci) + if (upper_32_bits(val)) + xhci_write_64(xhci, 0, &xhci->op_regs->cmd_ring); + +- for (i = 0; i < HCS_MAX_INTRS(xhci->hcs_params1); i++) { ++ intrs = min_t(u32, HCS_MAX_INTRS(xhci->hcs_params1), ++ ARRAY_SIZE(xhci->run_regs->ir_set)); ++ ++ for (i = 0; i < intrs; i++) { + struct xhci_intr_reg __iomem *ir; + + ir = &xhci->run_regs->ir_set[i]; +@@ -3227,6 +3231,14 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd, + + /* config ep command clears toggle if add and drop ep flags are set */ + ctrl_ctx = xhci_get_input_control_ctx(cfg_cmd->in_ctx); ++ if (!ctrl_ctx) { ++ spin_unlock_irqrestore(&xhci->lock, flags); ++ xhci_free_command(xhci, cfg_cmd); ++ xhci_warn(xhci, "%s: Could not get input context, bad type.\n", ++ __func__); ++ goto cleanup; ++ } ++ + xhci_setup_input_ctx_for_config_ep(xhci, cfg_cmd->in_ctx, vdev->out_ctx, + ctrl_ctx, ep_flag, ep_flag); + xhci_endpoint_copy(xhci, cfg_cmd->in_ctx, vdev->out_ctx, ep_index); +diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c +index 166f68f639c28..70ef603f7bb9b 100644 +--- a/drivers/usb/musb/musb_core.c ++++ b/drivers/usb/musb/musb_core.c +@@ -1932,7 +1932,7 @@ static void musb_irq_work(struct work_struct *data) + struct musb *musb = container_of(data, struct musb, irq_work.work); + int error; + +- error = pm_runtime_get_sync(musb->controller); ++ error = pm_runtime_resume_and_get(musb->controller); + if (error < 0) { + dev_err(musb->controller, "Could not enable: %i\n", error); + +diff --git a/drivers/video/fbdev/core/fbcmap.c b/drivers/video/fbdev/core/fbcmap.c +index e5ae33c1a8e84..e8a17fb715ace 100644 +--- a/drivers/video/fbdev/core/fbcmap.c ++++ b/drivers/video/fbdev/core/fbcmap.c +@@ -101,17 +101,17 @@ int fb_alloc_cmap_gfp(struct fb_cmap *cmap, int len, int transp, gfp_t flags) + if (!len) + return 0; + +- cmap->red = kmalloc(size, flags); ++ cmap->red = kzalloc(size, flags); + if (!cmap->red) + goto fail; +- cmap->green = kmalloc(size, flags); ++ cmap->green = kzalloc(size, flags); + if (!cmap->green) + goto fail; +- cmap->blue = kmalloc(size, flags); ++ cmap->blue = kzalloc(size, flags); + if (!cmap->blue) + goto fail; + if (transp) { +- cmap->transp = kmalloc(size, flags); ++ cmap->transp = kzalloc(size, flags); + if (!cmap->transp) + goto fail; + } else { +diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c +index 35741901f4e0b..ab69e3563b125 100644 +--- a/fs/btrfs/ctree.c ++++ b/fs/btrfs/ctree.c +@@ -1406,10 +1406,30 @@ get_old_root(struct btrfs_root *root, u64 time_seq) + "failed to read tree block %llu from get_old_root", + logical); + } else { ++ struct tree_mod_elem *tm2; ++ + btrfs_tree_read_lock(old); + eb = btrfs_clone_extent_buffer(old); ++ /* ++ * After the lookup for the most recent tree mod operation ++ * above and before we locked and cloned the extent buffer ++ * 'old', a new tree mod log operation may have been added. ++ * So lookup for a more recent one to make sure the number ++ * of mod log operations we replay is consistent with the ++ * number of items we have in the cloned extent buffer, ++ * otherwise we can hit a BUG_ON when rewinding the extent ++ * buffer. ++ */ ++ tm2 = tree_mod_log_search(fs_info, logical, time_seq); + btrfs_tree_read_unlock(old); + free_extent_buffer(old); ++ ASSERT(tm2); ++ ASSERT(tm2 == tm || tm2->seq > tm->seq); ++ if (!tm2 || tm2->seq < tm->seq) { ++ free_extent_buffer(eb); ++ return NULL; ++ } ++ tm = tm2; + } + } else if (old_root) { + eb_root_owner = btrfs_header_owner(eb_root); +diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c +index 4bbd4b09fb96f..e9d3eb7f0e2b8 100644 +--- a/fs/btrfs/ioctl.c ++++ b/fs/btrfs/ioctl.c +@@ -667,8 +667,6 @@ static noinline int create_subvol(struct inode *dir, + btrfs_set_root_otransid(root_item, trans->transid); + + btrfs_tree_unlock(leaf); +- free_extent_buffer(leaf); +- leaf = NULL; + + btrfs_set_root_dirid(root_item, new_dirid); + +@@ -677,8 +675,22 @@ static noinline int create_subvol(struct inode *dir, + key.type = BTRFS_ROOT_ITEM_KEY; + ret = btrfs_insert_root(trans, fs_info->tree_root, &key, + root_item); +- if (ret) ++ if (ret) { ++ /* ++ * Since we don't abort the transaction in this case, free the ++ * tree block so that we don't leak space and leave the ++ * filesystem in an inconsistent state (an extent item in the ++ * extent tree without backreferences). Also no need to have ++ * the tree block locked since it is not in any tree at this ++ * point, so no other task can find it and use it. ++ */ ++ btrfs_free_tree_block(trans, root, leaf, 0, 1); ++ free_extent_buffer(leaf); + goto fail; ++ } ++ ++ free_extent_buffer(leaf); ++ leaf = NULL; + + key.offset = (u64)-1; + new_root = btrfs_read_fs_root_no_name(fs_info, &key); +diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c +index 68b5d7c4aa491..ba68b0b41dff3 100644 +--- a/fs/btrfs/relocation.c ++++ b/fs/btrfs/relocation.c +@@ -1836,8 +1836,8 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc, + int ret; + int slot; + +- BUG_ON(src->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID); +- BUG_ON(dest->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID); ++ ASSERT(src->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID); ++ ASSERT(dest->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID); + + last_snapshot = btrfs_root_last_snapshot(&src->root_item); + again: +@@ -1871,7 +1871,7 @@ again: + struct btrfs_key first_key; + + level = btrfs_header_level(parent); +- BUG_ON(level < lowest_level); ++ ASSERT(level >= lowest_level); + + ret = btrfs_bin_search(parent, &key, level, &slot); + if (ret < 0) +diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c +index 30025cc5d4ae7..997a106f28d37 100644 +--- a/fs/cifs/smb2ops.c ++++ b/fs/cifs/smb2ops.c +@@ -3693,7 +3693,7 @@ smb2_get_enc_key(struct TCP_Server_Info *server, __u64 ses_id, int enc, u8 *key) + } + spin_unlock(&cifs_tcp_ses_lock); + +- return 1; ++ return -EAGAIN; + } + /* + * Encrypt or decrypt @rqst message. @rqst[0] has the following format: +diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c +index b8a7ce379ffe6..75fbdfb8aaef8 100644 +--- a/fs/ecryptfs/main.c ++++ b/fs/ecryptfs/main.c +@@ -492,6 +492,12 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags + goto out; + } + ++ if (!dev_name) { ++ rc = -EINVAL; ++ err = "Device name cannot be null"; ++ goto out; ++ } ++ + rc = ecryptfs_parse_options(sbi, raw_data, &check_ruid); + if (rc) { + err = "Error parsing options"; +diff --git a/fs/erofs/erofs_fs.h b/fs/erofs/erofs_fs.h +index b1ee5654750d8..52ab961544673 100644 +--- a/fs/erofs/erofs_fs.h ++++ b/fs/erofs/erofs_fs.h +@@ -74,6 +74,9 @@ static inline bool erofs_inode_is_data_compressed(unsigned int datamode) + #define EROFS_I_VERSION_BIT 0 + #define EROFS_I_DATALAYOUT_BIT 1 + ++#define EROFS_I_ALL \ ++ ((1 << (EROFS_I_DATALAYOUT_BIT + EROFS_I_DATALAYOUT_BITS)) - 1) ++ + /* 32-byte reduced form of an ondisk inode */ + struct erofs_inode_compact { + __le16 i_format; /* inode format hints */ +diff --git a/fs/erofs/inode.c b/fs/erofs/inode.c +index 70fd3af7b8cb5..0dbeaf68e1d6e 100644 +--- a/fs/erofs/inode.c ++++ b/fs/erofs/inode.c +@@ -44,6 +44,13 @@ static struct page *erofs_read_inode(struct inode *inode, + dic = page_address(page) + *ofs; + ifmt = le16_to_cpu(dic->i_format); + ++ if (ifmt & ~EROFS_I_ALL) { ++ erofs_err(inode->i_sb, "unsupported i_format %u of nid %llu", ++ ifmt, vi->nid); ++ err = -EOPNOTSUPP; ++ goto err_out; ++ } ++ + vi->datalayout = erofs_inode_datalayout(ifmt); + if (vi->datalayout >= EROFS_INODE_DATALAYOUT_MAX) { + erofs_err(inode->i_sb, "unsupported datalayout %u of nid %llu", +diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c +index 64b6549dd9016..dd2c23d1483cc 100644 +--- a/fs/ext4/ialloc.c ++++ b/fs/ext4/ialloc.c +@@ -1353,6 +1353,7 @@ int ext4_init_inode_table(struct super_block *sb, ext4_group_t group, + handle_t *handle; + ext4_fsblk_t blk; + int num, ret = 0, used_blks = 0; ++ unsigned long used_inos = 0; + + /* This should not happen, but just to be sure check this */ + if (sb_rdonly(sb)) { +@@ -1383,22 +1384,37 @@ int ext4_init_inode_table(struct super_block *sb, ext4_group_t group, + * used inodes so we need to skip blocks with used inodes in + * inode table. + */ +- if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT))) +- used_blks = DIV_ROUND_UP((EXT4_INODES_PER_GROUP(sb) - +- ext4_itable_unused_count(sb, gdp)), +- sbi->s_inodes_per_block); +- +- if ((used_blks < 0) || (used_blks > sbi->s_itb_per_group) || +- ((group == 0) && ((EXT4_INODES_PER_GROUP(sb) - +- ext4_itable_unused_count(sb, gdp)) < +- EXT4_FIRST_INO(sb)))) { +- ext4_error(sb, "Something is wrong with group %u: " +- "used itable blocks: %d; " +- "itable unused count: %u", +- group, used_blks, +- ext4_itable_unused_count(sb, gdp)); +- ret = 1; +- goto err_out; ++ if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT))) { ++ used_inos = EXT4_INODES_PER_GROUP(sb) - ++ ext4_itable_unused_count(sb, gdp); ++ used_blks = DIV_ROUND_UP(used_inos, sbi->s_inodes_per_block); ++ ++ /* Bogus inode unused count? */ ++ if (used_blks < 0 || used_blks > sbi->s_itb_per_group) { ++ ext4_error(sb, "Something is wrong with group %u: " ++ "used itable blocks: %d; " ++ "itable unused count: %u", ++ group, used_blks, ++ ext4_itable_unused_count(sb, gdp)); ++ ret = 1; ++ goto err_out; ++ } ++ ++ used_inos += group * EXT4_INODES_PER_GROUP(sb); ++ /* ++ * Are there some uninitialized inodes in the inode table ++ * before the first normal inode? ++ */ ++ if ((used_blks != sbi->s_itb_per_group) && ++ (used_inos < EXT4_FIRST_INO(sb))) { ++ ext4_error(sb, "Something is wrong with group %u: " ++ "itable unused count: %u; " ++ "itables initialized count: %ld", ++ group, ext4_itable_unused_count(sb, gdp), ++ used_inos); ++ ret = 1; ++ goto err_out; ++ } + } + + blk = ext4_inode_table(sb, gdp) + used_blks; +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index 2ecf4594a20dd..0b364f5e6fdf9 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -2675,9 +2675,6 @@ static void ext4_orphan_cleanup(struct super_block *sb, + sb->s_flags &= ~SB_RDONLY; + } + #ifdef CONFIG_QUOTA +- /* Needed for iput() to work correctly and not trash data */ +- sb->s_flags |= SB_ACTIVE; +- + /* + * Turn on quotas which were not enabled for read-only mounts if + * filesystem has quota feature, so that they are updated correctly. +@@ -5060,8 +5057,10 @@ static int ext4_commit_super(struct super_block *sb, int sync) + struct buffer_head *sbh = EXT4_SB(sb)->s_sbh; + int error = 0; + +- if (!sbh || block_device_ejected(sb)) +- return error; ++ if (!sbh) ++ return -EINVAL; ++ if (block_device_ejected(sb)) ++ return -ENODEV; + + /* + * If the file system is mounted read-only, don't update the +diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c +index 7ce33698ae381..48bb5d3c709db 100644 +--- a/fs/f2fs/node.c ++++ b/fs/f2fs/node.c +@@ -2718,6 +2718,9 @@ static void remove_nats_in_journal(struct f2fs_sb_info *sbi) + struct f2fs_nat_entry raw_ne; + nid_t nid = le32_to_cpu(nid_in_journal(journal, i)); + ++ if (f2fs_check_nid_range(sbi, nid)) ++ continue; ++ + raw_ne = nat_in_journal(journal, i); + + ne = __lookup_nat_cache(nm_i, nid); +diff --git a/fs/fuse/file.c b/fs/fuse/file.c +index 1e1aef1bc20b3..0883e5b24c901 100644 +--- a/fs/fuse/file.c ++++ b/fs/fuse/file.c +@@ -1108,6 +1108,7 @@ static ssize_t fuse_send_write_pages(struct fuse_io_args *ia, + struct fuse_file *ff = file->private_data; + struct fuse_conn *fc = ff->fc; + unsigned int offset, i; ++ bool short_write; + int err; + + for (i = 0; i < ap->num_pages; i++) +@@ -1120,32 +1121,38 @@ static ssize_t fuse_send_write_pages(struct fuse_io_args *ia, + if (!err && ia->write.out.size > count) + err = -EIO; + ++ short_write = ia->write.out.size < count; + offset = ap->descs[0].offset; + count = ia->write.out.size; + for (i = 0; i < ap->num_pages; i++) { + struct page *page = ap->pages[i]; + +- if (!err && !offset && count >= PAGE_SIZE) +- SetPageUptodate(page); +- +- if (count > PAGE_SIZE - offset) +- count -= PAGE_SIZE - offset; +- else +- count = 0; +- offset = 0; +- +- unlock_page(page); ++ if (err) { ++ ClearPageUptodate(page); ++ } else { ++ if (count >= PAGE_SIZE - offset) ++ count -= PAGE_SIZE - offset; ++ else { ++ if (short_write) ++ ClearPageUptodate(page); ++ count = 0; ++ } ++ offset = 0; ++ } ++ if (ia->write.page_locked && (i == ap->num_pages - 1)) ++ unlock_page(page); + put_page(page); + } + + return err; + } + +-static ssize_t fuse_fill_write_pages(struct fuse_args_pages *ap, ++static ssize_t fuse_fill_write_pages(struct fuse_io_args *ia, + struct address_space *mapping, + struct iov_iter *ii, loff_t pos, + unsigned int max_pages) + { ++ struct fuse_args_pages *ap = &ia->ap; + struct fuse_conn *fc = get_fuse_conn(mapping->host); + unsigned offset = pos & (PAGE_SIZE - 1); + size_t count = 0; +@@ -1198,6 +1205,16 @@ static ssize_t fuse_fill_write_pages(struct fuse_args_pages *ap, + if (offset == PAGE_SIZE) + offset = 0; + ++ /* If we copied full page, mark it uptodate */ ++ if (tmp == PAGE_SIZE) ++ SetPageUptodate(page); ++ ++ if (PageUptodate(page)) { ++ unlock_page(page); ++ } else { ++ ia->write.page_locked = true; ++ break; ++ } + if (!fc->big_writes) + break; + } while (iov_iter_count(ii) && count < fc->max_write && +@@ -1241,7 +1258,7 @@ static ssize_t fuse_perform_write(struct kiocb *iocb, + break; + } + +- count = fuse_fill_write_pages(ap, mapping, ii, pos, nr_pages); ++ count = fuse_fill_write_pages(&ia, mapping, ii, pos, nr_pages); + if (count <= 0) { + err = count; + } else { +diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h +index 43bacf0a6bd31..d878926485451 100644 +--- a/fs/fuse/fuse_i.h ++++ b/fs/fuse/fuse_i.h +@@ -845,6 +845,7 @@ struct fuse_io_args { + struct { + struct fuse_write_in in; + struct fuse_write_out out; ++ bool page_locked; + } write; + }; + struct fuse_args_pages ap; +diff --git a/fs/fuse/virtio_fs.c b/fs/fuse/virtio_fs.c +index 7505f81027623..fadf6fb90fe22 100644 +--- a/fs/fuse/virtio_fs.c ++++ b/fs/fuse/virtio_fs.c +@@ -667,6 +667,7 @@ static int virtio_fs_probe(struct virtio_device *vdev) + out_vqs: + vdev->config->reset(vdev); + virtio_fs_cleanup_vqs(vdev, fs); ++ kfree(fs->vqs); + + out: + vdev->priv = NULL; +diff --git a/fs/jffs2/compr_rtime.c b/fs/jffs2/compr_rtime.c +index 406d9cc84ba8d..79e771ab624f4 100644 +--- a/fs/jffs2/compr_rtime.c ++++ b/fs/jffs2/compr_rtime.c +@@ -37,6 +37,9 @@ static int jffs2_rtime_compress(unsigned char *data_in, + int outpos = 0; + int pos=0; + ++ if (*dstlen <= 3) ++ return -1; ++ + memset(positions,0,sizeof(positions)); + + while (pos < (*sourcelen) && outpos <= (*dstlen)-2) { +diff --git a/fs/jffs2/scan.c b/fs/jffs2/scan.c +index 5f7e284e0df36..0b1a7f68b7122 100644 +--- a/fs/jffs2/scan.c ++++ b/fs/jffs2/scan.c +@@ -1078,7 +1078,7 @@ static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblo + memcpy(&fd->name, rd->name, checkedlen); + fd->name[checkedlen] = 0; + +- crc = crc32(0, fd->name, rd->nsize); ++ crc = crc32(0, fd->name, checkedlen); + if (crc != je32_to_cpu(rd->name_crc)) { + pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", + __func__, ofs, je32_to_cpu(rd->name_crc), crc); +diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c +index e3a79e6958124..7e8c18218e68f 100644 +--- a/fs/nfs/pnfs.c ++++ b/fs/nfs/pnfs.c +@@ -1311,7 +1311,7 @@ _pnfs_return_layout(struct inode *ino) + } + valid_layout = pnfs_layout_is_valid(lo); + pnfs_clear_layoutcommit(ino, &tmp_list); +- pnfs_mark_matching_lsegs_invalid(lo, &tmp_list, NULL, 0); ++ pnfs_mark_matching_lsegs_return(lo, &tmp_list, NULL, 0); + + if (NFS_SERVER(ino)->pnfs_curr_ld->return_range) { + struct pnfs_layout_range range = { +@@ -2427,6 +2427,9 @@ pnfs_mark_matching_lsegs_return(struct pnfs_layout_hdr *lo, + + assert_spin_locked(&lo->plh_inode->i_lock); + ++ if (test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags)) ++ tmp_list = &lo->plh_return_segs; ++ + list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list) + if (pnfs_match_lseg_recall(lseg, return_range, seq)) { + dprintk("%s: marking lseg %p iomode %d " +@@ -2434,6 +2437,8 @@ pnfs_mark_matching_lsegs_return(struct pnfs_layout_hdr *lo, + lseg, lseg->pls_range.iomode, + lseg->pls_range.offset, + lseg->pls_range.length); ++ if (test_bit(NFS_LSEG_LAYOUTRETURN, &lseg->pls_flags)) ++ tmp_list = &lo->plh_return_segs; + if (mark_lseg_invalid(lseg, tmp_list)) + continue; + remaining++; +diff --git a/fs/ubifs/replay.c b/fs/ubifs/replay.c +index 01fcf79750472..723a4b66a9b90 100644 +--- a/fs/ubifs/replay.c ++++ b/fs/ubifs/replay.c +@@ -223,7 +223,8 @@ static bool inode_still_linked(struct ubifs_info *c, struct replay_entry *rino) + */ + list_for_each_entry_reverse(r, &c->replay_list, list) { + ubifs_assert(c, r->sqnum >= rino->sqnum); +- if (key_inum(c, &r->key) == key_inum(c, &rino->key)) ++ if (key_inum(c, &r->key) == key_inum(c, &rino->key) && ++ key_type(c, &r->key) == UBIFS_INO_KEY) + return r->deletion == 0; + + } +diff --git a/include/crypto/acompress.h b/include/crypto/acompress.h +index d873f999b3347..3a801a7d3a0e9 100644 +--- a/include/crypto/acompress.h ++++ b/include/crypto/acompress.h +@@ -147,6 +147,8 @@ static inline struct crypto_acomp *crypto_acomp_reqtfm(struct acomp_req *req) + * crypto_free_acomp() -- free ACOMPRESS tfm handle + * + * @tfm: ACOMPRESS tfm handle allocated with crypto_alloc_acomp() ++ * ++ * If @tfm is a NULL or error pointer, this function does nothing. + */ + static inline void crypto_free_acomp(struct crypto_acomp *tfm) + { +diff --git a/include/crypto/aead.h b/include/crypto/aead.h +index 3c245b1859e77..3b870b4e82751 100644 +--- a/include/crypto/aead.h ++++ b/include/crypto/aead.h +@@ -179,6 +179,8 @@ static inline struct crypto_tfm *crypto_aead_tfm(struct crypto_aead *tfm) + /** + * crypto_free_aead() - zeroize and free aead handle + * @tfm: cipher handle to be freed ++ * ++ * If @tfm is a NULL or error pointer, this function does nothing. + */ + static inline void crypto_free_aead(struct crypto_aead *tfm) + { +diff --git a/include/crypto/akcipher.h b/include/crypto/akcipher.h +index 6924b091adec1..8913b42fcb343 100644 +--- a/include/crypto/akcipher.h ++++ b/include/crypto/akcipher.h +@@ -174,6 +174,8 @@ static inline struct crypto_akcipher *crypto_akcipher_reqtfm( + * crypto_free_akcipher() - free AKCIPHER tfm handle + * + * @tfm: AKCIPHER tfm handle allocated with crypto_alloc_akcipher() ++ * ++ * If @tfm is a NULL or error pointer, this function does nothing. + */ + static inline void crypto_free_akcipher(struct crypto_akcipher *tfm) + { +diff --git a/include/crypto/hash.h b/include/crypto/hash.h +index 84e9f2380edf2..e993c6beec073 100644 +--- a/include/crypto/hash.h ++++ b/include/crypto/hash.h +@@ -260,6 +260,8 @@ static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm) + /** + * crypto_free_ahash() - zeroize and free the ahash handle + * @tfm: cipher handle to be freed ++ * ++ * If @tfm is a NULL or error pointer, this function does nothing. + */ + static inline void crypto_free_ahash(struct crypto_ahash *tfm) + { +@@ -703,6 +705,8 @@ static inline struct crypto_tfm *crypto_shash_tfm(struct crypto_shash *tfm) + /** + * crypto_free_shash() - zeroize and free the message digest handle + * @tfm: cipher handle to be freed ++ * ++ * If @tfm is a NULL or error pointer, this function does nothing. + */ + static inline void crypto_free_shash(struct crypto_shash *tfm) + { +diff --git a/include/crypto/kpp.h b/include/crypto/kpp.h +index cd9a9b500624b..19a2eadbef613 100644 +--- a/include/crypto/kpp.h ++++ b/include/crypto/kpp.h +@@ -154,6 +154,8 @@ static inline void crypto_kpp_set_flags(struct crypto_kpp *tfm, u32 flags) + * crypto_free_kpp() - free KPP tfm handle + * + * @tfm: KPP tfm handle allocated with crypto_alloc_kpp() ++ * ++ * If @tfm is a NULL or error pointer, this function does nothing. + */ + static inline void crypto_free_kpp(struct crypto_kpp *tfm) + { +diff --git a/include/crypto/rng.h b/include/crypto/rng.h +index 8b4b844b4eef8..17bb3673d3c17 100644 +--- a/include/crypto/rng.h ++++ b/include/crypto/rng.h +@@ -111,6 +111,8 @@ static inline struct rng_alg *crypto_rng_alg(struct crypto_rng *tfm) + /** + * crypto_free_rng() - zeroize and free RNG handle + * @tfm: cipher handle to be freed ++ * ++ * If @tfm is a NULL or error pointer, this function does nothing. + */ + static inline void crypto_free_rng(struct crypto_rng *tfm) + { +diff --git a/include/crypto/skcipher.h b/include/crypto/skcipher.h +index aada879169184..0bce6005d325d 100644 +--- a/include/crypto/skcipher.h ++++ b/include/crypto/skcipher.h +@@ -203,6 +203,8 @@ static inline struct crypto_tfm *crypto_skcipher_tfm( + /** + * crypto_free_skcipher() - zeroize and free cipher handle + * @tfm: cipher handle to be freed ++ * ++ * If @tfm is a NULL or error pointer, this function does nothing. + */ + static inline void crypto_free_skcipher(struct crypto_skcipher *tfm) + { +diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h +index 4c5eb3aa8e723..a0e1cf1bef4e5 100644 +--- a/include/linux/mmc/host.h ++++ b/include/linux/mmc/host.h +@@ -281,9 +281,6 @@ struct mmc_host { + u32 ocr_avail_sdio; /* SDIO-specific OCR */ + u32 ocr_avail_sd; /* SD-specific OCR */ + u32 ocr_avail_mmc; /* MMC-specific OCR */ +-#ifdef CONFIG_PM_SLEEP +- struct notifier_block pm_notify; +-#endif + u32 max_current_330; + u32 max_current_300; + u32 max_current_180; +diff --git a/include/linux/module.h b/include/linux/module.h +index 6d20895e77391..3e01e01f00ccb 100644 +--- a/include/linux/module.h ++++ b/include/linux/module.h +@@ -376,6 +376,7 @@ struct module { + unsigned int num_gpl_syms; + const struct kernel_symbol *gpl_syms; + const s32 *gpl_crcs; ++ bool using_gplonly_symbols; + + #ifdef CONFIG_UNUSED_SYMBOLS + /* unused exported symbols. */ +@@ -561,34 +562,14 @@ struct module *find_module(const char *name); + struct symsearch { + const struct kernel_symbol *start, *stop; + const s32 *crcs; +- enum { ++ enum mod_license { + NOT_GPL_ONLY, + GPL_ONLY, + WILL_BE_GPL_ONLY, +- } licence; ++ } license; + bool unused; + }; + +-/* +- * Search for an exported symbol by name. +- * +- * Must be called with module_mutex held or preemption disabled. +- */ +-const struct kernel_symbol *find_symbol(const char *name, +- struct module **owner, +- const s32 **crc, +- bool gplok, +- bool warn); +- +-/* +- * Walk the exported symbol table +- * +- * Must be called with module_mutex held or preemption disabled. +- */ +-bool each_symbol_section(bool (*fn)(const struct symsearch *arr, +- struct module *owner, +- void *data), void *data); +- + /* Returns 0 and fills in value, defined and namebuf, or -ERANGE if + symnum out of range. */ + int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type, +@@ -636,7 +617,6 @@ static inline void __module_get(struct module *module) + #define symbol_put_addr(p) do { } while (0) + + #endif /* CONFIG_MODULE_UNLOAD */ +-int ref_module(struct module *a, struct module *b); + + /* This is a #define so the string doesn't get put in every .o file */ + #define module_name(mod) \ +diff --git a/include/linux/power/bq27xxx_battery.h b/include/linux/power/bq27xxx_battery.h +index 507c5e214c424..7413779484d5a 100644 +--- a/include/linux/power/bq27xxx_battery.h ++++ b/include/linux/power/bq27xxx_battery.h +@@ -50,7 +50,6 @@ struct bq27xxx_reg_cache { + int capacity; + int energy; + int flags; +- int power_avg; + int health; + }; + +diff --git a/include/scsi/libfcoe.h b/include/scsi/libfcoe.h +index 2568cb0627ec0..fac8e89aed81d 100644 +--- a/include/scsi/libfcoe.h ++++ b/include/scsi/libfcoe.h +@@ -249,7 +249,7 @@ int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *, struct fc_lport *, + struct fc_frame *); + + /* libfcoe funcs */ +-u64 fcoe_wwn_from_mac(unsigned char mac[], unsigned int, unsigned int); ++u64 fcoe_wwn_from_mac(unsigned char mac[MAX_ADDR_LEN], unsigned int, unsigned int); + int fcoe_libfc_config(struct fc_lport *, struct fcoe_ctlr *, + const struct libfc_function_template *, int init_fcp); + u32 fcoe_fc_crc(struct fc_frame *fp); +diff --git a/include/uapi/linux/usb/video.h b/include/uapi/linux/usb/video.h +index d854cb19c42c3..bfdae12cdacf8 100644 +--- a/include/uapi/linux/usb/video.h ++++ b/include/uapi/linux/usb/video.h +@@ -302,9 +302,10 @@ struct uvc_processing_unit_descriptor { + __u8 bControlSize; + __u8 bmControls[2]; + __u8 iProcessing; ++ __u8 bmVideoStandards; + } __attribute__((__packed__)); + +-#define UVC_DT_PROCESSING_UNIT_SIZE(n) (9+(n)) ++#define UVC_DT_PROCESSING_UNIT_SIZE(n) (10+(n)) + + /* 3.7.2.6. Extension Unit Descriptor */ + struct uvc_extension_unit_descriptor { +diff --git a/kernel/.gitignore b/kernel/.gitignore +index 34d1e77ee9df8..0f0dba6c1eedc 100644 +--- a/kernel/.gitignore ++++ b/kernel/.gitignore +@@ -1,4 +1,5 @@ + # ++/config_data + # Generated files + # + kheaders.md5 +diff --git a/kernel/Makefile b/kernel/Makefile +index 6aef13053a5c4..d038b0de886e9 100644 +--- a/kernel/Makefile ++++ b/kernel/Makefile +@@ -122,10 +122,15 @@ KCOV_INSTRUMENT_stackleak.o := n + + $(obj)/configs.o: $(obj)/config_data.gz + +-targets += config_data.gz +-$(obj)/config_data.gz: $(KCONFIG_CONFIG) FORCE ++targets += config_data config_data.gz ++$(obj)/config_data.gz: $(obj)/config_data FORCE + $(call if_changed,gzip) + ++filechk_cat = cat $< ++ ++$(obj)/config_data: $(KCONFIG_CONFIG) FORCE ++ $(call filechk,cat) ++ + $(obj)/kheaders.o: $(obj)/kheaders_data.tar.xz + + quiet_cmd_genikh = CHK $(obj)/kheaders_data.tar.xz +diff --git a/kernel/futex.c b/kernel/futex.c +index 36a2a923f7ccf..375e7e98e301f 100644 +--- a/kernel/futex.c ++++ b/kernel/futex.c +@@ -3862,8 +3862,7 @@ long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout, + + if (op & FUTEX_CLOCK_REALTIME) { + flags |= FLAGS_CLOCKRT; +- if (cmd != FUTEX_WAIT && cmd != FUTEX_WAIT_BITSET && \ +- cmd != FUTEX_WAIT_REQUEUE_PI) ++ if (cmd != FUTEX_WAIT_BITSET && cmd != FUTEX_WAIT_REQUEUE_PI) + return -ENOSYS; + } + +diff --git a/kernel/irq/matrix.c b/kernel/irq/matrix.c +index 651a4ad6d711f..8e586858bcf41 100644 +--- a/kernel/irq/matrix.c ++++ b/kernel/irq/matrix.c +@@ -423,7 +423,9 @@ void irq_matrix_free(struct irq_matrix *m, unsigned int cpu, + if (WARN_ON_ONCE(bit < m->alloc_start || bit >= m->alloc_end)) + return; + +- clear_bit(bit, cm->alloc_map); ++ if (WARN_ON_ONCE(!test_and_clear_bit(bit, cm->alloc_map))) ++ return; ++ + cm->allocated--; + if(managed) + cm->managed_allocated--; +diff --git a/kernel/module.c b/kernel/module.c +index c60559b5bf101..88a6a9e04f8dc 100644 +--- a/kernel/module.c ++++ b/kernel/module.c +@@ -420,7 +420,7 @@ static bool each_symbol_in_section(const struct symsearch *arr, + } + + /* Returns true as soon as fn returns true, otherwise false. */ +-bool each_symbol_section(bool (*fn)(const struct symsearch *arr, ++static bool each_symbol_section(bool (*fn)(const struct symsearch *arr, + struct module *owner, + void *data), + void *data) +@@ -482,7 +482,6 @@ bool each_symbol_section(bool (*fn)(const struct symsearch *arr, + } + return false; + } +-EXPORT_SYMBOL_GPL(each_symbol_section); + + struct find_symbol_arg { + /* Input */ +@@ -494,6 +493,7 @@ struct find_symbol_arg { + struct module *owner; + const s32 *crc; + const struct kernel_symbol *sym; ++ enum mod_license license; + }; + + static bool check_exported_symbol(const struct symsearch *syms, +@@ -503,9 +503,9 @@ static bool check_exported_symbol(const struct symsearch *syms, + struct find_symbol_arg *fsa = data; + + if (!fsa->gplok) { +- if (syms->licence == GPL_ONLY) ++ if (syms->license == GPL_ONLY) + return false; +- if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) { ++ if (syms->license == WILL_BE_GPL_ONLY && fsa->warn) { + pr_warn("Symbol %s is being used by a non-GPL module, " + "which will not be allowed in the future\n", + fsa->name); +@@ -527,6 +527,7 @@ static bool check_exported_symbol(const struct symsearch *syms, + fsa->owner = owner; + fsa->crc = symversion(syms->crcs, symnum); + fsa->sym = &syms->start[symnum]; ++ fsa->license = syms->license; + return true; + } + +@@ -583,9 +584,10 @@ static bool find_exported_symbol_in_section(const struct symsearch *syms, + + /* Find an exported symbol and return it, along with, (optional) crc and + * (optional) module which owns it. Needs preempt disabled or module_mutex. */ +-const struct kernel_symbol *find_symbol(const char *name, ++static const struct kernel_symbol *find_symbol(const char *name, + struct module **owner, + const s32 **crc, ++ enum mod_license *license, + bool gplok, + bool warn) + { +@@ -600,13 +602,14 @@ const struct kernel_symbol *find_symbol(const char *name, + *owner = fsa.owner; + if (crc) + *crc = fsa.crc; ++ if (license) ++ *license = fsa.license; + return fsa.sym; + } + + pr_debug("Failed to find symbol %s\n", name); + return NULL; + } +-EXPORT_SYMBOL_GPL(find_symbol); + + /* + * Search for module by name: must hold module_mutex (or preempt disabled +@@ -867,7 +870,7 @@ static int add_module_usage(struct module *a, struct module *b) + } + + /* Module a uses b: caller needs module_mutex() */ +-int ref_module(struct module *a, struct module *b) ++static int ref_module(struct module *a, struct module *b) + { + int err; + +@@ -886,7 +889,6 @@ int ref_module(struct module *a, struct module *b) + } + return 0; + } +-EXPORT_SYMBOL_GPL(ref_module); + + /* Clear the unload stuff of the module. */ + static void module_unload_free(struct module *mod) +@@ -1075,7 +1077,7 @@ void __symbol_put(const char *symbol) + struct module *owner; + + preempt_disable(); +- if (!find_symbol(symbol, &owner, NULL, true, false)) ++ if (!find_symbol(symbol, &owner, NULL, NULL, true, false)) + BUG(); + module_put(owner); + preempt_enable(); +@@ -1167,11 +1169,10 @@ static inline void module_unload_free(struct module *mod) + { + } + +-int ref_module(struct module *a, struct module *b) ++static int ref_module(struct module *a, struct module *b) + { + return strong_try_module_get(b); + } +-EXPORT_SYMBOL_GPL(ref_module); + + static inline int module_unload_init(struct module *mod) + { +@@ -1354,7 +1355,7 @@ static inline int check_modstruct_version(const struct load_info *info, + * locking is necessary -- use preempt_disable() to placate lockdep. + */ + preempt_disable(); +- if (!find_symbol("module_layout", NULL, &crc, true, false)) { ++ if (!find_symbol("module_layout", NULL, &crc, NULL, true, false)) { + preempt_enable(); + BUG(); + } +@@ -1428,6 +1429,24 @@ static int verify_namespace_is_imported(const struct load_info *info, + return 0; + } + ++static bool inherit_taint(struct module *mod, struct module *owner) ++{ ++ if (!owner || !test_bit(TAINT_PROPRIETARY_MODULE, &owner->taints)) ++ return true; ++ ++ if (mod->using_gplonly_symbols) { ++ pr_err("%s: module using GPL-only symbols uses symbols from proprietary module %s.\n", ++ mod->name, owner->name); ++ return false; ++ } ++ ++ if (!test_bit(TAINT_PROPRIETARY_MODULE, &mod->taints)) { ++ pr_warn("%s: module uses symbols from proprietary module %s, inheriting taint.\n", ++ mod->name, owner->name); ++ set_bit(TAINT_PROPRIETARY_MODULE, &mod->taints); ++ } ++ return true; ++} + + /* Resolve a symbol for this module. I.e. if we find one, record usage. */ + static const struct kernel_symbol *resolve_symbol(struct module *mod, +@@ -1438,6 +1457,7 @@ static const struct kernel_symbol *resolve_symbol(struct module *mod, + struct module *owner; + const struct kernel_symbol *sym; + const s32 *crc; ++ enum mod_license license; + int err; + + /* +@@ -1447,11 +1467,19 @@ static const struct kernel_symbol *resolve_symbol(struct module *mod, + */ + sched_annotate_sleep(); + mutex_lock(&module_mutex); +- sym = find_symbol(name, &owner, &crc, ++ sym = find_symbol(name, &owner, &crc, &license, + !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true); + if (!sym) + goto unlock; + ++ if (license == GPL_ONLY) ++ mod->using_gplonly_symbols = true; ++ ++ if (!inherit_taint(mod, owner)) { ++ sym = NULL; ++ goto getname; ++ } ++ + if (!check_version(info, name, mod, crc)) { + sym = ERR_PTR(-EINVAL); + goto getname; +@@ -2262,7 +2290,7 @@ void *__symbol_get(const char *symbol) + const struct kernel_symbol *sym; + + preempt_disable(); +- sym = find_symbol(symbol, &owner, NULL, true, true); ++ sym = find_symbol(symbol, &owner, NULL, NULL, true, true); + if (sym && strong_try_module_get(owner)) + sym = NULL; + preempt_enable(); +@@ -2298,7 +2326,7 @@ static int verify_exported_symbols(struct module *mod) + for (i = 0; i < ARRAY_SIZE(arr); i++) { + for (s = arr[i].sym; s < arr[i].sym + arr[i].num; s++) { + if (find_symbol(kernel_symbol_name(s), &owner, NULL, +- true, false)) { ++ NULL, true, false)) { + pr_err("%s: exports duplicate symbol %s" + " (owned by %s)\n", + mod->name, kernel_symbol_name(s), +@@ -4620,7 +4648,6 @@ struct module *__module_address(unsigned long addr) + } + return mod; + } +-EXPORT_SYMBOL_GPL(__module_address); + + /* + * is_module_text_address - is this address inside module code? +@@ -4659,7 +4686,6 @@ struct module *__module_text_address(unsigned long addr) + } + return mod; + } +-EXPORT_SYMBOL_GPL(__module_text_address); + + /* Don't grab lock, we're oopsing. */ + void print_modules(void) +diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c +index 611adca1e6d0c..93ab546b6e16c 100644 +--- a/kernel/sched/fair.c ++++ b/kernel/sched/fair.c +@@ -7300,6 +7300,10 @@ int can_migrate_task(struct task_struct *p, struct lb_env *env) + if (throttled_lb_pair(task_group(p), env->src_cpu, env->dst_cpu)) + return 0; + ++ /* Disregard pcpu kthreads; they are where they need to be. */ ++ if ((p->flags & PF_KTHREAD) && kthread_is_per_cpu(p)) ++ return 0; ++ + if (!cpumask_test_cpu(env->dst_cpu, p->cpus_ptr)) { + int cpu; + +diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c +index 0ec5b7a1d769f..97d4a9dcf3399 100644 +--- a/kernel/time/posix-timers.c ++++ b/kernel/time/posix-timers.c +@@ -1169,8 +1169,8 @@ SYSCALL_DEFINE2(clock_adjtime32, clockid_t, which_clock, + + err = do_clock_adjtime(which_clock, &ktx); + +- if (err >= 0) +- err = put_old_timex32(utp, &ktx); ++ if (err >= 0 && put_old_timex32(utp, &ktx)) ++ return -EFAULT; + + return err; + } +diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c +index cbb76ffaf499f..74b5c36d7759a 100644 +--- a/kernel/trace/ftrace.c ++++ b/kernel/trace/ftrace.c +@@ -5053,7 +5053,10 @@ int ftrace_regex_release(struct inode *inode, struct file *file) + + parser = &iter->parser; + if (trace_parser_loaded(parser)) { +- ftrace_match_records(iter->hash, parser->buffer, parser->idx); ++ int enable = !(iter->flags & FTRACE_ITER_NOTRACE); ++ ++ ftrace_process_regex(iter, parser->buffer, ++ parser->idx, enable); + } + + trace_parser_put(parser); +diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c +index 1b5f54b309be5..5eaa46fe9ed63 100644 +--- a/kernel/trace/trace.c ++++ b/kernel/trace/trace.c +@@ -2140,14 +2140,13 @@ static void tracing_stop_tr(struct trace_array *tr) + + static int trace_save_cmdline(struct task_struct *tsk) + { +- unsigned pid, idx; ++ unsigned tpid, idx; + + /* treat recording of idle task as a success */ + if (!tsk->pid) + return 1; + +- if (unlikely(tsk->pid > PID_MAX_DEFAULT)) +- return 0; ++ tpid = tsk->pid & (PID_MAX_DEFAULT - 1); + + /* + * It's not the end of the world if we don't get +@@ -2158,26 +2157,15 @@ static int trace_save_cmdline(struct task_struct *tsk) + if (!arch_spin_trylock(&trace_cmdline_lock)) + return 0; + +- idx = savedcmd->map_pid_to_cmdline[tsk->pid]; ++ idx = savedcmd->map_pid_to_cmdline[tpid]; + if (idx == NO_CMDLINE_MAP) { + idx = (savedcmd->cmdline_idx + 1) % savedcmd->cmdline_num; + +- /* +- * Check whether the cmdline buffer at idx has a pid +- * mapped. We are going to overwrite that entry so we +- * need to clear the map_pid_to_cmdline. Otherwise we +- * would read the new comm for the old pid. +- */ +- pid = savedcmd->map_cmdline_to_pid[idx]; +- if (pid != NO_CMDLINE_MAP) +- savedcmd->map_pid_to_cmdline[pid] = NO_CMDLINE_MAP; +- +- savedcmd->map_cmdline_to_pid[idx] = tsk->pid; +- savedcmd->map_pid_to_cmdline[tsk->pid] = idx; +- ++ savedcmd->map_pid_to_cmdline[tpid] = idx; + savedcmd->cmdline_idx = idx; + } + ++ savedcmd->map_cmdline_to_pid[idx] = tsk->pid; + set_cmdline(idx, tsk->comm); + + arch_spin_unlock(&trace_cmdline_lock); +@@ -2188,6 +2176,7 @@ static int trace_save_cmdline(struct task_struct *tsk) + static void __trace_find_cmdline(int pid, char comm[]) + { + unsigned map; ++ int tpid; + + if (!pid) { + strcpy(comm, "<idle>"); +@@ -2199,16 +2188,16 @@ static void __trace_find_cmdline(int pid, char comm[]) + return; + } + +- if (pid > PID_MAX_DEFAULT) { +- strcpy(comm, "<...>"); +- return; ++ tpid = pid & (PID_MAX_DEFAULT - 1); ++ map = savedcmd->map_pid_to_cmdline[tpid]; ++ if (map != NO_CMDLINE_MAP) { ++ tpid = savedcmd->map_cmdline_to_pid[map]; ++ if (tpid == pid) { ++ strlcpy(comm, get_saved_cmdlines(map), TASK_COMM_LEN); ++ return; ++ } + } +- +- map = savedcmd->map_pid_to_cmdline[pid]; +- if (map != NO_CMDLINE_MAP) +- strlcpy(comm, get_saved_cmdlines(map), TASK_COMM_LEN); +- else +- strcpy(comm, "<...>"); ++ strcpy(comm, "<...>"); + } + + void trace_find_cmdline(int pid, char comm[]) +diff --git a/kernel/trace/trace_clock.c b/kernel/trace/trace_clock.c +index aaf6793ededaa..c1637f90c8a38 100644 +--- a/kernel/trace/trace_clock.c ++++ b/kernel/trace/trace_clock.c +@@ -95,33 +95,49 @@ u64 notrace trace_clock_global(void) + { + unsigned long flags; + int this_cpu; +- u64 now; ++ u64 now, prev_time; + + raw_local_irq_save(flags); + + this_cpu = raw_smp_processor_id(); +- now = sched_clock_cpu(this_cpu); ++ + /* +- * If in an NMI context then dont risk lockups and return the +- * cpu_clock() time: ++ * The global clock "guarantees" that the events are ordered ++ * between CPUs. But if two events on two different CPUS call ++ * trace_clock_global at roughly the same time, it really does ++ * not matter which one gets the earlier time. Just make sure ++ * that the same CPU will always show a monotonic clock. ++ * ++ * Use a read memory barrier to get the latest written ++ * time that was recorded. + */ +- if (unlikely(in_nmi())) +- goto out; ++ smp_rmb(); ++ prev_time = READ_ONCE(trace_clock_struct.prev_time); ++ now = sched_clock_cpu(this_cpu); + +- arch_spin_lock(&trace_clock_struct.lock); ++ /* Make sure that now is always greater than prev_time */ ++ if ((s64)(now - prev_time) < 0) ++ now = prev_time + 1; + + /* +- * TODO: if this happens often then maybe we should reset +- * my_scd->clock to prev_time+1, to make sure +- * we start ticking with the local clock from now on? ++ * If in an NMI context then dont risk lockups and simply return ++ * the current time. + */ +- if ((s64)(now - trace_clock_struct.prev_time) < 0) +- now = trace_clock_struct.prev_time + 1; ++ if (unlikely(in_nmi())) ++ goto out; + +- trace_clock_struct.prev_time = now; ++ /* Tracing can cause strange recursion, always use a try lock */ ++ if (arch_spin_trylock(&trace_clock_struct.lock)) { ++ /* Reread prev_time in case it was already updated */ ++ prev_time = READ_ONCE(trace_clock_struct.prev_time); ++ if ((s64)(now - prev_time) < 0) ++ now = prev_time + 1; + +- arch_spin_unlock(&trace_clock_struct.lock); ++ trace_clock_struct.prev_time = now; + ++ /* The unlock acts as the wmb for the above rmb */ ++ arch_spin_unlock(&trace_clock_struct.lock); ++ } + out: + raw_local_irq_restore(flags); + +diff --git a/net/bluetooth/ecdh_helper.h b/net/bluetooth/ecdh_helper.h +index a6f8d03d4aaf6..830723971cf83 100644 +--- a/net/bluetooth/ecdh_helper.h ++++ b/net/bluetooth/ecdh_helper.h +@@ -25,6 +25,6 @@ + + int compute_ecdh_secret(struct crypto_kpp *tfm, const u8 pair_public_key[64], + u8 secret[32]); +-int set_ecdh_privkey(struct crypto_kpp *tfm, const u8 *private_key); ++int set_ecdh_privkey(struct crypto_kpp *tfm, const u8 private_key[32]); + int generate_ecdh_public_key(struct crypto_kpp *tfm, u8 public_key[64]); + int generate_ecdh_keys(struct crypto_kpp *tfm, u8 public_key[64]); +diff --git a/net/openvswitch/actions.c b/net/openvswitch/actions.c +index 425e146523cc9..5c68f9ea98810 100644 +--- a/net/openvswitch/actions.c ++++ b/net/openvswitch/actions.c +@@ -831,17 +831,17 @@ static void ovs_fragment(struct net *net, struct vport *vport, + } + + if (key->eth.type == htons(ETH_P_IP)) { +- struct dst_entry ovs_dst; ++ struct rtable ovs_rt = { 0 }; + unsigned long orig_dst; + + prepare_frag(vport, skb, orig_network_offset, + ovs_key_mac_proto(key)); +- dst_init(&ovs_dst, &ovs_dst_ops, NULL, 1, ++ dst_init(&ovs_rt.dst, &ovs_dst_ops, NULL, 1, + DST_OBSOLETE_NONE, DST_NOCOUNT); +- ovs_dst.dev = vport->dev; ++ ovs_rt.dst.dev = vport->dev; + + orig_dst = skb->_skb_refdst; +- skb_dst_set_noref(skb, &ovs_dst); ++ skb_dst_set_noref(skb, &ovs_rt.dst); + IPCB(skb)->frag_max_size = mru; + + ip_do_fragment(net, skb->sk, skb, ovs_vport_output); +diff --git a/security/commoncap.c b/security/commoncap.c +index 28a6939bcc4e5..1c70d11491863 100644 +--- a/security/commoncap.c ++++ b/security/commoncap.c +@@ -391,7 +391,7 @@ int cap_inode_getsecurity(struct inode *inode, const char *name, void **buffer, + &tmpbuf, size, GFP_NOFS); + dput(dentry); + +- if (ret < 0) ++ if (ret < 0 || !tmpbuf) + return ret; + + fs_ns = inode->i_sb->s_user_ns; +diff --git a/sound/isa/sb/emu8000.c b/sound/isa/sb/emu8000.c +index 433e32e254f90..91c96fad06185 100644 +--- a/sound/isa/sb/emu8000.c ++++ b/sound/isa/sb/emu8000.c +@@ -1029,8 +1029,10 @@ snd_emu8000_create_mixer(struct snd_card *card, struct snd_emu8000 *emu) + + memset(emu->controls, 0, sizeof(emu->controls)); + for (i = 0; i < EMU8000_NUM_CONTROLS; i++) { +- if ((err = snd_ctl_add(card, emu->controls[i] = snd_ctl_new1(mixer_defs[i], emu))) < 0) ++ if ((err = snd_ctl_add(card, emu->controls[i] = snd_ctl_new1(mixer_defs[i], emu))) < 0) { ++ emu->controls[i] = NULL; + goto __error; ++ } + } + return 0; + +diff --git a/sound/isa/sb/sb16_csp.c b/sound/isa/sb/sb16_csp.c +index 4ad0ff0c4508c..69960cf1bb51d 100644 +--- a/sound/isa/sb/sb16_csp.c ++++ b/sound/isa/sb/sb16_csp.c +@@ -1045,10 +1045,14 @@ static int snd_sb_qsound_build(struct snd_sb_csp * p) + + spin_lock_init(&p->q_lock); + +- if ((err = snd_ctl_add(card, p->qsound_switch = snd_ctl_new1(&snd_sb_qsound_switch, p))) < 0) ++ if ((err = snd_ctl_add(card, p->qsound_switch = snd_ctl_new1(&snd_sb_qsound_switch, p))) < 0) { ++ p->qsound_switch = NULL; + goto __error; +- if ((err = snd_ctl_add(card, p->qsound_space = snd_ctl_new1(&snd_sb_qsound_space, p))) < 0) ++ } ++ if ((err = snd_ctl_add(card, p->qsound_space = snd_ctl_new1(&snd_sb_qsound_space, p))) < 0) { ++ p->qsound_space = NULL; + goto __error; ++ } + + return 0; + +diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c +index c3a1ce129b3d9..5e2fadb264e4d 100644 +--- a/sound/pci/hda/patch_conexant.c ++++ b/sound/pci/hda/patch_conexant.c +@@ -898,18 +898,18 @@ static const struct snd_pci_quirk cxt5066_fixups[] = { + SND_PCI_QUIRK(0x103c, 0x8079, "HP EliteBook 840 G3", CXT_FIXUP_HP_DOCK), + SND_PCI_QUIRK(0x103c, 0x807C, "HP EliteBook 820 G3", CXT_FIXUP_HP_DOCK), + SND_PCI_QUIRK(0x103c, 0x80FD, "HP ProBook 640 G2", CXT_FIXUP_HP_DOCK), +- SND_PCI_QUIRK(0x103c, 0x828c, "HP EliteBook 840 G4", CXT_FIXUP_HP_DOCK), +- SND_PCI_QUIRK(0x103c, 0x83b2, "HP EliteBook 840 G5", CXT_FIXUP_HP_DOCK), +- SND_PCI_QUIRK(0x103c, 0x83b3, "HP EliteBook 830 G5", CXT_FIXUP_HP_DOCK), +- SND_PCI_QUIRK(0x103c, 0x83d3, "HP ProBook 640 G4", CXT_FIXUP_HP_DOCK), +- SND_PCI_QUIRK(0x103c, 0x8174, "HP Spectre x360", CXT_FIXUP_HP_SPECTRE), + SND_PCI_QUIRK(0x103c, 0x8115, "HP Z1 Gen3", CXT_FIXUP_HP_GATE_MIC), + SND_PCI_QUIRK(0x103c, 0x814f, "HP ZBook 15u G3", CXT_FIXUP_MUTE_LED_GPIO), ++ SND_PCI_QUIRK(0x103c, 0x8174, "HP Spectre x360", CXT_FIXUP_HP_SPECTRE), + SND_PCI_QUIRK(0x103c, 0x822e, "HP ProBook 440 G4", CXT_FIXUP_MUTE_LED_GPIO), +- SND_PCI_QUIRK(0x103c, 0x836e, "HP ProBook 455 G5", CXT_FIXUP_MUTE_LED_GPIO), +- SND_PCI_QUIRK(0x103c, 0x837f, "HP ProBook 470 G5", CXT_FIXUP_MUTE_LED_GPIO), ++ SND_PCI_QUIRK(0x103c, 0x828c, "HP EliteBook 840 G4", CXT_FIXUP_HP_DOCK), + SND_PCI_QUIRK(0x103c, 0x8299, "HP 800 G3 SFF", CXT_FIXUP_HP_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x103c, 0x829a, "HP 800 G3 DM", CXT_FIXUP_HP_MIC_NO_PRESENCE), ++ SND_PCI_QUIRK(0x103c, 0x836e, "HP ProBook 455 G5", CXT_FIXUP_MUTE_LED_GPIO), ++ SND_PCI_QUIRK(0x103c, 0x837f, "HP ProBook 470 G5", CXT_FIXUP_MUTE_LED_GPIO), ++ SND_PCI_QUIRK(0x103c, 0x83b2, "HP EliteBook 840 G5", CXT_FIXUP_HP_DOCK), ++ SND_PCI_QUIRK(0x103c, 0x83b3, "HP EliteBook 830 G5", CXT_FIXUP_HP_DOCK), ++ SND_PCI_QUIRK(0x103c, 0x83d3, "HP ProBook 640 G4", CXT_FIXUP_HP_DOCK), + SND_PCI_QUIRK(0x103c, 0x8402, "HP ProBook 645 G4", CXT_FIXUP_MUTE_LED_GPIO), + SND_PCI_QUIRK(0x103c, 0x8455, "HP Z2 G4", CXT_FIXUP_HP_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x103c, 0x8456, "HP Z2 G4 SFF", CXT_FIXUP_HP_MIC_NO_PRESENCE), +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index e3fab993b3395..3b47ca4f7cac7 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -2542,8 +2542,10 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { + SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), ++ SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), ++ SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD), +@@ -6332,6 +6334,8 @@ enum { + ALC269_FIXUP_LEMOTE_A1802, + ALC269_FIXUP_LEMOTE_A190X, + ALC256_FIXUP_INTEL_NUC8_RUGGED, ++ ALC233_FIXUP_INTEL_NUC8_DMIC, ++ ALC233_FIXUP_INTEL_NUC8_BOOST, + ALC256_FIXUP_INTEL_NUC10, + ALC255_FIXUP_XIAOMI_HEADSET_MIC, + ALC274_FIXUP_HP_MIC, +@@ -7043,6 +7047,16 @@ static const struct hda_fixup alc269_fixups[] = { + .type = HDA_FIXUP_FUNC, + .v.func = alc233_fixup_lenovo_line2_mic_hotkey, + }, ++ [ALC233_FIXUP_INTEL_NUC8_DMIC] = { ++ .type = HDA_FIXUP_FUNC, ++ .v.func = alc_fixup_inv_dmic, ++ .chained = true, ++ .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST, ++ }, ++ [ALC233_FIXUP_INTEL_NUC8_BOOST] = { ++ .type = HDA_FIXUP_FUNC, ++ .v.func = alc269_fixup_limit_int_mic_boost ++ }, + [ALC255_FIXUP_DELL_SPK_NOISE] = { + .type = HDA_FIXUP_FUNC, + .v.func = alc_fixup_disable_aamix, +@@ -7958,6 +7972,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC), + SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE), + SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502), ++ SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401), + SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401), + SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS), + SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2), +@@ -8124,6 +8139,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE), + SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802), + SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X), ++ SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC), + SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED), + SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10), + +@@ -8583,12 +8599,7 @@ static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { + {0x12, 0x90a60130}, + {0x19, 0x03a11020}, + {0x21, 0x0321101f}), +- SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, +- {0x14, 0x90170110}, +- {0x19, 0x04a11040}, +- {0x21, 0x04211020}), + SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, +- {0x12, 0x90a60130}, + {0x14, 0x90170110}, + {0x19, 0x04a11040}, + {0x21, 0x04211020}), +@@ -8756,6 +8767,10 @@ static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = { + SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, + {0x19, 0x40000000}, + {0x1a, 0x40000000}), ++ SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, ++ {0x14, 0x90170110}, ++ {0x19, 0x04a11040}, ++ {0x21, 0x04211020}), + {} + }; + +diff --git a/sound/usb/clock.c b/sound/usb/clock.c +index 385a488c25cb0..6a51b9d20eebf 100644 +--- a/sound/usb/clock.c ++++ b/sound/usb/clock.c +@@ -296,7 +296,7 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip, + + selector = snd_usb_find_clock_selector(chip->ctrl_intf, entity_id); + if (selector) { +- int ret, i, cur; ++ int ret, i, cur, err; + + /* the entity ID we are looking for is a selector. + * find out what it currently selects */ +@@ -318,13 +318,17 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip, + ret = __uac_clock_find_source(chip, fmt, + selector->baCSourceID[ret - 1], + visited, validate); ++ if (ret > 0) { ++ err = uac_clock_selector_set_val(chip, entity_id, cur); ++ if (err < 0) ++ return err; ++ } ++ + if (!validate || ret > 0 || !chip->autoclock) + return ret; + + /* The current clock source is invalid, try others. */ + for (i = 1; i <= selector->bNrInPins; i++) { +- int err; +- + if (i == cur) + continue; + +@@ -390,7 +394,7 @@ static int __uac3_clock_find_source(struct snd_usb_audio *chip, + + selector = snd_usb_find_clock_selector_v3(chip->ctrl_intf, entity_id); + if (selector) { +- int ret, i, cur; ++ int ret, i, cur, err; + + /* the entity ID we are looking for is a selector. + * find out what it currently selects */ +@@ -412,6 +416,12 @@ static int __uac3_clock_find_source(struct snd_usb_audio *chip, + ret = __uac3_clock_find_source(chip, fmt, + selector->baCSourceID[ret - 1], + visited, validate); ++ if (ret > 0) { ++ err = uac_clock_selector_set_val(chip, entity_id, cur); ++ if (err < 0) ++ return err; ++ } ++ + if (!validate || ret > 0 || !chip->autoclock) + return ret; + +diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c +index 8aa96ed0b1b56..f4f8778e907a9 100644 +--- a/sound/usb/mixer.c ++++ b/sound/usb/mixer.c +@@ -1030,7 +1030,7 @@ struct usb_feature_control_info { + int type_uac2; /* data type for uac2 if different from uac1, else -1 */ + }; + +-static struct usb_feature_control_info audio_feature_info[] = { ++static const struct usb_feature_control_info audio_feature_info[] = { + { UAC_FU_MUTE, "Mute", USB_MIXER_INV_BOOLEAN, -1 }, + { UAC_FU_VOLUME, "Volume", USB_MIXER_S16, -1 }, + { UAC_FU_BASS, "Tone Control - Bass", USB_MIXER_S8, -1 }, +@@ -1544,7 +1544,7 @@ static void check_no_speaker_on_headset(struct snd_kcontrol *kctl, + strlcpy(kctl->id.name, "Headphone", sizeof(kctl->id.name)); + } + +-static struct usb_feature_control_info *get_feature_control_info(int control) ++static const struct usb_feature_control_info *get_feature_control_info(int control) + { + int i; + +@@ -1562,7 +1562,7 @@ static void __build_feature_ctl(struct usb_mixer_interface *mixer, + struct usb_audio_term *oterm, + int unitid, int nameid, int readonly_mask) + { +- struct usb_feature_control_info *ctl_info; ++ const struct usb_feature_control_info *ctl_info; + unsigned int len = 0; + int mapped_name = 0; + struct snd_kcontrol *kctl; +@@ -2237,7 +2237,7 @@ static const struct snd_kcontrol_new mixer_procunit_ctl = { + */ + struct procunit_value_info { + int control; +- char *suffix; ++ const char *suffix; + int val_type; + int min_value; + }; +@@ -2245,44 +2245,44 @@ struct procunit_value_info { + struct procunit_info { + int type; + char *name; +- struct procunit_value_info *values; ++ const struct procunit_value_info *values; + }; + +-static struct procunit_value_info undefined_proc_info[] = { ++static const struct procunit_value_info undefined_proc_info[] = { + { 0x00, "Control Undefined", 0 }, + { 0 } + }; + +-static struct procunit_value_info updown_proc_info[] = { ++static const struct procunit_value_info updown_proc_info[] = { + { UAC_UD_ENABLE, "Switch", USB_MIXER_BOOLEAN }, + { UAC_UD_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 }, + { 0 } + }; +-static struct procunit_value_info prologic_proc_info[] = { ++static const struct procunit_value_info prologic_proc_info[] = { + { UAC_DP_ENABLE, "Switch", USB_MIXER_BOOLEAN }, + { UAC_DP_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 }, + { 0 } + }; +-static struct procunit_value_info threed_enh_proc_info[] = { ++static const struct procunit_value_info threed_enh_proc_info[] = { + { UAC_3D_ENABLE, "Switch", USB_MIXER_BOOLEAN }, + { UAC_3D_SPACE, "Spaciousness", USB_MIXER_U8 }, + { 0 } + }; +-static struct procunit_value_info reverb_proc_info[] = { ++static const struct procunit_value_info reverb_proc_info[] = { + { UAC_REVERB_ENABLE, "Switch", USB_MIXER_BOOLEAN }, + { UAC_REVERB_LEVEL, "Level", USB_MIXER_U8 }, + { UAC_REVERB_TIME, "Time", USB_MIXER_U16 }, + { UAC_REVERB_FEEDBACK, "Feedback", USB_MIXER_U8 }, + { 0 } + }; +-static struct procunit_value_info chorus_proc_info[] = { ++static const struct procunit_value_info chorus_proc_info[] = { + { UAC_CHORUS_ENABLE, "Switch", USB_MIXER_BOOLEAN }, + { UAC_CHORUS_LEVEL, "Level", USB_MIXER_U8 }, + { UAC_CHORUS_RATE, "Rate", USB_MIXER_U16 }, + { UAC_CHORUS_DEPTH, "Depth", USB_MIXER_U16 }, + { 0 } + }; +-static struct procunit_value_info dcr_proc_info[] = { ++static const struct procunit_value_info dcr_proc_info[] = { + { UAC_DCR_ENABLE, "Switch", USB_MIXER_BOOLEAN }, + { UAC_DCR_RATE, "Ratio", USB_MIXER_U16 }, + { UAC_DCR_MAXAMPL, "Max Amp", USB_MIXER_S16 }, +@@ -2292,7 +2292,7 @@ static struct procunit_value_info dcr_proc_info[] = { + { 0 } + }; + +-static struct procunit_info procunits[] = { ++static const struct procunit_info procunits[] = { + { UAC_PROCESS_UP_DOWNMIX, "Up Down", updown_proc_info }, + { UAC_PROCESS_DOLBY_PROLOGIC, "Dolby Prologic", prologic_proc_info }, + { UAC_PROCESS_STEREO_EXTENDER, "3D Stereo Extender", threed_enh_proc_info }, +@@ -2302,16 +2302,16 @@ static struct procunit_info procunits[] = { + { 0 }, + }; + +-static struct procunit_value_info uac3_updown_proc_info[] = { ++static const struct procunit_value_info uac3_updown_proc_info[] = { + { UAC3_UD_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 }, + { 0 } + }; +-static struct procunit_value_info uac3_stereo_ext_proc_info[] = { ++static const struct procunit_value_info uac3_stereo_ext_proc_info[] = { + { UAC3_EXT_WIDTH_CONTROL, "Width Control", USB_MIXER_U8 }, + { 0 } + }; + +-static struct procunit_info uac3_procunits[] = { ++static const struct procunit_info uac3_procunits[] = { + { UAC3_PROCESS_UP_DOWNMIX, "Up Down", uac3_updown_proc_info }, + { UAC3_PROCESS_STEREO_EXTENDER, "3D Stereo Extender", uac3_stereo_ext_proc_info }, + { UAC3_PROCESS_MULTI_FUNCTION, "Multi-Function", undefined_proc_info }, +@@ -2321,23 +2321,23 @@ static struct procunit_info uac3_procunits[] = { + /* + * predefined data for extension units + */ +-static struct procunit_value_info clock_rate_xu_info[] = { ++static const struct procunit_value_info clock_rate_xu_info[] = { + { USB_XU_CLOCK_RATE_SELECTOR, "Selector", USB_MIXER_U8, 0 }, + { 0 } + }; +-static struct procunit_value_info clock_source_xu_info[] = { ++static const struct procunit_value_info clock_source_xu_info[] = { + { USB_XU_CLOCK_SOURCE_SELECTOR, "External", USB_MIXER_BOOLEAN }, + { 0 } + }; +-static struct procunit_value_info spdif_format_xu_info[] = { ++static const struct procunit_value_info spdif_format_xu_info[] = { + { USB_XU_DIGITAL_FORMAT_SELECTOR, "SPDIF/AC3", USB_MIXER_BOOLEAN }, + { 0 } + }; +-static struct procunit_value_info soft_limit_xu_info[] = { ++static const struct procunit_value_info soft_limit_xu_info[] = { + { USB_XU_SOFT_LIMIT_SELECTOR, " ", USB_MIXER_BOOLEAN }, + { 0 } + }; +-static struct procunit_info extunits[] = { ++static const struct procunit_info extunits[] = { + { USB_XU_CLOCK_RATE, "Clock rate", clock_rate_xu_info }, + { USB_XU_CLOCK_SOURCE, "DigitalIn CLK source", clock_source_xu_info }, + { USB_XU_DIGITAL_IO_STATUS, "DigitalOut format:", spdif_format_xu_info }, +@@ -2349,7 +2349,7 @@ static struct procunit_info extunits[] = { + * build a processing/extension unit + */ + static int build_audio_procunit(struct mixer_build *state, int unitid, +- void *raw_desc, struct procunit_info *list, ++ void *raw_desc, const struct procunit_info *list, + bool extension_unit) + { + struct uac_processing_unit_descriptor *desc = raw_desc; +@@ -2357,14 +2357,14 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, + struct usb_mixer_elem_info *cval; + struct snd_kcontrol *kctl; + int i, err, nameid, type, len; +- struct procunit_info *info; +- struct procunit_value_info *valinfo; ++ const struct procunit_info *info; ++ const struct procunit_value_info *valinfo; + const struct usbmix_name_map *map; +- static struct procunit_value_info default_value_info[] = { ++ static const struct procunit_value_info default_value_info[] = { + { 0x01, "Switch", USB_MIXER_BOOLEAN }, + { 0 } + }; +- static struct procunit_info default_info = { ++ static const struct procunit_info default_info = { + 0, NULL, default_value_info + }; + const char *name = extension_unit ? +@@ -2842,7 +2842,7 @@ struct uac3_badd_profile { + int st_chmask; /* side tone mixing channel mask */ + }; + +-static struct uac3_badd_profile uac3_badd_profiles[] = { ++static const struct uac3_badd_profile uac3_badd_profiles[] = { + { + /* + * BAIF, BAOF or combination of both +@@ -2903,7 +2903,7 @@ static struct uac3_badd_profile uac3_badd_profiles[] = { + }; + + static bool uac3_badd_func_has_valid_channels(struct usb_mixer_interface *mixer, +- struct uac3_badd_profile *f, ++ const struct uac3_badd_profile *f, + int c_chmask, int p_chmask) + { + /* +@@ -2947,7 +2947,7 @@ static int snd_usb_mixer_controls_badd(struct usb_mixer_interface *mixer, + struct usb_device *dev = mixer->chip->dev; + struct usb_interface_assoc_descriptor *assoc; + int badd_profile = mixer->chip->badd_profile; +- struct uac3_badd_profile *f; ++ const struct uac3_badd_profile *f; + const struct usbmix_ctl_map *map; + int p_chmask = 0, c_chmask = 0, st_chmask = 0; + int i; +@@ -3241,7 +3241,7 @@ static void snd_usb_mixer_dump_cval(struct snd_info_buffer *buffer, + struct usb_mixer_elem_list *list) + { + struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list); +- static char *val_types[] = {"BOOLEAN", "INV_BOOLEAN", ++ static const char * const val_types[] = {"BOOLEAN", "INV_BOOLEAN", + "S8", "U8", "S16", "U16"}; + snd_iprintf(buffer, " Info: id=%i, control=%i, cmask=0x%x, " + "channels=%i, type=\"%s\"\n", cval->head.id, +diff --git a/sound/usb/mixer_maps.c b/sound/usb/mixer_maps.c +index ac84f0b2b0bc7..dda13624a28cd 100644 +--- a/sound/usb/mixer_maps.c ++++ b/sound/usb/mixer_maps.c +@@ -14,7 +14,7 @@ struct usbmix_name_map { + int id; + const char *name; + int control; +- struct usbmix_dB_map *dB; ++ const struct usbmix_dB_map *dB; + }; + + struct usbmix_selector_map { +@@ -53,7 +53,7 @@ Mic-IN[9] --+->FU[10]----------------------------+ | + ++--+->SU[11]-->FU[12] --------------------------------------------------------------------------------------> USB_OUT[13] + */ + +-static struct usbmix_name_map extigy_map[] = { ++static const struct usbmix_name_map extigy_map[] = { + /* 1: IT pcm */ + { 2, "PCM Playback" }, /* FU */ + /* 3: IT pcm */ +@@ -94,12 +94,12 @@ static struct usbmix_name_map extigy_map[] = { + * e.g. no Master and fake PCM volume + * Pavel Mihaylov <bin@bash.info> + */ +-static struct usbmix_dB_map mp3plus_dB_1 = {.min = -4781, .max = 0}; ++static const struct usbmix_dB_map mp3plus_dB_1 = {.min = -4781, .max = 0}; + /* just guess */ +-static struct usbmix_dB_map mp3plus_dB_2 = {.min = -1781, .max = 618}; ++static const struct usbmix_dB_map mp3plus_dB_2 = {.min = -1781, .max = 618}; + /* just guess */ + +-static struct usbmix_name_map mp3plus_map[] = { ++static const struct usbmix_name_map mp3plus_map[] = { + /* 1: IT pcm */ + /* 2: IT mic */ + /* 3: IT line */ +@@ -140,7 +140,7 @@ Lin_IN[7]-+--->FU[8]---+ +->EU[23]->FU[28]------------->Spk_OUT[19] + | ^ + +->FU[13]--------------------------------------+ + */ +-static struct usbmix_name_map audigy2nx_map[] = { ++static const struct usbmix_name_map audigy2nx_map[] = { + /* 1: IT pcm playback */ + /* 4: IT digital in */ + { 6, "Digital In Playback" }, /* FU */ +@@ -168,12 +168,12 @@ static struct usbmix_name_map audigy2nx_map[] = { + { 0 } /* terminator */ + }; + +-static struct usbmix_name_map mbox1_map[] = { ++static const struct usbmix_name_map mbox1_map[] = { + { 1, "Clock" }, + { 0 } /* terminator */ + }; + +-static struct usbmix_selector_map c400_selectors[] = { ++static const struct usbmix_selector_map c400_selectors[] = { + { + .id = 0x80, + .count = 2, +@@ -182,7 +182,7 @@ static struct usbmix_selector_map c400_selectors[] = { + { 0 } /* terminator */ + }; + +-static struct usbmix_selector_map audigy2nx_selectors[] = { ++static const struct usbmix_selector_map audigy2nx_selectors[] = { + { + .id = 14, /* Capture Source */ + .count = 3, +@@ -202,21 +202,21 @@ static struct usbmix_selector_map audigy2nx_selectors[] = { + }; + + /* Creative SoundBlaster Live! 24-bit External */ +-static struct usbmix_name_map live24ext_map[] = { ++static const struct usbmix_name_map live24ext_map[] = { + /* 2: PCM Playback Volume */ + { 5, "Mic Capture" }, /* FU, default PCM Capture Volume */ + { 0 } /* terminator */ + }; + + /* LineX FM Transmitter entry - needed to bypass controls bug */ +-static struct usbmix_name_map linex_map[] = { ++static const struct usbmix_name_map linex_map[] = { + /* 1: IT pcm */ + /* 2: OT Speaker */ + { 3, "Master" }, /* FU: master volume - left / right / mute */ + { 0 } /* terminator */ + }; + +-static struct usbmix_name_map maya44_map[] = { ++static const struct usbmix_name_map maya44_map[] = { + /* 1: IT line */ + { 2, "Line Playback" }, /* FU */ + /* 3: IT line */ +@@ -239,7 +239,7 @@ static struct usbmix_name_map maya44_map[] = { + * so this map removes all unwanted sliders from alsamixer + */ + +-static struct usbmix_name_map justlink_map[] = { ++static const struct usbmix_name_map justlink_map[] = { + /* 1: IT pcm playback */ + /* 2: Not present */ + { 3, NULL}, /* IT mic (No mic input on device) */ +@@ -256,7 +256,7 @@ static struct usbmix_name_map justlink_map[] = { + }; + + /* TerraTec Aureon 5.1 MkII USB */ +-static struct usbmix_name_map aureon_51_2_map[] = { ++static const struct usbmix_name_map aureon_51_2_map[] = { + /* 1: IT USB */ + /* 2: IT Mic */ + /* 3: IT Line */ +@@ -275,7 +275,7 @@ static struct usbmix_name_map aureon_51_2_map[] = { + {} /* terminator */ + }; + +-static struct usbmix_name_map scratch_live_map[] = { ++static const struct usbmix_name_map scratch_live_map[] = { + /* 1: IT Line 1 (USB streaming) */ + /* 2: OT Line 1 (Speaker) */ + /* 3: IT Line 1 (Line connector) */ +@@ -291,7 +291,7 @@ static struct usbmix_name_map scratch_live_map[] = { + { 0 } /* terminator */ + }; + +-static struct usbmix_name_map ebox44_map[] = { ++static const struct usbmix_name_map ebox44_map[] = { + { 4, NULL }, /* FU */ + { 6, NULL }, /* MU */ + { 7, NULL }, /* FU */ +@@ -306,7 +306,7 @@ static struct usbmix_name_map ebox44_map[] = { + * FIXME: or mp3plus_map should use "Capture Source" too, + * so this maps can be merget + */ +-static struct usbmix_name_map hercules_usb51_map[] = { ++static const struct usbmix_name_map hercules_usb51_map[] = { + { 8, "Capture Source" }, /* SU, default "PCM Capture Source" */ + { 9, "Master Playback" }, /* FU, default "Speaker Playback" */ + { 10, "Mic Boost", 7 }, /* FU, default "Auto Gain Input" */ +@@ -317,7 +317,7 @@ static struct usbmix_name_map hercules_usb51_map[] = { + }; + + /* Plantronics Gamecom 780 has a broken volume control, better to disable it */ +-static struct usbmix_name_map gamecom780_map[] = { ++static const struct usbmix_name_map gamecom780_map[] = { + { 9, NULL }, /* FU, speaker out */ + {} + }; +@@ -331,12 +331,19 @@ static const struct usbmix_name_map scms_usb3318_map[] = { + }; + + /* Bose companion 5, the dB conversion factor is 16 instead of 256 */ +-static struct usbmix_dB_map bose_companion5_dB = {-5006, -6}; +-static struct usbmix_name_map bose_companion5_map[] = { ++static const struct usbmix_dB_map bose_companion5_dB = {-5006, -6}; ++static const struct usbmix_name_map bose_companion5_map[] = { + { 3, NULL, .dB = &bose_companion5_dB }, + { 0 } /* terminator */ + }; + ++/* Sennheiser Communications Headset [PC 8], the dB value is reported as -6 negative maximum */ ++static const struct usbmix_dB_map sennheiser_pc8_dB = {-9500, 0}; ++static const struct usbmix_name_map sennheiser_pc8_map[] = { ++ { 9, NULL, .dB = &sennheiser_pc8_dB }, ++ { 0 } /* terminator */ ++}; ++ + /* + * Dell usb dock with ALC4020 codec had a firmware problem where it got + * screwed up when zero volume is passed; just skip it as a workaround +@@ -406,7 +413,7 @@ static const struct usbmix_name_map aorus_master_alc1220vb_map[] = { + * Control map entries + */ + +-static struct usbmix_ctl_map usbmix_ctl_maps[] = { ++static const struct usbmix_ctl_map usbmix_ctl_maps[] = { + { + .id = USB_ID(0x041e, 0x3000), + .map = extigy_map, +@@ -560,37 +567,37 @@ static struct usbmix_ctl_map usbmix_ctl_maps[] = { + * Control map entries for UAC3 BADD profiles + */ + +-static struct usbmix_name_map uac3_badd_generic_io_map[] = { ++static const struct usbmix_name_map uac3_badd_generic_io_map[] = { + { UAC3_BADD_FU_ID2, "Generic Out Playback" }, + { UAC3_BADD_FU_ID5, "Generic In Capture" }, + { 0 } /* terminator */ + }; +-static struct usbmix_name_map uac3_badd_headphone_map[] = { ++static const struct usbmix_name_map uac3_badd_headphone_map[] = { + { UAC3_BADD_FU_ID2, "Headphone Playback" }, + { 0 } /* terminator */ + }; +-static struct usbmix_name_map uac3_badd_speaker_map[] = { ++static const struct usbmix_name_map uac3_badd_speaker_map[] = { + { UAC3_BADD_FU_ID2, "Speaker Playback" }, + { 0 } /* terminator */ + }; +-static struct usbmix_name_map uac3_badd_microphone_map[] = { ++static const struct usbmix_name_map uac3_badd_microphone_map[] = { + { UAC3_BADD_FU_ID5, "Mic Capture" }, + { 0 } /* terminator */ + }; + /* Covers also 'headset adapter' profile */ +-static struct usbmix_name_map uac3_badd_headset_map[] = { ++static const struct usbmix_name_map uac3_badd_headset_map[] = { + { UAC3_BADD_FU_ID2, "Headset Playback" }, + { UAC3_BADD_FU_ID5, "Headset Capture" }, + { UAC3_BADD_FU_ID7, "Sidetone Mixing" }, + { 0 } /* terminator */ + }; +-static struct usbmix_name_map uac3_badd_speakerphone_map[] = { ++static const struct usbmix_name_map uac3_badd_speakerphone_map[] = { + { UAC3_BADD_FU_ID2, "Speaker Playback" }, + { UAC3_BADD_FU_ID5, "Mic Capture" }, + { 0 } /* terminator */ + }; + +-static struct usbmix_ctl_map uac3_badd_usbmix_ctl_maps[] = { ++static const struct usbmix_ctl_map uac3_badd_usbmix_ctl_maps[] = { + { + .id = UAC3_FUNCTION_SUBCLASS_GENERIC_IO, + .map = uac3_badd_generic_io_map, +@@ -619,5 +626,10 @@ static struct usbmix_ctl_map uac3_badd_usbmix_ctl_maps[] = { + .id = UAC3_FUNCTION_SUBCLASS_SPEAKERPHONE, + .map = uac3_badd_speakerphone_map, + }, ++ { ++ /* Sennheiser Communications Headset [PC 8] */ ++ .id = USB_ID(0x1395, 0x0025), ++ .map = sennheiser_pc8_map, ++ }, + { 0 } /* terminator */ + }; +diff --git a/sound/usb/mixer_quirks.c b/sound/usb/mixer_quirks.c +index 49f0dc0e3e4d6..2040fecea17b3 100644 +--- a/sound/usb/mixer_quirks.c ++++ b/sound/usb/mixer_quirks.c +@@ -119,7 +119,7 @@ static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer, + * Create a set of standard UAC controls from a table + */ + static int snd_create_std_mono_table(struct usb_mixer_interface *mixer, +- struct std_mono_table *t) ++ const struct std_mono_table *t) + { + int err; + +@@ -1388,7 +1388,7 @@ static int snd_c400_create_mixer(struct usb_mixer_interface *mixer) + * are valid they presents mono controls as L and R channels of + * stereo. So we provide a good mixer here. + */ +-static struct std_mono_table ebox44_table[] = { ++static const struct std_mono_table ebox44_table[] = { + { + .unitid = 4, + .control = 1, +@@ -1697,7 +1697,7 @@ static struct snd_kcontrol_new snd_microii_mixer_spdif[] = { + static int snd_microii_controls_create(struct usb_mixer_interface *mixer) + { + int err, i; +- static usb_mixer_elem_resume_func_t resume_funcs[] = { ++ const static usb_mixer_elem_resume_func_t resume_funcs[] = { + snd_microii_spdif_default_update, + NULL, + snd_microii_spdif_switch_update +diff --git a/sound/usb/mixer_scarlett.c b/sound/usb/mixer_scarlett.c +index 83715fd8dfd64..6217424e973f5 100644 +--- a/sound/usb/mixer_scarlett.c ++++ b/sound/usb/mixer_scarlett.c +@@ -623,7 +623,7 @@ static int add_output_ctls(struct usb_mixer_interface *mixer, + /********************** device-specific config *************************/ + + /* untested... */ +-static struct scarlett_device_info s6i6_info = { ++static const struct scarlett_device_info s6i6_info = { + .matrix_in = 18, + .matrix_out = 8, + .input_len = 6, +@@ -665,7 +665,7 @@ static struct scarlett_device_info s6i6_info = { + }; + + /* untested... */ +-static struct scarlett_device_info s8i6_info = { ++static const struct scarlett_device_info s8i6_info = { + .matrix_in = 18, + .matrix_out = 6, + .input_len = 8, +@@ -704,7 +704,7 @@ static struct scarlett_device_info s8i6_info = { + } + }; + +-static struct scarlett_device_info s18i6_info = { ++static const struct scarlett_device_info s18i6_info = { + .matrix_in = 18, + .matrix_out = 6, + .input_len = 18, +@@ -741,7 +741,7 @@ static struct scarlett_device_info s18i6_info = { + } + }; + +-static struct scarlett_device_info s18i8_info = { ++static const struct scarlett_device_info s18i8_info = { + .matrix_in = 18, + .matrix_out = 8, + .input_len = 18, +@@ -783,7 +783,7 @@ static struct scarlett_device_info s18i8_info = { + } + }; + +-static struct scarlett_device_info s18i20_info = { ++static const struct scarlett_device_info s18i20_info = { + .matrix_in = 18, + .matrix_out = 8, + .input_len = 18, +@@ -833,7 +833,7 @@ static struct scarlett_device_info s18i20_info = { + + + static int scarlett_controls_create_generic(struct usb_mixer_interface *mixer, +- struct scarlett_device_info *info) ++ const struct scarlett_device_info *info) + { + int i, err; + char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +@@ -896,7 +896,7 @@ int snd_scarlett_controls_create(struct usb_mixer_interface *mixer) + { + int err, i, o; + char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- struct scarlett_device_info *info; ++ const struct scarlett_device_info *info; + struct usb_mixer_elem_info *elem; + static char sample_rate_buffer[4] = { '\x80', '\xbb', '\x00', '\x00' }; + +diff --git a/sound/usb/proc.c b/sound/usb/proc.c +index 49e3f176aaf5a..ffbf4bd9208c4 100644 +--- a/sound/usb/proc.c ++++ b/sound/usb/proc.c +@@ -60,7 +60,7 @@ void snd_usb_audio_create_proc(struct snd_usb_audio *chip) + static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer) + { + struct audioformat *fp; +- static char *sync_types[4] = { ++ static const char * const sync_types[4] = { + "NONE", "ASYNC", "ADAPTIVE", "SYNC" + }; + +diff --git a/sound/usb/stream.c b/sound/usb/stream.c +index c5cbba9fdf0da..eff1ac1dc9ba3 100644 +--- a/sound/usb/stream.c ++++ b/sound/usb/stream.c +@@ -240,7 +240,7 @@ static int add_chmap(struct snd_pcm *pcm, int stream, + static struct snd_pcm_chmap_elem *convert_chmap(int channels, unsigned int bits, + int protocol) + { +- static unsigned int uac1_maps[] = { ++ static const unsigned int uac1_maps[] = { + SNDRV_CHMAP_FL, /* left front */ + SNDRV_CHMAP_FR, /* right front */ + SNDRV_CHMAP_FC, /* center front */ +@@ -255,7 +255,7 @@ static struct snd_pcm_chmap_elem *convert_chmap(int channels, unsigned int bits, + SNDRV_CHMAP_TC, /* top */ + 0 /* terminator */ + }; +- static unsigned int uac2_maps[] = { ++ static const unsigned int uac2_maps[] = { + SNDRV_CHMAP_FL, /* front left */ + SNDRV_CHMAP_FR, /* front right */ + SNDRV_CHMAP_FC, /* front center */ +diff --git a/sound/usb/validate.c b/sound/usb/validate.c +index 5a3c4f7882b00..89a48d7317199 100644 +--- a/sound/usb/validate.c ++++ b/sound/usb/validate.c +@@ -233,7 +233,7 @@ static bool validate_midi_out_jack(const void *p, + #define FIXED(p, t, s) { .protocol = (p), .type = (t), .size = sizeof(s) } + #define FUNC(p, t, f) { .protocol = (p), .type = (t), .func = (f) } + +-static struct usb_desc_validator audio_validators[] = { ++static const struct usb_desc_validator audio_validators[] = { + /* UAC1 */ + FUNC(UAC_VERSION_1, UAC_HEADER, validate_uac1_header), + FIXED(UAC_VERSION_1, UAC_INPUT_TERMINAL, +@@ -288,7 +288,7 @@ static struct usb_desc_validator audio_validators[] = { + { } /* terminator */ + }; + +-static struct usb_desc_validator midi_validators[] = { ++static const struct usb_desc_validator midi_validators[] = { + FIXED(UAC_VERSION_ALL, USB_MS_HEADER, + struct usb_ms_header_descriptor), + FIXED(UAC_VERSION_ALL, USB_MS_MIDI_IN_JACK, |