commit: e9c8dc88c933d5708b1bdcded3c16b2f8b892636 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Sat Apr 13 13:06:10 2024 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Sat Apr 13 13:06:10 2024 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=e9c8dc88
Linux patch 6.6.27 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1026_linux-6.6.27.patch | 4095 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 4099 insertions(+) diff --git a/0000_README b/0000_README index 7ad42cd5..7a128ec9 100644 --- a/0000_README +++ b/0000_README @@ -147,6 +147,10 @@ Patch: 1025_linux-6.6.26.patch From: https://www.kernel.org Desc: Linux 6.6.26 +Patch: 1026_linux-6.6.27.patch +From: https://www.kernel.org +Desc: Linux 6.6.27 + Patch: 1510_fs-enable-link-security-restrictions-by-default.patch From: http://sources.debian.net/src/linux/3.16.7-ckt4-3/debian/patches/debian/fs-enable-link-security-restrictions-by-default.patch/ Desc: Enable link security restrictions by default. diff --git a/1026_linux-6.6.27.patch b/1026_linux-6.6.27.patch new file mode 100644 index 00000000..d4e41272 --- /dev/null +++ b/1026_linux-6.6.27.patch @@ -0,0 +1,4095 @@ +diff --git a/Makefile b/Makefile +index 77ad41bd298e0..c3077c5d57665 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 6 + PATCHLEVEL = 6 +-SUBLEVEL = 26 ++SUBLEVEL = 27 + EXTRAVERSION = + NAME = Hurr durr I'ma ninja sloth + +diff --git a/arch/arm/boot/dts/rockchip/rk322x.dtsi b/arch/arm/boot/dts/rockchip/rk322x.dtsi +index ffc16d6b97e1b..03d9baddcbaba 100644 +--- a/arch/arm/boot/dts/rockchip/rk322x.dtsi ++++ b/arch/arm/boot/dts/rockchip/rk322x.dtsi +@@ -732,14 +732,20 @@ hdmi: hdmi@200a0000 { + status = "disabled"; + + ports { +- hdmi_in: port { +- #address-cells = <1>; +- #size-cells = <0>; +- hdmi_in_vop: endpoint@0 { +- reg = <0>; ++ #address-cells = <1>; ++ #size-cells = <0>; ++ ++ hdmi_in: port@0 { ++ reg = <0>; ++ ++ hdmi_in_vop: endpoint { + remote-endpoint = <&vop_out_hdmi>; + }; + }; ++ ++ hdmi_out: port@1 { ++ reg = <1>; ++ }; + }; + }; + +diff --git a/arch/arm/boot/dts/rockchip/rk3288.dtsi b/arch/arm/boot/dts/rockchip/rk3288.dtsi +index cb9cdaddffd42..8593a83599376 100644 +--- a/arch/arm/boot/dts/rockchip/rk3288.dtsi ++++ b/arch/arm/boot/dts/rockchip/rk3288.dtsi +@@ -1231,27 +1231,37 @@ hdmi: hdmi@ff980000 { + compatible = "rockchip,rk3288-dw-hdmi"; + reg = <0x0 0xff980000 0x0 0x20000>; + reg-io-width = <4>; +- #sound-dai-cells = <0>; +- rockchip,grf = <&grf>; + interrupts = <GIC_SPI 103 IRQ_TYPE_LEVEL_HIGH>; + clocks = <&cru PCLK_HDMI_CTRL>, <&cru SCLK_HDMI_HDCP>, <&cru SCLK_HDMI_CEC>; + clock-names = "iahb", "isfr", "cec"; + power-domains = <&power RK3288_PD_VIO>; ++ rockchip,grf = <&grf>; ++ #sound-dai-cells = <0>; + status = "disabled"; + + ports { +- hdmi_in: port { ++ #address-cells = <1>; ++ #size-cells = <0>; ++ ++ hdmi_in: port@0 { ++ reg = <0>; + #address-cells = <1>; + #size-cells = <0>; ++ + hdmi_in_vopb: endpoint@0 { + reg = <0>; + remote-endpoint = <&vopb_out_hdmi>; + }; ++ + hdmi_in_vopl: endpoint@1 { + reg = <1>; + remote-endpoint = <&vopl_out_hdmi>; + }; + }; ++ ++ hdmi_out: port@1 { ++ reg = <1>; ++ }; + }; + }; + +diff --git a/arch/arm64/boot/dts/rockchip/rk3328.dtsi b/arch/arm64/boot/dts/rockchip/rk3328.dtsi +index cc8209795c3e5..3778fe5c42a4b 100644 +--- a/arch/arm64/boot/dts/rockchip/rk3328.dtsi ++++ b/arch/arm64/boot/dts/rockchip/rk3328.dtsi +@@ -743,11 +743,20 @@ hdmi: hdmi@ff3c0000 { + status = "disabled"; + + ports { +- hdmi_in: port { ++ #address-cells = <1>; ++ #size-cells = <0>; ++ ++ hdmi_in: port@0 { ++ reg = <0>; ++ + hdmi_in_vop: endpoint { + remote-endpoint = <&vop_out_hdmi>; + }; + }; ++ ++ hdmi_out: port@1 { ++ reg = <1>; ++ }; + }; + }; + +diff --git a/arch/arm64/boot/dts/rockchip/rk3399.dtsi b/arch/arm64/boot/dts/rockchip/rk3399.dtsi +index 4a3d0af5ecfe2..fb1ea84c2b14f 100644 +--- a/arch/arm64/boot/dts/rockchip/rk3399.dtsi ++++ b/arch/arm64/boot/dts/rockchip/rk3399.dtsi +@@ -1953,6 +1953,7 @@ simple-audio-card,codec { + hdmi: hdmi@ff940000 { + compatible = "rockchip,rk3399-dw-hdmi"; + reg = <0x0 0xff940000 0x0 0x20000>; ++ reg-io-width = <4>; + interrupts = <GIC_SPI 23 IRQ_TYPE_LEVEL_HIGH 0>; + clocks = <&cru PCLK_HDMI_CTRL>, + <&cru SCLK_HDMI_SFR>, +@@ -1961,13 +1962,16 @@ hdmi: hdmi@ff940000 { + <&cru PLL_VPLL>; + clock-names = "iahb", "isfr", "cec", "grf", "ref"; + power-domains = <&power RK3399_PD_HDCP>; +- reg-io-width = <4>; + rockchip,grf = <&grf>; + #sound-dai-cells = <0>; + status = "disabled"; + + ports { +- hdmi_in: port { ++ #address-cells = <1>; ++ #size-cells = <0>; ++ ++ hdmi_in: port@0 { ++ reg = <0>; + #address-cells = <1>; + #size-cells = <0>; + +@@ -1980,6 +1984,10 @@ hdmi_in_vopl: endpoint@1 { + remote-endpoint = <&vopl_out_hdmi>; + }; + }; ++ ++ hdmi_out: port@1 { ++ reg = <1>; ++ }; + }; + }; + +diff --git a/arch/x86/events/amd/lbr.c b/arch/x86/events/amd/lbr.c +index 110e34c59643a..5149830c7c4fa 100644 +--- a/arch/x86/events/amd/lbr.c ++++ b/arch/x86/events/amd/lbr.c +@@ -173,9 +173,11 @@ void amd_pmu_lbr_read(void) + + /* + * Check if a branch has been logged; if valid = 0, spec = 0 +- * then no branch was recorded ++ * then no branch was recorded; if reserved = 1 then an ++ * erroneous branch was recorded (see Erratum 1452) + */ +- if (!entry.to.split.valid && !entry.to.split.spec) ++ if ((!entry.to.split.valid && !entry.to.split.spec) || ++ entry.to.split.reserved) + continue; + + perf_clear_branch_entry_bitfields(br + out); +diff --git a/arch/x86/include/asm/xen/hypervisor.h b/arch/x86/include/asm/xen/hypervisor.h +index a9088250770f2..64fbd2dbc5b76 100644 +--- a/arch/x86/include/asm/xen/hypervisor.h ++++ b/arch/x86/include/asm/xen/hypervisor.h +@@ -62,6 +62,11 @@ void xen_arch_unregister_cpu(int num); + #ifdef CONFIG_PVH + void __init xen_pvh_init(struct boot_params *boot_params); + void __init mem_map_via_hcall(struct boot_params *boot_params_p); ++#ifdef CONFIG_XEN_PVH ++void __init xen_reserve_extra_memory(struct boot_params *bootp); ++#else ++static inline void xen_reserve_extra_memory(struct boot_params *bootp) { } ++#endif + #endif + + /* Lazy mode for batching updates / context switch */ +diff --git a/arch/x86/pci/fixup.c b/arch/x86/pci/fixup.c +index f347c20247d30..b33afb240601b 100644 +--- a/arch/x86/pci/fixup.c ++++ b/arch/x86/pci/fixup.c +@@ -907,6 +907,54 @@ static void chromeos_fixup_apl_pci_l1ss_capability(struct pci_dev *dev) + DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x5ad6, chromeos_save_apl_pci_l1ss_capability); + DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL, 0x5ad6, chromeos_fixup_apl_pci_l1ss_capability); + ++/* ++ * Disable D3cold on Asus B1400 PCI-NVMe bridge ++ * ++ * On this platform with VMD off, the NVMe device cannot successfully power ++ * back on from D3cold. This appears to be an untested transition by the ++ * vendor: Windows leaves the NVMe and parent bridge in D0 during suspend. ++ * ++ * We disable D3cold on the parent bridge for simplicity, and the fact that ++ * both parent bridge and NVMe device share the same power resource. ++ * ++ * This is only needed on BIOS versions before 308; the newer versions flip ++ * StorageD3Enable from 1 to 0. ++ */ ++static const struct dmi_system_id asus_nvme_broken_d3cold_table[] = { ++ { ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), ++ DMI_MATCH(DMI_BIOS_VERSION, "B1400CEAE.304"), ++ }, ++ }, ++ { ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), ++ DMI_MATCH(DMI_BIOS_VERSION, "B1400CEAE.305"), ++ }, ++ }, ++ { ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), ++ DMI_MATCH(DMI_BIOS_VERSION, "B1400CEAE.306"), ++ }, ++ }, ++ { ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), ++ DMI_MATCH(DMI_BIOS_VERSION, "B1400CEAE.307"), ++ }, ++ }, ++ {} ++}; ++ ++static void asus_disable_nvme_d3cold(struct pci_dev *pdev) ++{ ++ if (dmi_check_system(asus_nvme_broken_d3cold_table) > 0) ++ pci_d3cold_disable(pdev); ++} ++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x9a09, asus_disable_nvme_d3cold); ++ + #ifdef CONFIG_SUSPEND + /* + * Root Ports on some AMD SoCs advertise PME_Support for D3hot and D3cold, but +diff --git a/arch/x86/platform/pvh/enlighten.c b/arch/x86/platform/pvh/enlighten.c +index 00a92cb2c8147..a12117f3d4de7 100644 +--- a/arch/x86/platform/pvh/enlighten.c ++++ b/arch/x86/platform/pvh/enlighten.c +@@ -74,6 +74,9 @@ static void __init init_pvh_bootparams(bool xen_guest) + } else + xen_raw_printk("Warning: Can fit ISA range into e820\n"); + ++ if (xen_guest) ++ xen_reserve_extra_memory(&pvh_bootparams); ++ + pvh_bootparams.hdr.cmd_line_ptr = + pvh_start_info.cmdline_paddr; + +diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c +index 3c61bb98c10e2..a01ca255b0c64 100644 +--- a/arch/x86/xen/enlighten.c ++++ b/arch/x86/xen/enlighten.c +@@ -6,6 +6,7 @@ + #include <linux/console.h> + #include <linux/cpu.h> + #include <linux/kexec.h> ++#include <linux/memblock.h> + #include <linux/slab.h> + #include <linux/panic_notifier.h> + +@@ -350,3 +351,34 @@ void xen_arch_unregister_cpu(int num) + } + EXPORT_SYMBOL(xen_arch_unregister_cpu); + #endif ++ ++/* Amount of extra memory space we add to the e820 ranges */ ++struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata; ++ ++void __init xen_add_extra_mem(unsigned long start_pfn, unsigned long n_pfns) ++{ ++ unsigned int i; ++ ++ /* ++ * No need to check for zero size, should happen rarely and will only ++ * write a new entry regarded to be unused due to zero size. ++ */ ++ for (i = 0; i < XEN_EXTRA_MEM_MAX_REGIONS; i++) { ++ /* Add new region. */ ++ if (xen_extra_mem[i].n_pfns == 0) { ++ xen_extra_mem[i].start_pfn = start_pfn; ++ xen_extra_mem[i].n_pfns = n_pfns; ++ break; ++ } ++ /* Append to existing region. */ ++ if (xen_extra_mem[i].start_pfn + xen_extra_mem[i].n_pfns == ++ start_pfn) { ++ xen_extra_mem[i].n_pfns += n_pfns; ++ break; ++ } ++ } ++ if (i == XEN_EXTRA_MEM_MAX_REGIONS) ++ printk(KERN_WARNING "Warning: not enough extra memory regions\n"); ++ ++ memblock_reserve(PFN_PHYS(start_pfn), PFN_PHYS(n_pfns)); ++} +diff --git a/arch/x86/xen/enlighten_pvh.c b/arch/x86/xen/enlighten_pvh.c +index ada3868c02c23..c28f073c1df52 100644 +--- a/arch/x86/xen/enlighten_pvh.c ++++ b/arch/x86/xen/enlighten_pvh.c +@@ -1,6 +1,7 @@ + // SPDX-License-Identifier: GPL-2.0 + #include <linux/acpi.h> + #include <linux/export.h> ++#include <linux/mm.h> + + #include <xen/hvc-console.h> + +@@ -72,3 +73,70 @@ void __init mem_map_via_hcall(struct boot_params *boot_params_p) + } + boot_params_p->e820_entries = memmap.nr_entries; + } ++ ++/* ++ * Reserve e820 UNUSABLE regions to inflate the memory balloon. ++ * ++ * On PVH dom0 the host memory map is used, RAM regions available to dom0 are ++ * located as the same place as in the native memory map, but since dom0 gets ++ * less memory than the total amount of host RAM the ranges that can't be ++ * populated are converted from RAM -> UNUSABLE. Use such regions (up to the ++ * ratio signaled in EXTRA_MEM_RATIO) in order to inflate the balloon driver at ++ * boot. Doing so prevents the guest (even if just temporary) from using holes ++ * in the memory map in order to map grants or foreign addresses, and ++ * hopefully limits the risk of a clash with a device MMIO region. Ideally the ++ * hypervisor should notify us which memory ranges are suitable for creating ++ * foreign mappings, but that's not yet implemented. ++ */ ++void __init xen_reserve_extra_memory(struct boot_params *bootp) ++{ ++ unsigned int i, ram_pages = 0, extra_pages; ++ ++ for (i = 0; i < bootp->e820_entries; i++) { ++ struct boot_e820_entry *e = &bootp->e820_table[i]; ++ ++ if (e->type != E820_TYPE_RAM) ++ continue; ++ ram_pages += PFN_DOWN(e->addr + e->size) - PFN_UP(e->addr); ++ } ++ ++ /* Max amount of extra memory. */ ++ extra_pages = EXTRA_MEM_RATIO * ram_pages; ++ ++ /* ++ * Convert UNUSABLE ranges to RAM and reserve them for foreign mapping ++ * purposes. ++ */ ++ for (i = 0; i < bootp->e820_entries && extra_pages; i++) { ++ struct boot_e820_entry *e = &bootp->e820_table[i]; ++ unsigned long pages; ++ ++ if (e->type != E820_TYPE_UNUSABLE) ++ continue; ++ ++ pages = min(extra_pages, ++ PFN_DOWN(e->addr + e->size) - PFN_UP(e->addr)); ++ ++ if (pages != (PFN_DOWN(e->addr + e->size) - PFN_UP(e->addr))) { ++ struct boot_e820_entry *next; ++ ++ if (bootp->e820_entries == ++ ARRAY_SIZE(bootp->e820_table)) ++ /* No space left to split - skip region. */ ++ continue; ++ ++ /* Split entry. */ ++ next = e + 1; ++ memmove(next, e, ++ (bootp->e820_entries - i) * sizeof(*e)); ++ bootp->e820_entries++; ++ next->addr = PAGE_ALIGN(e->addr) + PFN_PHYS(pages); ++ e->size = next->addr - e->addr; ++ next->size -= e->size; ++ } ++ e->type = E820_TYPE_RAM; ++ extra_pages -= pages; ++ ++ xen_add_extra_mem(PFN_UP(e->addr), pages); ++ } ++} +diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c +index b3e37961065a2..380591028cb8f 100644 +--- a/arch/x86/xen/setup.c ++++ b/arch/x86/xen/setup.c +@@ -38,9 +38,6 @@ + + #define GB(x) ((uint64_t)(x) * 1024 * 1024 * 1024) + +-/* Amount of extra memory space we add to the e820 ranges */ +-struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata; +- + /* Number of pages released from the initial allocation. */ + unsigned long xen_released_pages; + +@@ -64,18 +61,6 @@ static struct { + } xen_remap_buf __initdata __aligned(PAGE_SIZE); + static unsigned long xen_remap_mfn __initdata = INVALID_P2M_ENTRY; + +-/* +- * The maximum amount of extra memory compared to the base size. The +- * main scaling factor is the size of struct page. At extreme ratios +- * of base:extra, all the base memory can be filled with page +- * structures for the extra memory, leaving no space for anything +- * else. +- * +- * 10x seems like a reasonable balance between scaling flexibility and +- * leaving a practically usable system. +- */ +-#define EXTRA_MEM_RATIO (10) +- + static bool xen_512gb_limit __initdata = IS_ENABLED(CONFIG_XEN_512GB); + + static void __init xen_parse_512gb(void) +@@ -96,35 +81,6 @@ static void __init xen_parse_512gb(void) + xen_512gb_limit = val; + } + +-static void __init xen_add_extra_mem(unsigned long start_pfn, +- unsigned long n_pfns) +-{ +- int i; +- +- /* +- * No need to check for zero size, should happen rarely and will only +- * write a new entry regarded to be unused due to zero size. +- */ +- for (i = 0; i < XEN_EXTRA_MEM_MAX_REGIONS; i++) { +- /* Add new region. */ +- if (xen_extra_mem[i].n_pfns == 0) { +- xen_extra_mem[i].start_pfn = start_pfn; +- xen_extra_mem[i].n_pfns = n_pfns; +- break; +- } +- /* Append to existing region. */ +- if (xen_extra_mem[i].start_pfn + xen_extra_mem[i].n_pfns == +- start_pfn) { +- xen_extra_mem[i].n_pfns += n_pfns; +- break; +- } +- } +- if (i == XEN_EXTRA_MEM_MAX_REGIONS) +- printk(KERN_WARNING "Warning: not enough extra memory regions\n"); +- +- memblock_reserve(PFN_PHYS(start_pfn), PFN_PHYS(n_pfns)); +-} +- + static void __init xen_del_extra_mem(unsigned long start_pfn, + unsigned long n_pfns) + { +diff --git a/arch/x86/xen/xen-ops.h b/arch/x86/xen/xen-ops.h +index a87ab36889e76..79cf93f2c92f1 100644 +--- a/arch/x86/xen/xen-ops.h ++++ b/arch/x86/xen/xen-ops.h +@@ -163,4 +163,18 @@ void xen_hvm_post_suspend(int suspend_cancelled); + static inline void xen_hvm_post_suspend(int suspend_cancelled) {} + #endif + ++/* ++ * The maximum amount of extra memory compared to the base size. The ++ * main scaling factor is the size of struct page. At extreme ratios ++ * of base:extra, all the base memory can be filled with page ++ * structures for the extra memory, leaving no space for anything ++ * else. ++ * ++ * 10x seems like a reasonable balance between scaling flexibility and ++ * leaving a practically usable system. ++ */ ++#define EXTRA_MEM_RATIO (10) ++ ++void xen_add_extra_mem(unsigned long start_pfn, unsigned long n_pfns); ++ + #endif /* XEN_OPS_H */ +diff --git a/block/blk-stat.c b/block/blk-stat.c +index 7ff76ae6c76a9..e42c263e53fb9 100644 +--- a/block/blk-stat.c ++++ b/block/blk-stat.c +@@ -27,7 +27,7 @@ void blk_rq_stat_init(struct blk_rq_stat *stat) + /* src is a per-cpu stat, mean isn't initialized */ + void blk_rq_stat_sum(struct blk_rq_stat *dst, struct blk_rq_stat *src) + { +- if (!src->nr_samples) ++ if (dst->nr_samples + src->nr_samples <= dst->nr_samples) + return; + + dst->min = min(dst->min, src->min); +diff --git a/drivers/accel/habanalabs/common/habanalabs.h b/drivers/accel/habanalabs/common/habanalabs.h +index 05febd5b14e9c..179e5e7013a12 100644 +--- a/drivers/accel/habanalabs/common/habanalabs.h ++++ b/drivers/accel/habanalabs/common/habanalabs.h +@@ -2508,7 +2508,7 @@ struct hl_state_dump_specs { + * DEVICES + */ + +-#define HL_STR_MAX 32 ++#define HL_STR_MAX 64 + + #define HL_DEV_STS_MAX (HL_DEVICE_STATUS_LAST + 1) + +diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c +index 808484d112097..728acfeb774d8 100644 +--- a/drivers/acpi/sleep.c ++++ b/drivers/acpi/sleep.c +@@ -385,18 +385,6 @@ static const struct dmi_system_id acpisleep_dmi_table[] __initconst = { + DMI_MATCH(DMI_PRODUCT_NAME, "20GGA00L00"), + }, + }, +- /* +- * ASUS B1400CEAE hangs on resume from suspend (see +- * https://bugzilla.kernel.org/show_bug.cgi?id=215742). +- */ +- { +- .callback = init_default_s3, +- .ident = "ASUS B1400CEAE", +- .matches = { +- DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), +- DMI_MATCH(DMI_PRODUCT_NAME, "ASUS EXPERTBOOK B1400CEAE"), +- }, +- }, + {}, + }; + +diff --git a/drivers/acpi/x86/utils.c b/drivers/acpi/x86/utils.c +index 63d834dd38112..c708524576df4 100644 +--- a/drivers/acpi/x86/utils.c ++++ b/drivers/acpi/x86/utils.c +@@ -429,7 +429,7 @@ bool acpi_quirk_skip_i2c_client_enumeration(struct acpi_device *adev) + } + EXPORT_SYMBOL_GPL(acpi_quirk_skip_i2c_client_enumeration); + +-int acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *skip) ++static int acpi_dmi_skip_serdev_enumeration(struct device *controller_parent, bool *skip) + { + struct acpi_device *adev = ACPI_COMPANION(controller_parent); + const struct dmi_system_id *dmi_id; +@@ -437,8 +437,6 @@ int acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *s + u64 uid; + int ret; + +- *skip = false; +- + ret = acpi_dev_uid_to_integer(adev, &uid); + if (ret) + return 0; +@@ -464,7 +462,6 @@ int acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *s + + return 0; + } +-EXPORT_SYMBOL_GPL(acpi_quirk_skip_serdev_enumeration); + + bool acpi_quirk_skip_gpio_event_handlers(void) + { +@@ -479,8 +476,21 @@ bool acpi_quirk_skip_gpio_event_handlers(void) + return (quirks & ACPI_QUIRK_SKIP_GPIO_EVENT_HANDLERS); + } + EXPORT_SYMBOL_GPL(acpi_quirk_skip_gpio_event_handlers); ++#else ++static int acpi_dmi_skip_serdev_enumeration(struct device *controller_parent, bool *skip) ++{ ++ return 0; ++} + #endif + ++int acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *skip) ++{ ++ *skip = false; ++ ++ return acpi_dmi_skip_serdev_enumeration(controller_parent, skip); ++} ++EXPORT_SYMBOL_GPL(acpi_quirk_skip_serdev_enumeration); ++ + /* Lists of PMIC ACPI HIDs with an (often better) native charger driver */ + static const struct { + const char *hid; +diff --git a/drivers/bluetooth/btintel.c b/drivers/bluetooth/btintel.c +index 2462796a512a5..ac1562d9ef26b 100644 +--- a/drivers/bluetooth/btintel.c ++++ b/drivers/bluetooth/btintel.c +@@ -441,7 +441,7 @@ int btintel_read_version(struct hci_dev *hdev, struct intel_version *ver) + return PTR_ERR(skb); + } + +- if (skb->len != sizeof(*ver)) { ++ if (!skb || skb->len != sizeof(*ver)) { + bt_dev_err(hdev, "Intel version event size mismatch"); + kfree_skb(skb); + return -EILSEQ; +diff --git a/drivers/bluetooth/btmtk.c b/drivers/bluetooth/btmtk.c +index 285418dbb43f5..ac8ebccd35075 100644 +--- a/drivers/bluetooth/btmtk.c ++++ b/drivers/bluetooth/btmtk.c +@@ -422,5 +422,6 @@ MODULE_LICENSE("GPL"); + MODULE_FIRMWARE(FIRMWARE_MT7622); + MODULE_FIRMWARE(FIRMWARE_MT7663); + MODULE_FIRMWARE(FIRMWARE_MT7668); ++MODULE_FIRMWARE(FIRMWARE_MT7922); + MODULE_FIRMWARE(FIRMWARE_MT7961); + MODULE_FIRMWARE(FIRMWARE_MT7925); +diff --git a/drivers/bluetooth/btmtk.h b/drivers/bluetooth/btmtk.h +index 56f5502baadf9..cbcdb99a22e6d 100644 +--- a/drivers/bluetooth/btmtk.h ++++ b/drivers/bluetooth/btmtk.h +@@ -4,6 +4,7 @@ + #define FIRMWARE_MT7622 "mediatek/mt7622pr2h.bin" + #define FIRMWARE_MT7663 "mediatek/mt7663pr2h.bin" + #define FIRMWARE_MT7668 "mediatek/mt7668pr2h.bin" ++#define FIRMWARE_MT7922 "mediatek/BT_RAM_CODE_MT7922_1_1_hdr.bin" + #define FIRMWARE_MT7961 "mediatek/BT_RAM_CODE_MT7961_1_2_hdr.bin" + #define FIRMWARE_MT7925 "mediatek/mt7925/BT_RAM_CODE_MT7925_1_1_hdr.bin" + +diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c +index 8dbdc51976e7b..1976593bc804e 100644 +--- a/drivers/bluetooth/btusb.c ++++ b/drivers/bluetooth/btusb.c +@@ -4477,6 +4477,7 @@ static int btusb_probe(struct usb_interface *intf, + set_bit(HCI_QUIRK_BROKEN_READ_TRANSMIT_POWER, &hdev->quirks); + set_bit(HCI_QUIRK_BROKEN_SET_RPA_TIMEOUT, &hdev->quirks); + set_bit(HCI_QUIRK_BROKEN_EXT_SCAN, &hdev->quirks); ++ set_bit(HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE, &hdev->quirks); + } + + if (!reset) +diff --git a/drivers/bus/mhi/host/init.c b/drivers/bus/mhi/host/init.c +index f78aefd2d7a36..cfd17c02fe20e 100644 +--- a/drivers/bus/mhi/host/init.c ++++ b/drivers/bus/mhi/host/init.c +@@ -62,6 +62,7 @@ static const char * const mhi_pm_state_str[] = { + [MHI_PM_STATE_FW_DL_ERR] = "Firmware Download Error", + [MHI_PM_STATE_SYS_ERR_DETECT] = "SYS ERROR Detect", + [MHI_PM_STATE_SYS_ERR_PROCESS] = "SYS ERROR Process", ++ [MHI_PM_STATE_SYS_ERR_FAIL] = "SYS ERROR Failure", + [MHI_PM_STATE_SHUTDOWN_PROCESS] = "SHUTDOWN Process", + [MHI_PM_STATE_LD_ERR_FATAL_DETECT] = "Linkdown or Error Fatal Detect", + }; +diff --git a/drivers/bus/mhi/host/internal.h b/drivers/bus/mhi/host/internal.h +index 2e139e76de4c0..d2858236af52b 100644 +--- a/drivers/bus/mhi/host/internal.h ++++ b/drivers/bus/mhi/host/internal.h +@@ -88,6 +88,7 @@ enum mhi_pm_state { + MHI_PM_STATE_FW_DL_ERR, + MHI_PM_STATE_SYS_ERR_DETECT, + MHI_PM_STATE_SYS_ERR_PROCESS, ++ MHI_PM_STATE_SYS_ERR_FAIL, + MHI_PM_STATE_SHUTDOWN_PROCESS, + MHI_PM_STATE_LD_ERR_FATAL_DETECT, + MHI_PM_STATE_MAX +@@ -104,14 +105,16 @@ enum mhi_pm_state { + #define MHI_PM_FW_DL_ERR BIT(7) + #define MHI_PM_SYS_ERR_DETECT BIT(8) + #define MHI_PM_SYS_ERR_PROCESS BIT(9) +-#define MHI_PM_SHUTDOWN_PROCESS BIT(10) ++#define MHI_PM_SYS_ERR_FAIL BIT(10) ++#define MHI_PM_SHUTDOWN_PROCESS BIT(11) + /* link not accessible */ +-#define MHI_PM_LD_ERR_FATAL_DETECT BIT(11) ++#define MHI_PM_LD_ERR_FATAL_DETECT BIT(12) + + #define MHI_REG_ACCESS_VALID(pm_state) ((pm_state & (MHI_PM_POR | MHI_PM_M0 | \ + MHI_PM_M2 | MHI_PM_M3_ENTER | MHI_PM_M3_EXIT | \ + MHI_PM_SYS_ERR_DETECT | MHI_PM_SYS_ERR_PROCESS | \ +- MHI_PM_SHUTDOWN_PROCESS | MHI_PM_FW_DL_ERR))) ++ MHI_PM_SYS_ERR_FAIL | MHI_PM_SHUTDOWN_PROCESS | \ ++ MHI_PM_FW_DL_ERR))) + #define MHI_PM_IN_ERROR_STATE(pm_state) (pm_state >= MHI_PM_FW_DL_ERR) + #define MHI_PM_IN_FATAL_STATE(pm_state) (pm_state == MHI_PM_LD_ERR_FATAL_DETECT) + #define MHI_DB_ACCESS_VALID(mhi_cntrl) (mhi_cntrl->pm_state & mhi_cntrl->db_access) +diff --git a/drivers/bus/mhi/host/pm.c b/drivers/bus/mhi/host/pm.c +index 8a4362d75fc43..27f8a40f288cf 100644 +--- a/drivers/bus/mhi/host/pm.c ++++ b/drivers/bus/mhi/host/pm.c +@@ -36,7 +36,10 @@ + * M0 <--> M0 + * M0 -> FW_DL_ERR + * M0 -> M3_ENTER -> M3 -> M3_EXIT --> M0 +- * L1: SYS_ERR_DETECT -> SYS_ERR_PROCESS --> POR ++ * L1: SYS_ERR_DETECT -> SYS_ERR_PROCESS ++ * SYS_ERR_PROCESS -> SYS_ERR_FAIL ++ * SYS_ERR_FAIL -> SYS_ERR_DETECT ++ * SYS_ERR_PROCESS --> POR + * L2: SHUTDOWN_PROCESS -> LD_ERR_FATAL_DETECT + * SHUTDOWN_PROCESS -> DISABLE + * L3: LD_ERR_FATAL_DETECT <--> LD_ERR_FATAL_DETECT +@@ -93,7 +96,12 @@ static const struct mhi_pm_transitions dev_state_transitions[] = { + }, + { + MHI_PM_SYS_ERR_PROCESS, +- MHI_PM_POR | MHI_PM_SHUTDOWN_PROCESS | ++ MHI_PM_POR | MHI_PM_SYS_ERR_FAIL | MHI_PM_SHUTDOWN_PROCESS | ++ MHI_PM_LD_ERR_FATAL_DETECT ++ }, ++ { ++ MHI_PM_SYS_ERR_FAIL, ++ MHI_PM_SYS_ERR_DETECT | MHI_PM_SHUTDOWN_PROCESS | + MHI_PM_LD_ERR_FATAL_DETECT + }, + /* L2 States */ +@@ -624,7 +632,13 @@ static void mhi_pm_sys_error_transition(struct mhi_controller *mhi_cntrl) + !in_reset, timeout); + if (!ret || in_reset) { + dev_err(dev, "Device failed to exit MHI Reset state\n"); +- goto exit_sys_error_transition; ++ write_lock_irq(&mhi_cntrl->pm_lock); ++ cur_state = mhi_tryset_pm_state(mhi_cntrl, ++ MHI_PM_SYS_ERR_FAIL); ++ write_unlock_irq(&mhi_cntrl->pm_lock); ++ /* Shutdown may have occurred, otherwise cleanup now */ ++ if (cur_state != MHI_PM_SYS_ERR_FAIL) ++ goto exit_sys_error_transition; + } + + /* +diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c +index 4bc7c793de3b9..9177265d73b47 100644 +--- a/drivers/cpufreq/cpufreq.c ++++ b/drivers/cpufreq/cpufreq.c +@@ -1576,7 +1576,8 @@ static int cpufreq_online(unsigned int cpu) + if (cpufreq_driver->ready) + cpufreq_driver->ready(policy); + +- if (cpufreq_thermal_control_enabled(cpufreq_driver)) ++ /* Register cpufreq cooling only for a new policy */ ++ if (new_policy && cpufreq_thermal_control_enabled(cpufreq_driver)) + policy->cdev = of_cpufreq_cooling_register(policy); + + pr_debug("initialization complete\n"); +@@ -1660,11 +1661,6 @@ static void __cpufreq_offline(unsigned int cpu, struct cpufreq_policy *policy) + else + policy->last_policy = policy->policy; + +- if (cpufreq_thermal_control_enabled(cpufreq_driver)) { +- cpufreq_cooling_unregister(policy->cdev); +- policy->cdev = NULL; +- } +- + if (has_target()) + cpufreq_exit_governor(policy); + +@@ -1725,6 +1721,15 @@ static void cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif) + return; + } + ++ /* ++ * Unregister cpufreq cooling once all the CPUs of the policy are ++ * removed. ++ */ ++ if (cpufreq_thermal_control_enabled(cpufreq_driver)) { ++ cpufreq_cooling_unregister(policy->cdev); ++ policy->cdev = NULL; ++ } ++ + /* We did light-weight exit earlier, do full tear down now */ + if (cpufreq_driver->offline) + cpufreq_driver->exit(policy); +diff --git a/drivers/cpuidle/driver.c b/drivers/cpuidle/driver.c +index d9cda7f6ccb98..cf5873cc45dc8 100644 +--- a/drivers/cpuidle/driver.c ++++ b/drivers/cpuidle/driver.c +@@ -16,6 +16,7 @@ + #include <linux/cpumask.h> + #include <linux/tick.h> + #include <linux/cpu.h> ++#include <linux/math64.h> + + #include "cpuidle.h" + +@@ -187,7 +188,7 @@ static void __cpuidle_driver_init(struct cpuidle_driver *drv) + s->target_residency = div_u64(s->target_residency_ns, NSEC_PER_USEC); + + if (s->exit_latency > 0) +- s->exit_latency_ns = s->exit_latency * NSEC_PER_USEC; ++ s->exit_latency_ns = mul_u32_u32(s->exit_latency, NSEC_PER_USEC); + else if (s->exit_latency_ns < 0) + s->exit_latency_ns = 0; + else +diff --git a/drivers/firmware/tegra/bpmp-debugfs.c b/drivers/firmware/tegra/bpmp-debugfs.c +index 6dfe3d34109ee..b20d04950d99b 100644 +--- a/drivers/firmware/tegra/bpmp-debugfs.c ++++ b/drivers/firmware/tegra/bpmp-debugfs.c +@@ -77,7 +77,7 @@ static const char *get_filename(struct tegra_bpmp *bpmp, + + root_path_buf = kzalloc(root_path_buf_len, GFP_KERNEL); + if (!root_path_buf) +- goto out; ++ return NULL; + + root_path = dentry_path(bpmp->debugfs_mirror, root_path_buf, + root_path_buf_len); +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c b/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +index c37f1fcd2165b..c157721214e8d 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +@@ -778,8 +778,8 @@ static int kfd_ioctl_get_process_apertures_new(struct file *filp, + * nodes, but not more than args->num_of_nodes as that is + * the amount of memory allocated by user + */ +- pa = kzalloc((sizeof(struct kfd_process_device_apertures) * +- args->num_of_nodes), GFP_KERNEL); ++ pa = kcalloc(args->num_of_nodes, sizeof(struct kfd_process_device_apertures), ++ GFP_KERNEL); + if (!pa) + return -ENOMEM; + +diff --git a/drivers/gpu/drm/amd/display/modules/inc/mod_stats.h b/drivers/gpu/drm/amd/display/modules/inc/mod_stats.h +index 4220fd8fdd60c..54cd86060f4d6 100644 +--- a/drivers/gpu/drm/amd/display/modules/inc/mod_stats.h ++++ b/drivers/gpu/drm/amd/display/modules/inc/mod_stats.h +@@ -57,10 +57,10 @@ void mod_stats_update_event(struct mod_stats *mod_stats, + unsigned int length); + + void mod_stats_update_flip(struct mod_stats *mod_stats, +- unsigned long timestamp_in_ns); ++ unsigned long long timestamp_in_ns); + + void mod_stats_update_vupdate(struct mod_stats *mod_stats, +- unsigned long timestamp_in_ns); ++ unsigned long long timestamp_in_ns); + + void mod_stats_update_freesync(struct mod_stats *mod_stats, + unsigned int v_total_min, +diff --git a/drivers/gpu/drm/drm_modeset_helper.c b/drivers/gpu/drm/drm_modeset_helper.c +index f858dfedf2cfc..2c582020cb423 100644 +--- a/drivers/gpu/drm/drm_modeset_helper.c ++++ b/drivers/gpu/drm/drm_modeset_helper.c +@@ -193,13 +193,22 @@ int drm_mode_config_helper_suspend(struct drm_device *dev) + + if (!dev) + return 0; ++ /* ++ * Don't disable polling if it was never initialized ++ */ ++ if (dev->mode_config.poll_enabled) ++ drm_kms_helper_poll_disable(dev); + +- drm_kms_helper_poll_disable(dev); + drm_fb_helper_set_suspend_unlocked(dev->fb_helper, 1); + state = drm_atomic_helper_suspend(dev); + if (IS_ERR(state)) { + drm_fb_helper_set_suspend_unlocked(dev->fb_helper, 0); +- drm_kms_helper_poll_enable(dev); ++ /* ++ * Don't enable polling if it was never initialized ++ */ ++ if (dev->mode_config.poll_enabled) ++ drm_kms_helper_poll_enable(dev); ++ + return PTR_ERR(state); + } + +@@ -239,7 +248,11 @@ int drm_mode_config_helper_resume(struct drm_device *dev) + dev->mode_config.suspend_state = NULL; + + drm_fb_helper_set_suspend_unlocked(dev->fb_helper, 0); +- drm_kms_helper_poll_enable(dev); ++ /* ++ * Don't enable polling if it is not initialized ++ */ ++ if (dev->mode_config.poll_enabled) ++ drm_kms_helper_poll_enable(dev); + + return ret; + } +diff --git a/drivers/gpu/drm/drm_panel_orientation_quirks.c b/drivers/gpu/drm/drm_panel_orientation_quirks.c +index d5c15292ae937..3fe5e6439c401 100644 +--- a/drivers/gpu/drm/drm_panel_orientation_quirks.c ++++ b/drivers/gpu/drm/drm_panel_orientation_quirks.c +@@ -117,6 +117,12 @@ static const struct drm_dmi_panel_orientation_data lcd1080x1920_leftside_up = { + .orientation = DRM_MODE_PANEL_ORIENTATION_LEFT_UP, + }; + ++static const struct drm_dmi_panel_orientation_data lcd1080x1920_rightside_up = { ++ .width = 1080, ++ .height = 1920, ++ .orientation = DRM_MODE_PANEL_ORIENTATION_RIGHT_UP, ++}; ++ + static const struct drm_dmi_panel_orientation_data lcd1200x1920_rightside_up = { + .width = 1200, + .height = 1920, +@@ -279,6 +285,12 @@ static const struct dmi_system_id orientation_data[] = { + DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "G1618-03") + }, + .driver_data = (void *)&lcd720x1280_rightside_up, ++ }, { /* GPD Win Mini */ ++ .matches = { ++ DMI_EXACT_MATCH(DMI_SYS_VENDOR, "GPD"), ++ DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "G1617-01") ++ }, ++ .driver_data = (void *)&lcd1080x1920_rightside_up, + }, { /* I.T.Works TW891 */ + .matches = { + DMI_EXACT_MATCH(DMI_SYS_VENDOR, "To be filled by O.E.M."), +diff --git a/drivers/gpu/drm/drm_probe_helper.c b/drivers/gpu/drm/drm_probe_helper.c +index 15ed974bcb988..c90afb5d08987 100644 +--- a/drivers/gpu/drm/drm_probe_helper.c ++++ b/drivers/gpu/drm/drm_probe_helper.c +@@ -293,14 +293,17 @@ static void reschedule_output_poll_work(struct drm_device *dev) + * Drivers can call this helper from their device resume implementation. It is + * not an error to call this even when output polling isn't enabled. + * ++ * If device polling was never initialized before, this call will trigger a ++ * warning and return. ++ * + * Note that calls to enable and disable polling must be strictly ordered, which + * is automatically the case when they're only call from suspend/resume + * callbacks. + */ + void drm_kms_helper_poll_enable(struct drm_device *dev) + { +- if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll || +- dev->mode_config.poll_running) ++ if (drm_WARN_ON_ONCE(dev, !dev->mode_config.poll_enabled) || ++ !drm_kms_helper_poll || dev->mode_config.poll_running) + return; + + if (drm_kms_helper_enable_hpd(dev) || +@@ -626,8 +629,12 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector, + 0); + } + +- /* Re-enable polling in case the global poll config changed. */ +- drm_kms_helper_poll_enable(dev); ++ /* ++ * Re-enable polling in case the global poll config changed but polling ++ * is still initialized. ++ */ ++ if (dev->mode_config.poll_enabled) ++ drm_kms_helper_poll_enable(dev); + + if (connector->status == connector_status_disconnected) { + DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n", +@@ -878,12 +885,18 @@ EXPORT_SYMBOL(drm_kms_helper_is_poll_worker); + * not an error to call this even when output polling isn't enabled or already + * disabled. Polling is re-enabled by calling drm_kms_helper_poll_enable(). + * ++ * If however, the polling was never initialized, this call will trigger a ++ * warning and return ++ * + * Note that calls to enable and disable polling must be strictly ordered, which + * is automatically the case when they're only call from suspend/resume + * callbacks. + */ + void drm_kms_helper_poll_disable(struct drm_device *dev) + { ++ if (drm_WARN_ON(dev, !dev->mode_config.poll_enabled)) ++ return; ++ + if (dev->mode_config.poll_running) + drm_kms_helper_disable_hpd(dev); + +diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c +index e58b7e2498166..b3e5185835c37 100644 +--- a/drivers/gpu/drm/ttm/ttm_bo.c ++++ b/drivers/gpu/drm/ttm/ttm_bo.c +@@ -764,7 +764,7 @@ static int ttm_bo_mem_force_space(struct ttm_buffer_object *bo, + * This function may sleep while waiting for space to become available. + * Returns: + * -EBUSY: No space available (only if no_wait == 1). +- * -ENOMEM: Could not allocate memory for the buffer object, either due to ++ * -ENOSPC: Could not allocate space for the buffer object, either due to + * fragmentation or concurrent allocators. + * -ERESTARTSYS: An interruptible sleep was interrupted by a signal. + */ +@@ -824,7 +824,7 @@ int ttm_bo_mem_space(struct ttm_buffer_object *bo, + goto error; + } + +- ret = -ENOMEM; ++ ret = -ENOSPC; + if (!type_found) { + pr_err(TTM_PFX "No compatible memory type found\n"); + ret = -EINVAL; +@@ -910,6 +910,9 @@ int ttm_bo_validate(struct ttm_buffer_object *bo, + return -EINVAL; + + ret = ttm_bo_move_buffer(bo, placement, ctx); ++ /* For backward compatibility with userspace */ ++ if (ret == -ENOSPC) ++ return -ENOMEM; + if (ret) + return ret; + +diff --git a/drivers/gpu/drm/vc4/vc4_plane.c b/drivers/gpu/drm/vc4/vc4_plane.c +index 00e713faecd5a..5948e34f7f813 100644 +--- a/drivers/gpu/drm/vc4/vc4_plane.c ++++ b/drivers/gpu/drm/vc4/vc4_plane.c +@@ -1505,9 +1505,6 @@ static int vc4_prepare_fb(struct drm_plane *plane, + + drm_gem_plane_helper_prepare_fb(plane, state); + +- if (plane->state->fb == state->fb) +- return 0; +- + return vc4_bo_inc_usecnt(bo); + } + +@@ -1516,7 +1513,7 @@ static void vc4_cleanup_fb(struct drm_plane *plane, + { + struct vc4_bo *bo; + +- if (plane->state->fb == state->fb || !state->fb) ++ if (!state->fb) + return; + + bo = to_vc4_bo(&drm_fb_dma_get_gem_obj(state->fb, 0)->base); +diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h +index 72046039d1be7..0a4daff4846ff 100644 +--- a/drivers/hid/hid-ids.h ++++ b/drivers/hid/hid-ids.h +@@ -427,6 +427,7 @@ + #define I2C_DEVICE_ID_HP_SPECTRE_X360_14T_EA100_V1 0x2BED + #define I2C_DEVICE_ID_HP_SPECTRE_X360_14T_EA100_V2 0x2BEE + #define I2C_DEVICE_ID_HP_ENVY_X360_15_EU0556NG 0x2D02 ++#define I2C_DEVICE_ID_CHROMEBOOK_TROGDOR_POMPOM 0x2F81 + + #define USB_VENDOR_ID_ELECOM 0x056e + #define USB_DEVICE_ID_ELECOM_BM084 0x0061 +diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c +index c8b20d44b1472..e03d300d2bac4 100644 +--- a/drivers/hid/hid-input.c ++++ b/drivers/hid/hid-input.c +@@ -411,6 +411,8 @@ static const struct hid_device_id hid_battery_quirks[] = { + HID_BATTERY_QUIRK_IGNORE }, + { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_HP_ENVY_X360_15_EU0556NG), + HID_BATTERY_QUIRK_IGNORE }, ++ { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_CHROMEBOOK_TROGDOR_POMPOM), ++ HID_BATTERY_QUIRK_AVOID_QUERY }, + {} + }; + +diff --git a/drivers/i2c/busses/i2c-designware-core.h b/drivers/i2c/busses/i2c-designware-core.h +index a7f6f3eafad7d..ae835000fd32a 100644 +--- a/drivers/i2c/busses/i2c-designware-core.h ++++ b/drivers/i2c/busses/i2c-designware-core.h +@@ -318,7 +318,7 @@ struct dw_i2c_dev { + #define AMD_UCSI_INTR_EN 0xd + + #define TXGBE_TX_FIFO_DEPTH 4 +-#define TXGBE_RX_FIFO_DEPTH 0 ++#define TXGBE_RX_FIFO_DEPTH 1 + + struct i2c_dw_semaphore_callbacks { + int (*probe)(struct dw_i2c_dev *dev); +diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c +index ff58058aeadca..bf0df6ee4f785 100644 +--- a/drivers/infiniband/core/cm.c ++++ b/drivers/infiniband/core/cm.c +@@ -34,6 +34,7 @@ MODULE_AUTHOR("Sean Hefty"); + MODULE_DESCRIPTION("InfiniBand CM"); + MODULE_LICENSE("Dual BSD/GPL"); + ++#define CM_DESTROY_ID_WAIT_TIMEOUT 10000 /* msecs */ + static const char * const ibcm_rej_reason_strs[] = { + [IB_CM_REJ_NO_QP] = "no QP", + [IB_CM_REJ_NO_EEC] = "no EEC", +@@ -1025,10 +1026,20 @@ static void cm_reset_to_idle(struct cm_id_private *cm_id_priv) + } + } + ++static noinline void cm_destroy_id_wait_timeout(struct ib_cm_id *cm_id) ++{ ++ struct cm_id_private *cm_id_priv; ++ ++ cm_id_priv = container_of(cm_id, struct cm_id_private, id); ++ pr_err("%s: cm_id=%p timed out. state=%d refcnt=%d\n", __func__, ++ cm_id, cm_id->state, refcount_read(&cm_id_priv->refcount)); ++} ++ + static void cm_destroy_id(struct ib_cm_id *cm_id, int err) + { + struct cm_id_private *cm_id_priv; + struct cm_work *work; ++ int ret; + + cm_id_priv = container_of(cm_id, struct cm_id_private, id); + spin_lock_irq(&cm_id_priv->lock); +@@ -1135,7 +1146,14 @@ static void cm_destroy_id(struct ib_cm_id *cm_id, int err) + + xa_erase(&cm.local_id_table, cm_local_id(cm_id->local_id)); + cm_deref_id(cm_id_priv); +- wait_for_completion(&cm_id_priv->comp); ++ do { ++ ret = wait_for_completion_timeout(&cm_id_priv->comp, ++ msecs_to_jiffies( ++ CM_DESTROY_ID_WAIT_TIMEOUT)); ++ if (!ret) /* timeout happened */ ++ cm_destroy_id_wait_timeout(cm_id); ++ } while (!ret); ++ + while ((work = cm_dequeue_work(cm_id_priv)) != NULL) + cm_free_work(work); + +diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c +index c11af4441cf25..9206253422016 100644 +--- a/drivers/input/joystick/xpad.c ++++ b/drivers/input/joystick/xpad.c +@@ -366,6 +366,8 @@ static const struct xpad_device { + { 0x24c6, 0x5d04, "Razer Sabertooth", 0, XTYPE_XBOX360 }, + { 0x24c6, 0xfafe, "Rock Candy Gamepad for Xbox 360", 0, XTYPE_XBOX360 }, + { 0x2563, 0x058d, "OneXPlayer Gamepad", 0, XTYPE_XBOX360 }, ++ { 0x294b, 0x3303, "Snakebyte GAMEPAD BASE X", 0, XTYPE_XBOXONE }, ++ { 0x294b, 0x3404, "Snakebyte GAMEPAD RGB X", 0, XTYPE_XBOXONE }, + { 0x2dc8, 0x2000, "8BitDo Pro 2 Wired Controller fox Xbox", 0, XTYPE_XBOXONE }, + { 0x2dc8, 0x3106, "8BitDo Pro 2 Wired Controller", 0, XTYPE_XBOX360 }, + { 0x31e3, 0x1100, "Wooting One", 0, XTYPE_XBOX360 }, +@@ -507,6 +509,7 @@ static const struct usb_device_id xpad_table[] = { + XPAD_XBOXONE_VENDOR(0x24c6), /* PowerA controllers */ + XPAD_XBOX360_VENDOR(0x2563), /* OneXPlayer Gamepad */ + XPAD_XBOX360_VENDOR(0x260d), /* Dareu H101 */ ++ XPAD_XBOXONE_VENDOR(0x294b), /* Snakebyte */ + XPAD_XBOX360_VENDOR(0x2c22), /* Qanba Controllers */ + XPAD_XBOX360_VENDOR(0x2dc8), /* 8BitDo Pro 2 Wired Controller */ + XPAD_XBOXONE_VENDOR(0x2dc8), /* 8BitDo Pro 2 Wired Controller for Xbox */ +diff --git a/drivers/input/rmi4/rmi_driver.c b/drivers/input/rmi4/rmi_driver.c +index 258d5fe3d395c..aa32371f04af6 100644 +--- a/drivers/input/rmi4/rmi_driver.c ++++ b/drivers/input/rmi4/rmi_driver.c +@@ -1196,7 +1196,11 @@ static int rmi_driver_probe(struct device *dev) + } + rmi_driver_set_input_params(rmi_dev, data->input); + data->input->phys = devm_kasprintf(dev, GFP_KERNEL, +- "%s/input0", dev_name(dev)); ++ "%s/input0", dev_name(dev)); ++ if (!data->input->phys) { ++ retval = -ENOMEM; ++ goto err; ++ } + } + + retval = rmi_init_functions(data); +diff --git a/drivers/input/touchscreen/imagis.c b/drivers/input/touchscreen/imagis.c +index 07111ca244556..55ecebe981445 100644 +--- a/drivers/input/touchscreen/imagis.c ++++ b/drivers/input/touchscreen/imagis.c +@@ -1,5 +1,6 @@ + // SPDX-License-Identifier: GPL-2.0-only + ++#include <linux/bitfield.h> + #include <linux/bits.h> + #include <linux/delay.h> + #include <linux/i2c.h> +@@ -23,12 +24,9 @@ + #define IST3038C_I2C_RETRY_COUNT 3 + #define IST3038C_MAX_FINGER_NUM 10 + #define IST3038C_X_MASK GENMASK(23, 12) +-#define IST3038C_X_SHIFT 12 + #define IST3038C_Y_MASK GENMASK(11, 0) + #define IST3038C_AREA_MASK GENMASK(27, 24) +-#define IST3038C_AREA_SHIFT 24 + #define IST3038C_FINGER_COUNT_MASK GENMASK(15, 12) +-#define IST3038C_FINGER_COUNT_SHIFT 12 + #define IST3038C_FINGER_STATUS_MASK GENMASK(9, 0) + + struct imagis_ts { +@@ -92,8 +90,7 @@ static irqreturn_t imagis_interrupt(int irq, void *dev_id) + goto out; + } + +- finger_count = (intr_message & IST3038C_FINGER_COUNT_MASK) >> +- IST3038C_FINGER_COUNT_SHIFT; ++ finger_count = FIELD_GET(IST3038C_FINGER_COUNT_MASK, intr_message); + if (finger_count > IST3038C_MAX_FINGER_NUM) { + dev_err(&ts->client->dev, + "finger count %d is more than maximum supported\n", +@@ -101,7 +98,7 @@ static irqreturn_t imagis_interrupt(int irq, void *dev_id) + goto out; + } + +- finger_pressed = intr_message & IST3038C_FINGER_STATUS_MASK; ++ finger_pressed = FIELD_GET(IST3038C_FINGER_STATUS_MASK, intr_message); + + for (i = 0; i < finger_count; i++) { + error = imagis_i2c_read_reg(ts, +@@ -118,12 +115,11 @@ static irqreturn_t imagis_interrupt(int irq, void *dev_id) + input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, + finger_pressed & BIT(i)); + touchscreen_report_pos(ts->input_dev, &ts->prop, +- (finger_status & IST3038C_X_MASK) >> +- IST3038C_X_SHIFT, +- finger_status & IST3038C_Y_MASK, 1); ++ FIELD_GET(IST3038C_X_MASK, finger_status), ++ FIELD_GET(IST3038C_Y_MASK, finger_status), ++ true); + input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, +- (finger_status & IST3038C_AREA_MASK) >> +- IST3038C_AREA_SHIFT); ++ FIELD_GET(IST3038C_AREA_MASK, finger_status)); + } + + input_mt_sync_frame(ts->input_dev); +@@ -210,7 +206,7 @@ static int imagis_init_input_dev(struct imagis_ts *ts) + + input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X); + input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y); +- input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0); ++ input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 16, 0, 0); + + touchscreen_parse_properties(input_dev, true, &ts->prop); + if (!ts->prop.max_x || !ts->prop.max_y) { +diff --git a/drivers/media/pci/sta2x11/sta2x11_vip.c b/drivers/media/pci/sta2x11/sta2x11_vip.c +index e4cf9d63e926d..364ce9e570182 100644 +--- a/drivers/media/pci/sta2x11/sta2x11_vip.c ++++ b/drivers/media/pci/sta2x11/sta2x11_vip.c +@@ -757,7 +757,7 @@ static const struct video_device video_dev_template = { + /** + * vip_irq - interrupt routine + * @irq: Number of interrupt ( not used, correct number is assumed ) +- * @vip: local data structure containing all information ++ * @data: local data structure containing all information + * + * check for both frame interrupts set ( top and bottom ). + * check FIFO overflow, but limit number of log messages after open. +@@ -767,8 +767,9 @@ static const struct video_device video_dev_template = { + * + * IRQ_HANDLED, interrupt done. + */ +-static irqreturn_t vip_irq(int irq, struct sta2x11_vip *vip) ++static irqreturn_t vip_irq(int irq, void *data) + { ++ struct sta2x11_vip *vip = data; + unsigned int status; + + status = reg_read(vip, DVP_ITS); +@@ -1053,9 +1054,7 @@ static int sta2x11_vip_init_one(struct pci_dev *pdev, + + spin_lock_init(&vip->slock); + +- ret = request_irq(pdev->irq, +- (irq_handler_t) vip_irq, +- IRQF_SHARED, KBUILD_MODNAME, vip); ++ ret = request_irq(pdev->irq, vip_irq, IRQF_SHARED, KBUILD_MODNAME, vip); + if (ret) { + dev_err(&pdev->dev, "request_irq failed\n"); + ret = -ENODEV; +diff --git a/drivers/media/platform/mediatek/vcodec/common/mtk_vcodec_fw_vpu.c b/drivers/media/platform/mediatek/vcodec/common/mtk_vcodec_fw_vpu.c +index 0849ffb0dcd45..42ce58c41e4f4 100644 +--- a/drivers/media/platform/mediatek/vcodec/common/mtk_vcodec_fw_vpu.c ++++ b/drivers/media/platform/mediatek/vcodec/common/mtk_vcodec_fw_vpu.c +@@ -50,12 +50,12 @@ static void mtk_vcodec_vpu_reset_dec_handler(void *priv) + + dev_err(&dev->plat_dev->dev, "Watchdog timeout!!"); + +- mutex_lock(&dev->dev_mutex); ++ mutex_lock(&dev->dev_ctx_lock); + list_for_each_entry(ctx, &dev->ctx_list, list) { + ctx->state = MTK_STATE_ABORT; + mtk_v4l2_vdec_dbg(0, ctx, "[%d] Change to state MTK_STATE_ABORT", ctx->id); + } +- mutex_unlock(&dev->dev_mutex); ++ mutex_unlock(&dev->dev_ctx_lock); + } + + static void mtk_vcodec_vpu_reset_enc_handler(void *priv) +@@ -65,12 +65,12 @@ static void mtk_vcodec_vpu_reset_enc_handler(void *priv) + + dev_err(&dev->plat_dev->dev, "Watchdog timeout!!"); + +- mutex_lock(&dev->dev_mutex); ++ mutex_lock(&dev->dev_ctx_lock); + list_for_each_entry(ctx, &dev->ctx_list, list) { + ctx->state = MTK_STATE_ABORT; + mtk_v4l2_vdec_dbg(0, ctx, "[%d] Change to state MTK_STATE_ABORT", ctx->id); + } +- mutex_unlock(&dev->dev_mutex); ++ mutex_unlock(&dev->dev_ctx_lock); + } + + static const struct mtk_vcodec_fw_ops mtk_vcodec_vpu_msg = { +diff --git a/drivers/media/platform/mediatek/vcodec/decoder/mtk_vcodec_dec_drv.c b/drivers/media/platform/mediatek/vcodec/decoder/mtk_vcodec_dec_drv.c +index 0a89ce452ac32..20c0b1acf6186 100644 +--- a/drivers/media/platform/mediatek/vcodec/decoder/mtk_vcodec_dec_drv.c ++++ b/drivers/media/platform/mediatek/vcodec/decoder/mtk_vcodec_dec_drv.c +@@ -268,7 +268,9 @@ static int fops_vcodec_open(struct file *file) + + ctx->dev->vdec_pdata->init_vdec_params(ctx); + ++ mutex_lock(&dev->dev_ctx_lock); + list_add(&ctx->list, &dev->ctx_list); ++ mutex_unlock(&dev->dev_ctx_lock); + mtk_vcodec_dbgfs_create(ctx); + + mutex_unlock(&dev->dev_mutex); +@@ -311,7 +313,9 @@ static int fops_vcodec_release(struct file *file) + v4l2_ctrl_handler_free(&ctx->ctrl_hdl); + + mtk_vcodec_dbgfs_remove(dev, ctx->id); ++ mutex_lock(&dev->dev_ctx_lock); + list_del_init(&ctx->list); ++ mutex_unlock(&dev->dev_ctx_lock); + kfree(ctx); + mutex_unlock(&dev->dev_mutex); + return 0; +@@ -378,6 +382,7 @@ static int mtk_vcodec_probe(struct platform_device *pdev) + for (i = 0; i < MTK_VDEC_HW_MAX; i++) + mutex_init(&dev->dec_mutex[i]); + mutex_init(&dev->dev_mutex); ++ mutex_init(&dev->dev_ctx_lock); + spin_lock_init(&dev->irqlock); + + snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name), "%s", +diff --git a/drivers/media/platform/mediatek/vcodec/decoder/mtk_vcodec_dec_drv.h b/drivers/media/platform/mediatek/vcodec/decoder/mtk_vcodec_dec_drv.h +index 7e36b2c69b7d1..b3a59af7c8ac5 100644 +--- a/drivers/media/platform/mediatek/vcodec/decoder/mtk_vcodec_dec_drv.h ++++ b/drivers/media/platform/mediatek/vcodec/decoder/mtk_vcodec_dec_drv.h +@@ -231,6 +231,7 @@ struct mtk_vcodec_dec_ctx { + * + * @dec_mutex: decoder hardware lock + * @dev_mutex: video_device lock ++ * @dev_ctx_lock: the lock of context list + * @decode_workqueue: decode work queue + * + * @irqlock: protect data access by irq handler and work thread +@@ -270,6 +271,7 @@ struct mtk_vcodec_dec_dev { + /* decoder hardware mutex lock */ + struct mutex dec_mutex[MTK_VDEC_HW_MAX]; + struct mutex dev_mutex; ++ struct mutex dev_ctx_lock; + struct workqueue_struct *decode_workqueue; + + spinlock_t irqlock; +diff --git a/drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_hevc_req_multi_if.c b/drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_hevc_req_multi_if.c +index 06ed47df693bf..21836dd6ef85a 100644 +--- a/drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_hevc_req_multi_if.c ++++ b/drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_hevc_req_multi_if.c +@@ -869,7 +869,6 @@ static int vdec_hevc_slice_init(struct mtk_vcodec_dec_ctx *ctx) + inst->vpu.codec_type = ctx->current_codec; + inst->vpu.capture_type = ctx->capture_fourcc; + +- ctx->drv_handle = inst; + err = vpu_dec_init(&inst->vpu); + if (err) { + mtk_vdec_err(ctx, "vdec_hevc init err=%d", err); +@@ -898,6 +897,7 @@ static int vdec_hevc_slice_init(struct mtk_vcodec_dec_ctx *ctx) + mtk_vdec_debug(ctx, "lat hevc instance >> %p, codec_type = 0x%x", + inst, inst->vpu.codec_type); + ++ ctx->drv_handle = inst; + return 0; + error_free_inst: + kfree(inst); +diff --git a/drivers/media/platform/mediatek/vcodec/decoder/vdec_vpu_if.c b/drivers/media/platform/mediatek/vcodec/decoder/vdec_vpu_if.c +index 82e57ae983d55..da6be556727bb 100644 +--- a/drivers/media/platform/mediatek/vcodec/decoder/vdec_vpu_if.c ++++ b/drivers/media/platform/mediatek/vcodec/decoder/vdec_vpu_if.c +@@ -77,12 +77,14 @@ static bool vpu_dec_check_ap_inst(struct mtk_vcodec_dec_dev *dec_dev, struct vde + struct mtk_vcodec_dec_ctx *ctx; + int ret = false; + ++ mutex_lock(&dec_dev->dev_ctx_lock); + list_for_each_entry(ctx, &dec_dev->ctx_list, list) { + if (!IS_ERR_OR_NULL(ctx) && ctx->vpu_inst == vpu) { + ret = true; + break; + } + } ++ mutex_unlock(&dec_dev->dev_ctx_lock); + + return ret; + } +diff --git a/drivers/media/platform/mediatek/vcodec/encoder/mtk_vcodec_enc_drv.c b/drivers/media/platform/mediatek/vcodec/encoder/mtk_vcodec_enc_drv.c +index 6319f24bc714b..3cb8a16222220 100644 +--- a/drivers/media/platform/mediatek/vcodec/encoder/mtk_vcodec_enc_drv.c ++++ b/drivers/media/platform/mediatek/vcodec/encoder/mtk_vcodec_enc_drv.c +@@ -177,7 +177,9 @@ static int fops_vcodec_open(struct file *file) + mtk_v4l2_venc_dbg(2, ctx, "Create instance [%d]@%p m2m_ctx=%p ", + ctx->id, ctx, ctx->m2m_ctx); + ++ mutex_lock(&dev->dev_ctx_lock); + list_add(&ctx->list, &dev->ctx_list); ++ mutex_unlock(&dev->dev_ctx_lock); + + mutex_unlock(&dev->dev_mutex); + mtk_v4l2_venc_dbg(0, ctx, "%s encoder [%d]", dev_name(&dev->plat_dev->dev), +@@ -212,7 +214,9 @@ static int fops_vcodec_release(struct file *file) + v4l2_fh_exit(&ctx->fh); + v4l2_ctrl_handler_free(&ctx->ctrl_hdl); + ++ mutex_lock(&dev->dev_ctx_lock); + list_del_init(&ctx->list); ++ mutex_unlock(&dev->dev_ctx_lock); + kfree(ctx); + mutex_unlock(&dev->dev_mutex); + return 0; +@@ -294,6 +298,7 @@ static int mtk_vcodec_probe(struct platform_device *pdev) + + mutex_init(&dev->enc_mutex); + mutex_init(&dev->dev_mutex); ++ mutex_init(&dev->dev_ctx_lock); + spin_lock_init(&dev->irqlock); + + snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name), "%s", +diff --git a/drivers/media/platform/mediatek/vcodec/encoder/mtk_vcodec_enc_drv.h b/drivers/media/platform/mediatek/vcodec/encoder/mtk_vcodec_enc_drv.h +index a042f607ed8d1..0bd85d0fb379a 100644 +--- a/drivers/media/platform/mediatek/vcodec/encoder/mtk_vcodec_enc_drv.h ++++ b/drivers/media/platform/mediatek/vcodec/encoder/mtk_vcodec_enc_drv.h +@@ -178,6 +178,7 @@ struct mtk_vcodec_enc_ctx { + * + * @enc_mutex: encoder hardware lock. + * @dev_mutex: video_device lock ++ * @dev_ctx_lock: the lock of context list + * @encode_workqueue: encode work queue + * + * @enc_irq: h264 encoder irq resource +@@ -205,6 +206,7 @@ struct mtk_vcodec_enc_dev { + /* encoder hardware mutex lock */ + struct mutex enc_mutex; + struct mutex dev_mutex; ++ struct mutex dev_ctx_lock; + struct workqueue_struct *encode_workqueue; + + int enc_irq; +diff --git a/drivers/media/platform/mediatek/vcodec/encoder/venc_vpu_if.c b/drivers/media/platform/mediatek/vcodec/encoder/venc_vpu_if.c +index 84ad1cc6ad171..51bb7ee141b9e 100644 +--- a/drivers/media/platform/mediatek/vcodec/encoder/venc_vpu_if.c ++++ b/drivers/media/platform/mediatek/vcodec/encoder/venc_vpu_if.c +@@ -47,12 +47,14 @@ static bool vpu_enc_check_ap_inst(struct mtk_vcodec_enc_dev *enc_dev, struct ven + struct mtk_vcodec_enc_ctx *ctx; + int ret = false; + ++ mutex_lock(&enc_dev->dev_ctx_lock); + list_for_each_entry(ctx, &enc_dev->ctx_list, list) { + if (!IS_ERR_OR_NULL(ctx) && ctx->vpu_inst == vpu) { + ret = true; + break; + } + } ++ mutex_unlock(&enc_dev->dev_ctx_lock); + + return ret; + } +diff --git a/drivers/misc/vmw_vmci/vmci_datagram.c b/drivers/misc/vmw_vmci/vmci_datagram.c +index f50d22882476f..a0ad1f3a69f7e 100644 +--- a/drivers/misc/vmw_vmci/vmci_datagram.c ++++ b/drivers/misc/vmw_vmci/vmci_datagram.c +@@ -234,7 +234,8 @@ static int dg_dispatch_as_host(u32 context_id, struct vmci_datagram *dg) + + dg_info->in_dg_host_queue = true; + dg_info->entry = dst_entry; +- memcpy(&dg_info->msg, dg, dg_size); ++ dg_info->msg = *dg; ++ memcpy(&dg_info->msg_payload, dg + 1, dg->payload_size); + + INIT_WORK(&dg_info->work, dg_delayed_dispatch); + schedule_work(&dg_info->work); +@@ -377,7 +378,8 @@ int vmci_datagram_invoke_guest_handler(struct vmci_datagram *dg) + + dg_info->in_dg_host_queue = false; + dg_info->entry = dst_entry; +- memcpy(&dg_info->msg, dg, VMCI_DG_SIZE(dg)); ++ dg_info->msg = *dg; ++ memcpy(&dg_info->msg_payload, dg + 1, dg->payload_size); + + INIT_WORK(&dg_info->work, dg_delayed_dispatch); + schedule_work(&dg_info->work); +diff --git a/drivers/net/dummy.c b/drivers/net/dummy.c +index c4b1b0aa438ac..5560cf683eb73 100644 +--- a/drivers/net/dummy.c ++++ b/drivers/net/dummy.c +@@ -71,6 +71,7 @@ static int dummy_dev_init(struct net_device *dev) + if (!dev->lstats) + return -ENOMEM; + ++ netdev_lockdep_set_classes(dev); + return 0; + } + +diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c +index e9c1e1bb55806..528441b28c4ef 100644 +--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c ++++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c +@@ -147,10 +147,11 @@ void bnx2x_fill_fw_str(struct bnx2x *bp, char *buf, size_t buf_len) + + phy_fw_ver[0] = '\0'; + bnx2x_get_ext_phy_fw_version(&bp->link_params, +- phy_fw_ver, PHY_FW_VER_LEN); +- strscpy(buf, bp->fw_ver, buf_len); +- snprintf(buf + strlen(bp->fw_ver), 32 - strlen(bp->fw_ver), +- "bc %d.%d.%d%s%s", ++ phy_fw_ver, sizeof(phy_fw_ver)); ++ /* This may become truncated. */ ++ scnprintf(buf, buf_len, ++ "%sbc %d.%d.%d%s%s", ++ bp->fw_ver, + (bp->common.bc_ver & 0xff0000) >> 16, + (bp->common.bc_ver & 0xff00) >> 8, + (bp->common.bc_ver & 0xff), +diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c +index bda3ccc28eca6..f920976c36f0c 100644 +--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c ++++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c +@@ -1132,7 +1132,7 @@ static void bnx2x_get_drvinfo(struct net_device *dev, + } + + memset(version, 0, sizeof(version)); +- bnx2x_fill_fw_str(bp, version, ETHTOOL_FWVERS_LEN); ++ bnx2x_fill_fw_str(bp, version, sizeof(version)); + strlcat(info->fw_version, version, sizeof(info->fw_version)); + + strscpy(info->bus_info, pci_name(bp->pdev), sizeof(info->bus_info)); +diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c +index 02808513ffe45..ea310057fe3af 100644 +--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c ++++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c +@@ -6163,8 +6163,8 @@ static void bnx2x_link_int_ack(struct link_params *params, + + static int bnx2x_null_format_ver(u32 spirom_ver, u8 *str, u16 *len) + { +- str[0] = '\0'; +- (*len)--; ++ if (*len) ++ str[0] = '\0'; + return 0; + } + +@@ -6173,7 +6173,7 @@ static int bnx2x_format_ver(u32 num, u8 *str, u16 *len) + u16 ret; + + if (*len < 10) { +- /* Need more than 10chars for this format */ ++ /* Need more than 10 chars for this format */ + bnx2x_null_format_ver(num, str, len); + return -EINVAL; + } +@@ -6188,8 +6188,8 @@ static int bnx2x_3_seq_format_ver(u32 num, u8 *str, u16 *len) + { + u16 ret; + +- if (*len < 10) { +- /* Need more than 10chars for this format */ ++ if (*len < 9) { ++ /* Need more than 9 chars for this format */ + bnx2x_null_format_ver(num, str, len); + return -EINVAL; + } +@@ -6208,7 +6208,7 @@ int bnx2x_get_ext_phy_fw_version(struct link_params *params, u8 *version, + int status = 0; + u8 *ver_p = version; + u16 remain_len = len; +- if (version == NULL || params == NULL) ++ if (version == NULL || params == NULL || len == 0) + return -EINVAL; + bp = params->bp; + +@@ -11546,7 +11546,7 @@ static int bnx2x_7101_format_ver(u32 spirom_ver, u8 *str, u16 *len) + str[2] = (spirom_ver & 0xFF0000) >> 16; + str[3] = (spirom_ver & 0xFF000000) >> 24; + str[4] = '\0'; +- *len -= 5; ++ *len -= 4; + return 0; + } + +diff --git a/drivers/net/ethernet/intel/ice/ice_virtchnl.c b/drivers/net/ethernet/intel/ice/ice_virtchnl.c +index 3a28210be3c23..d8509e86214ef 100644 +--- a/drivers/net/ethernet/intel/ice/ice_virtchnl.c ++++ b/drivers/net/ethernet/intel/ice/ice_virtchnl.c +@@ -496,7 +496,7 @@ static int ice_vc_get_vf_res_msg(struct ice_vf *vf, u8 *msg) + vfres->rss_lut_size = ICE_LUT_VSI_SIZE; + vfres->max_mtu = ice_vc_get_max_frame_size(vf); + +- vfres->vsi_res[0].vsi_id = vf->lan_vsi_num; ++ vfres->vsi_res[0].vsi_id = ICE_VF_VSI_ID; + vfres->vsi_res[0].vsi_type = VIRTCHNL_VSI_SRIOV; + vfres->vsi_res[0].num_queue_pairs = vsi->num_txq; + ether_addr_copy(vfres->vsi_res[0].default_mac_addr, +@@ -542,12 +542,7 @@ static void ice_vc_reset_vf_msg(struct ice_vf *vf) + */ + bool ice_vc_isvalid_vsi_id(struct ice_vf *vf, u16 vsi_id) + { +- struct ice_pf *pf = vf->pf; +- struct ice_vsi *vsi; +- +- vsi = ice_find_vsi(pf, vsi_id); +- +- return (vsi && (vsi->vf == vf)); ++ return vsi_id == ICE_VF_VSI_ID; + } + + /** +diff --git a/drivers/net/ethernet/intel/ice/ice_virtchnl.h b/drivers/net/ethernet/intel/ice/ice_virtchnl.h +index cd747718de738..a0d03f350dfc7 100644 +--- a/drivers/net/ethernet/intel/ice/ice_virtchnl.h ++++ b/drivers/net/ethernet/intel/ice/ice_virtchnl.h +@@ -19,6 +19,15 @@ + #define ICE_MAX_MACADDR_PER_VF 18 + #define ICE_FLEX_DESC_RXDID_MAX_NUM 64 + ++/* VFs only get a single VSI. For ice hardware, the VF does not need to know ++ * its VSI index. However, the virtchnl interface requires a VSI number, ++ * mainly due to legacy hardware. ++ * ++ * Since the VF doesn't need this information, report a static value to the VF ++ * instead of leaking any information about the PF or hardware setup. ++ */ ++#define ICE_VF_VSI_ID 1 ++ + struct ice_virtchnl_ops { + int (*get_ver_msg)(struct ice_vf *vf, u8 *msg); + int (*get_vf_res_msg)(struct ice_vf *vf, u8 *msg); +diff --git a/drivers/net/ethernet/pensando/ionic/ionic_lif.c b/drivers/net/ethernet/pensando/ionic/ionic_lif.c +index adb0f9b01bb1e..4f05cddc65cb4 100644 +--- a/drivers/net/ethernet/pensando/ionic/ionic_lif.c ++++ b/drivers/net/ethernet/pensando/ionic/ionic_lif.c +@@ -3468,9 +3468,12 @@ static int ionic_lif_adminq_init(struct ionic_lif *lif) + + napi_enable(&qcq->napi); + +- if (qcq->flags & IONIC_QCQ_F_INTR) ++ if (qcq->flags & IONIC_QCQ_F_INTR) { ++ irq_set_affinity_hint(qcq->intr.vector, ++ &qcq->intr.affinity_mask); + ionic_intr_mask(idev->intr_ctrl, qcq->intr.index, + IONIC_INTR_MASK_CLEAR); ++ } + + qcq->flags |= IONIC_QCQ_F_INITED; + +diff --git a/drivers/net/ethernet/stmicro/stmmac/Kconfig b/drivers/net/ethernet/stmicro/stmmac/Kconfig +index 25f2d42de406d..92d7d5a00b84c 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/Kconfig ++++ b/drivers/net/ethernet/stmicro/stmmac/Kconfig +@@ -165,9 +165,9 @@ config DWMAC_STARFIVE + help + Support for ethernet controllers on StarFive RISC-V SoCs + +- This selects the StarFive platform specific glue layer support for +- the stmmac device driver. This driver is used for StarFive JH7110 +- ethernet controller. ++ This selects the StarFive platform specific glue layer support ++ for the stmmac device driver. This driver is used for the ++ StarFive JH7100 and JH7110 ethernet controllers. + + config DWMAC_STI + tristate "STi GMAC support" +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-starfive.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-starfive.c +index 9289bb87c3e3a..0c713257193de 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-starfive.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-starfive.c +@@ -15,13 +15,20 @@ + + #include "stmmac_platform.h" + +-#define STARFIVE_DWMAC_PHY_INFT_RGMII 0x1 +-#define STARFIVE_DWMAC_PHY_INFT_RMII 0x4 +-#define STARFIVE_DWMAC_PHY_INFT_FIELD 0x7U ++#define STARFIVE_DWMAC_PHY_INFT_RGMII 0x1 ++#define STARFIVE_DWMAC_PHY_INFT_RMII 0x4 ++#define STARFIVE_DWMAC_PHY_INFT_FIELD 0x7U ++ ++#define JH7100_SYSMAIN_REGISTER49_DLYCHAIN 0xc8 ++ ++struct starfive_dwmac_data { ++ unsigned int gtxclk_dlychain; ++}; + + struct starfive_dwmac { + struct device *dev; + struct clk *clk_tx; ++ const struct starfive_dwmac_data *data; + }; + + static void starfive_dwmac_fix_mac_speed(void *priv, unsigned int speed, unsigned int mode) +@@ -67,6 +74,8 @@ static int starfive_dwmac_set_mode(struct plat_stmmacenet_data *plat_dat) + + case PHY_INTERFACE_MODE_RGMII: + case PHY_INTERFACE_MODE_RGMII_ID: ++ case PHY_INTERFACE_MODE_RGMII_RXID: ++ case PHY_INTERFACE_MODE_RGMII_TXID: + mode = STARFIVE_DWMAC_PHY_INFT_RGMII; + break; + +@@ -89,6 +98,14 @@ static int starfive_dwmac_set_mode(struct plat_stmmacenet_data *plat_dat) + if (err) + return dev_err_probe(dwmac->dev, err, "error setting phy mode\n"); + ++ if (dwmac->data) { ++ err = regmap_write(regmap, JH7100_SYSMAIN_REGISTER49_DLYCHAIN, ++ dwmac->data->gtxclk_dlychain); ++ if (err) ++ return dev_err_probe(dwmac->dev, err, ++ "error selecting gtxclk delay chain\n"); ++ } ++ + return 0; + } + +@@ -114,6 +131,8 @@ static int starfive_dwmac_probe(struct platform_device *pdev) + if (!dwmac) + return -ENOMEM; + ++ dwmac->data = device_get_match_data(&pdev->dev); ++ + dwmac->clk_tx = devm_clk_get_enabled(&pdev->dev, "tx"); + if (IS_ERR(dwmac->clk_tx)) + return dev_err_probe(&pdev->dev, PTR_ERR(dwmac->clk_tx), +@@ -150,8 +169,13 @@ static int starfive_dwmac_probe(struct platform_device *pdev) + return 0; + } + ++static const struct starfive_dwmac_data jh7100_data = { ++ .gtxclk_dlychain = 4, ++}; ++ + static const struct of_device_id starfive_dwmac_match[] = { +- { .compatible = "starfive,jh7110-dwmac" }, ++ { .compatible = "starfive,jh7100-dwmac", .data = &jh7100_data }, ++ { .compatible = "starfive,jh7110-dwmac" }, + { /* sentinel */ } + }; + MODULE_DEVICE_TABLE(of, starfive_dwmac_match); +diff --git a/drivers/net/geneve.c b/drivers/net/geneve.c +index 9566fda8b2e2e..0204ac92b05ab 100644 +--- a/drivers/net/geneve.c ++++ b/drivers/net/geneve.c +@@ -349,6 +349,7 @@ static int geneve_init(struct net_device *dev) + gro_cells_destroy(&geneve->gro_cells); + return err; + } ++ netdev_lockdep_set_classes(dev); + return 0; + } + +diff --git a/drivers/net/loopback.c b/drivers/net/loopback.c +index f6d53e63ef4ec..f6eab66c26608 100644 +--- a/drivers/net/loopback.c ++++ b/drivers/net/loopback.c +@@ -144,6 +144,7 @@ static int loopback_dev_init(struct net_device *dev) + dev->lstats = netdev_alloc_pcpu_stats(struct pcpu_lstats); + if (!dev->lstats) + return -ENOMEM; ++ netdev_lockdep_set_classes(dev); + return 0; + } + +diff --git a/drivers/net/pcs/pcs-xpcs.c b/drivers/net/pcs/pcs-xpcs.c +index 4dbc21f604f20..f0f41e86a4fb3 100644 +--- a/drivers/net/pcs/pcs-xpcs.c ++++ b/drivers/net/pcs/pcs-xpcs.c +@@ -293,7 +293,7 @@ static int xpcs_soft_reset(struct dw_xpcs *xpcs, + dev = MDIO_MMD_VEND2; + break; + default: +- return -1; ++ return -EINVAL; + } + + ret = xpcs_write(xpcs, dev, MDIO_CTRL1, MDIO_CTRL1_RESET); +@@ -891,7 +891,7 @@ int xpcs_do_config(struct dw_xpcs *xpcs, phy_interface_t interface, + return ret; + break; + default: +- return -1; ++ return -EINVAL; + } + + if (compat->pma_config) { +diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c +index 813b753e21dec..c895cd178e6a1 100644 +--- a/drivers/net/phy/phy_device.c ++++ b/drivers/net/phy/phy_device.c +@@ -1411,6 +1411,11 @@ int phy_sfp_probe(struct phy_device *phydev, + } + EXPORT_SYMBOL(phy_sfp_probe); + ++static bool phy_drv_supports_irq(struct phy_driver *phydrv) ++{ ++ return phydrv->config_intr && phydrv->handle_interrupt; ++} ++ + /** + * phy_attach_direct - attach a network device to a given PHY device pointer + * @dev: network device to attach +@@ -1525,6 +1530,9 @@ int phy_attach_direct(struct net_device *dev, struct phy_device *phydev, + if (phydev->dev_flags & PHY_F_NO_IRQ) + phydev->irq = PHY_POLL; + ++ if (!phy_drv_supports_irq(phydev->drv) && phy_interrupt_is_valid(phydev)) ++ phydev->irq = PHY_POLL; ++ + /* Port is set to PORT_TP by default and the actual PHY driver will set + * it to different value depending on the PHY configuration. If we have + * the generic PHY driver we can't figure it out, thus set the old +@@ -2987,11 +2995,6 @@ s32 phy_get_internal_delay(struct phy_device *phydev, struct device *dev, + } + EXPORT_SYMBOL(phy_get_internal_delay); + +-static bool phy_drv_supports_irq(struct phy_driver *phydrv) +-{ +- return phydrv->config_intr && phydrv->handle_interrupt; +-} +- + static int phy_led_set_brightness(struct led_classdev *led_cdev, + enum led_brightness value) + { +diff --git a/drivers/net/veth.c b/drivers/net/veth.c +index 5cdb77e861c0e..7767b6ff5a155 100644 +--- a/drivers/net/veth.c ++++ b/drivers/net/veth.c +@@ -1475,6 +1475,7 @@ static void veth_free_queues(struct net_device *dev) + + static int veth_dev_init(struct net_device *dev) + { ++ netdev_lockdep_set_classes(dev); + return veth_alloc_queues(dev); + } + +diff --git a/drivers/net/vxlan/vxlan_core.c b/drivers/net/vxlan/vxlan_core.c +index 5b5597073b004..99ede13124194 100644 +--- a/drivers/net/vxlan/vxlan_core.c ++++ b/drivers/net/vxlan/vxlan_core.c +@@ -2960,6 +2960,7 @@ static int vxlan_init(struct net_device *dev) + if (err) + goto err_gro_cells_destroy; + ++ netdev_lockdep_set_classes(dev); + return 0; + + err_gro_cells_destroy: +diff --git a/drivers/net/wireless/ath/ath11k/mhi.c b/drivers/net/wireless/ath/ath11k/mhi.c +index 3ac689f1def40..76de891d6c0f1 100644 +--- a/drivers/net/wireless/ath/ath11k/mhi.c ++++ b/drivers/net/wireless/ath/ath11k/mhi.c +@@ -105,7 +105,7 @@ static struct mhi_controller_config ath11k_mhi_config_qca6390 = { + .max_channels = 128, + .timeout_ms = 2000, + .use_bounce_buf = false, +- .buf_len = 0, ++ .buf_len = 8192, + .num_channels = ARRAY_SIZE(ath11k_mhi_channels_qca6390), + .ch_cfg = ath11k_mhi_channels_qca6390, + .num_events = ARRAY_SIZE(ath11k_mhi_events_qca6390), +diff --git a/drivers/net/wireless/ath/ath9k/antenna.c b/drivers/net/wireless/ath/ath9k/antenna.c +index 988222cea9dfe..acc84e6711b0e 100644 +--- a/drivers/net/wireless/ath/ath9k/antenna.c ++++ b/drivers/net/wireless/ath/ath9k/antenna.c +@@ -643,7 +643,7 @@ static void ath_ant_try_scan(struct ath_ant_comb *antcomb, + conf->main_lna_conf = ATH_ANT_DIV_COMB_LNA1; + conf->alt_lna_conf = ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2; + } else if (antcomb->rssi_sub > +- antcomb->rssi_lna1) { ++ antcomb->rssi_lna2) { + /* set to A-B */ + conf->main_lna_conf = ATH_ANT_DIV_COMB_LNA1; + conf->alt_lna_conf = ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2; +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/dmi.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/dmi.c +index 86ff174936a9a..c3a602197662b 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/dmi.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/dmi.c +@@ -82,6 +82,15 @@ static const struct dmi_system_id dmi_platform_data[] = { + }, + .driver_data = (void *)&acepc_t8_data, + }, ++ { ++ /* ACEPC W5 Pro Cherry Trail Z8350 HDMI stick, same wifi as the T8 */ ++ .matches = { ++ DMI_MATCH(DMI_BOARD_NAME, "T3 MRD"), ++ DMI_MATCH(DMI_CHASSIS_TYPE, "3"), ++ DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."), ++ }, ++ .driver_data = (void *)&acepc_t8_data, ++ }, + { + /* Chuwi Hi8 Pro with D2D3_Hi8Pro.233 BIOS */ + .matches = { +diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/ax210.c b/drivers/net/wireless/intel/iwlwifi/cfg/ax210.c +index 8d5f9dce71d58..dc9667586de9e 100644 +--- a/drivers/net/wireless/intel/iwlwifi/cfg/ax210.c ++++ b/drivers/net/wireless/intel/iwlwifi/cfg/ax210.c +@@ -299,3 +299,9 @@ MODULE_FIRMWARE(IWL_MA_B_HR_B_FW_MODULE_FIRMWARE(IWL_AX210_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL_MA_B_GF_A_FW_MODULE_FIRMWARE(IWL_AX210_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL_MA_B_GF4_A_FW_MODULE_FIRMWARE(IWL_AX210_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL_MA_B_MR_A_FW_MODULE_FIRMWARE(IWL_AX210_UCODE_API_MAX)); ++ ++MODULE_FIRMWARE("iwlwifi-so-a0-gf-a0.pnvm"); ++MODULE_FIRMWARE("iwlwifi-so-a0-gf4-a0.pnvm"); ++MODULE_FIRMWARE("iwlwifi-ty-a0-gf-a0.pnvm"); ++MODULE_FIRMWARE("iwlwifi-ma-b0-gf-a0.pnvm"); ++MODULE_FIRMWARE("iwlwifi-ma-b0-gf4-a0.pnvm"); +diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/bz.c b/drivers/net/wireless/intel/iwlwifi/cfg/bz.c +index 42e765fe3cfe1..cc71b513adf98 100644 +--- a/drivers/net/wireless/intel/iwlwifi/cfg/bz.c ++++ b/drivers/net/wireless/intel/iwlwifi/cfg/bz.c +@@ -179,3 +179,5 @@ MODULE_FIRMWARE(IWL_BZ_A_FM_C_MODULE_FIRMWARE(IWL_BZ_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL_BZ_A_FM4_B_MODULE_FIRMWARE(IWL_BZ_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL_GL_B_FM_B_MODULE_FIRMWARE(IWL_BZ_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL_GL_C_FM_C_MODULE_FIRMWARE(IWL_BZ_UCODE_API_MAX)); ++ ++MODULE_FIRMWARE("iwlwifi-gl-c0-fm-c0.pnvm"); +diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c +index bc83d2ba55c67..dea4d6478b4f4 100644 +--- a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c ++++ b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c +@@ -502,6 +502,7 @@ static const struct pci_device_id iwl_hw_card_ids[] = { + + /* Bz devices */ + {IWL_PCI_DEVICE(0x2727, PCI_ANY_ID, iwl_bz_trans_cfg)}, ++ {IWL_PCI_DEVICE(0x272D, PCI_ANY_ID, iwl_bz_trans_cfg)}, + {IWL_PCI_DEVICE(0x272b, PCI_ANY_ID, iwl_bz_trans_cfg)}, + {IWL_PCI_DEVICE(0xA840, PCI_ANY_ID, iwl_bz_trans_cfg)}, + {IWL_PCI_DEVICE(0x7740, PCI_ANY_ID, iwl_bz_trans_cfg)}, +diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/mmio.c b/drivers/net/wireless/mediatek/mt76/mt7915/mmio.c +index f4ad7219f94f4..a306a42777d78 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7915/mmio.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7915/mmio.c +@@ -490,6 +490,11 @@ static u32 __mt7915_reg_addr(struct mt7915_dev *dev, u32 addr) + return dev->reg.map[i].maps + ofs; + } + ++ return 0; ++} ++ ++static u32 __mt7915_reg_remap_addr(struct mt7915_dev *dev, u32 addr) ++{ + if ((addr >= MT_INFRA_BASE && addr < MT_WFSYS0_PHY_START) || + (addr >= MT_WFSYS0_PHY_START && addr < MT_WFSYS1_PHY_START) || + (addr >= MT_WFSYS1_PHY_START && addr <= MT_WFSYS1_PHY_END)) +@@ -514,15 +519,30 @@ void mt7915_memcpy_fromio(struct mt7915_dev *dev, void *buf, u32 offset, + { + u32 addr = __mt7915_reg_addr(dev, offset); + +- memcpy_fromio(buf, dev->mt76.mmio.regs + addr, len); ++ if (addr) { ++ memcpy_fromio(buf, dev->mt76.mmio.regs + addr, len); ++ return; ++ } ++ ++ spin_lock_bh(&dev->reg_lock); ++ memcpy_fromio(buf, dev->mt76.mmio.regs + ++ __mt7915_reg_remap_addr(dev, offset), len); ++ spin_unlock_bh(&dev->reg_lock); + } + + static u32 mt7915_rr(struct mt76_dev *mdev, u32 offset) + { + struct mt7915_dev *dev = container_of(mdev, struct mt7915_dev, mt76); +- u32 addr = __mt7915_reg_addr(dev, offset); ++ u32 addr = __mt7915_reg_addr(dev, offset), val; + +- return dev->bus_ops->rr(mdev, addr); ++ if (addr) ++ return dev->bus_ops->rr(mdev, addr); ++ ++ spin_lock_bh(&dev->reg_lock); ++ val = dev->bus_ops->rr(mdev, __mt7915_reg_remap_addr(dev, offset)); ++ spin_unlock_bh(&dev->reg_lock); ++ ++ return val; + } + + static void mt7915_wr(struct mt76_dev *mdev, u32 offset, u32 val) +@@ -530,7 +550,14 @@ static void mt7915_wr(struct mt76_dev *mdev, u32 offset, u32 val) + struct mt7915_dev *dev = container_of(mdev, struct mt7915_dev, mt76); + u32 addr = __mt7915_reg_addr(dev, offset); + +- dev->bus_ops->wr(mdev, addr, val); ++ if (addr) { ++ dev->bus_ops->wr(mdev, addr, val); ++ return; ++ } ++ ++ spin_lock_bh(&dev->reg_lock); ++ dev->bus_ops->wr(mdev, __mt7915_reg_remap_addr(dev, offset), val); ++ spin_unlock_bh(&dev->reg_lock); + } + + static u32 mt7915_rmw(struct mt76_dev *mdev, u32 offset, u32 mask, u32 val) +@@ -538,7 +565,14 @@ static u32 mt7915_rmw(struct mt76_dev *mdev, u32 offset, u32 mask, u32 val) + struct mt7915_dev *dev = container_of(mdev, struct mt7915_dev, mt76); + u32 addr = __mt7915_reg_addr(dev, offset); + +- return dev->bus_ops->rmw(mdev, addr, mask, val); ++ if (addr) ++ return dev->bus_ops->rmw(mdev, addr, mask, val); ++ ++ spin_lock_bh(&dev->reg_lock); ++ val = dev->bus_ops->rmw(mdev, __mt7915_reg_remap_addr(dev, offset), mask, val); ++ spin_unlock_bh(&dev->reg_lock); ++ ++ return val; + } + + #ifdef CONFIG_NET_MEDIATEK_SOC_WED +@@ -813,6 +847,7 @@ static int mt7915_mmio_init(struct mt76_dev *mdev, + + dev = container_of(mdev, struct mt7915_dev, mt76); + mt76_mmio_init(&dev->mt76, mem_base); ++ spin_lock_init(&dev->reg_lock); + + switch (device_id) { + case 0x7915: +diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h b/drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h +index 21984e9723709..e192211d4b23e 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h ++++ b/drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h +@@ -287,6 +287,7 @@ struct mt7915_dev { + + struct list_head sta_rc_list; + struct list_head twt_list; ++ spinlock_t reg_lock; + + u32 hw_pattern; + +diff --git a/drivers/net/wireless/mediatek/mt76/mt7996/mac.c b/drivers/net/wireless/mediatek/mt76/mt7996/mac.c +index b0d0ae5080e82..73d46ec1181ae 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7996/mac.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7996/mac.c +@@ -757,6 +757,9 @@ mt7996_mac_write_txwi_8023(struct mt7996_dev *dev, __le32 *txwi, + FIELD_PREP(MT_TXD2_SUB_TYPE, fc_stype); + + txwi[2] |= cpu_to_le32(val); ++ ++ if (wcid->amsdu) ++ txwi[3] |= cpu_to_le32(MT_TXD3_HW_AMSDU); + } + + static void +@@ -887,8 +890,6 @@ void mt7996_mac_write_txwi(struct mt7996_dev *dev, __le32 *txwi, + val |= MT_TXD3_PROTECT_FRAME; + if (info->flags & IEEE80211_TX_CTL_NO_ACK) + val |= MT_TXD3_NO_ACK; +- if (wcid->amsdu) +- val |= MT_TXD3_HW_AMSDU; + + txwi[3] = cpu_to_le32(val); + txwi[4] = 0; +diff --git a/drivers/net/wireless/mediatek/mt76/mt7996/mmio.c b/drivers/net/wireless/mediatek/mt76/mt7996/mmio.c +index 3a591a7b47ae6..e75becadc2e54 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7996/mmio.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7996/mmio.c +@@ -82,7 +82,6 @@ static u32 mt7996_reg_map_l1(struct mt7996_dev *dev, u32 addr) + u32 offset = FIELD_GET(MT_HIF_REMAP_L1_OFFSET, addr); + u32 base = FIELD_GET(MT_HIF_REMAP_L1_BASE, addr); + +- dev->reg_l1_backup = dev->bus_ops->rr(&dev->mt76, MT_HIF_REMAP_L1); + dev->bus_ops->rmw(&dev->mt76, MT_HIF_REMAP_L1, + MT_HIF_REMAP_L1_MASK, + FIELD_PREP(MT_HIF_REMAP_L1_MASK, base)); +@@ -97,7 +96,6 @@ static u32 mt7996_reg_map_l2(struct mt7996_dev *dev, u32 addr) + u32 offset = FIELD_GET(MT_HIF_REMAP_L2_OFFSET, addr); + u32 base = FIELD_GET(MT_HIF_REMAP_L2_BASE, addr); + +- dev->reg_l2_backup = dev->bus_ops->rr(&dev->mt76, MT_HIF_REMAP_L2); + dev->bus_ops->rmw(&dev->mt76, MT_HIF_REMAP_L2, + MT_HIF_REMAP_L2_MASK, + FIELD_PREP(MT_HIF_REMAP_L2_MASK, base)); +@@ -107,26 +105,10 @@ static u32 mt7996_reg_map_l2(struct mt7996_dev *dev, u32 addr) + return MT_HIF_REMAP_BASE_L2 + offset; + } + +-static void mt7996_reg_remap_restore(struct mt7996_dev *dev) +-{ +- /* remap to ori status */ +- if (unlikely(dev->reg_l1_backup)) { +- dev->bus_ops->wr(&dev->mt76, MT_HIF_REMAP_L1, dev->reg_l1_backup); +- dev->reg_l1_backup = 0; +- } +- +- if (dev->reg_l2_backup) { +- dev->bus_ops->wr(&dev->mt76, MT_HIF_REMAP_L2, dev->reg_l2_backup); +- dev->reg_l2_backup = 0; +- } +-} +- + static u32 __mt7996_reg_addr(struct mt7996_dev *dev, u32 addr) + { + int i; + +- mt7996_reg_remap_restore(dev); +- + if (addr < 0x100000) + return addr; + +@@ -143,6 +125,11 @@ static u32 __mt7996_reg_addr(struct mt7996_dev *dev, u32 addr) + return dev->reg.map[i].mapped + ofs; + } + ++ return 0; ++} ++ ++static u32 __mt7996_reg_remap_addr(struct mt7996_dev *dev, u32 addr) ++{ + if ((addr >= MT_INFRA_BASE && addr < MT_WFSYS0_PHY_START) || + (addr >= MT_WFSYS0_PHY_START && addr < MT_WFSYS1_PHY_START) || + (addr >= MT_WFSYS1_PHY_START && addr <= MT_WFSYS1_PHY_END)) +@@ -167,28 +154,60 @@ void mt7996_memcpy_fromio(struct mt7996_dev *dev, void *buf, u32 offset, + { + u32 addr = __mt7996_reg_addr(dev, offset); + +- memcpy_fromio(buf, dev->mt76.mmio.regs + addr, len); ++ if (addr) { ++ memcpy_fromio(buf, dev->mt76.mmio.regs + addr, len); ++ return; ++ } ++ ++ spin_lock_bh(&dev->reg_lock); ++ memcpy_fromio(buf, dev->mt76.mmio.regs + ++ __mt7996_reg_remap_addr(dev, offset), len); ++ spin_unlock_bh(&dev->reg_lock); + } + + static u32 mt7996_rr(struct mt76_dev *mdev, u32 offset) + { + struct mt7996_dev *dev = container_of(mdev, struct mt7996_dev, mt76); ++ u32 addr = __mt7996_reg_addr(dev, offset), val; ++ ++ if (addr) ++ return dev->bus_ops->rr(mdev, addr); + +- return dev->bus_ops->rr(mdev, __mt7996_reg_addr(dev, offset)); ++ spin_lock_bh(&dev->reg_lock); ++ val = dev->bus_ops->rr(mdev, __mt7996_reg_remap_addr(dev, offset)); ++ spin_unlock_bh(&dev->reg_lock); ++ ++ return val; + } + + static void mt7996_wr(struct mt76_dev *mdev, u32 offset, u32 val) + { + struct mt7996_dev *dev = container_of(mdev, struct mt7996_dev, mt76); ++ u32 addr = __mt7996_reg_addr(dev, offset); + +- dev->bus_ops->wr(mdev, __mt7996_reg_addr(dev, offset), val); ++ if (addr) { ++ dev->bus_ops->wr(mdev, addr, val); ++ return; ++ } ++ ++ spin_lock_bh(&dev->reg_lock); ++ dev->bus_ops->wr(mdev, __mt7996_reg_remap_addr(dev, offset), val); ++ spin_unlock_bh(&dev->reg_lock); + } + + static u32 mt7996_rmw(struct mt76_dev *mdev, u32 offset, u32 mask, u32 val) + { + struct mt7996_dev *dev = container_of(mdev, struct mt7996_dev, mt76); ++ u32 addr = __mt7996_reg_addr(dev, offset); ++ ++ if (addr) ++ return dev->bus_ops->rmw(mdev, addr, mask, val); ++ ++ spin_lock_bh(&dev->reg_lock); ++ val = dev->bus_ops->rmw(mdev, __mt7996_reg_remap_addr(dev, offset), mask, val); ++ spin_unlock_bh(&dev->reg_lock); + +- return dev->bus_ops->rmw(mdev, __mt7996_reg_addr(dev, offset), mask, val); ++ return val; + } + + static int mt7996_mmio_init(struct mt76_dev *mdev, +@@ -200,6 +219,7 @@ static int mt7996_mmio_init(struct mt76_dev *mdev, + + dev = container_of(mdev, struct mt7996_dev, mt76); + mt76_mmio_init(&dev->mt76, mem_base); ++ spin_lock_init(&dev->reg_lock); + + switch (device_id) { + case 0x7990: +diff --git a/drivers/net/wireless/mediatek/mt76/mt7996/mt7996.h b/drivers/net/wireless/mediatek/mt76/mt7996/mt7996.h +index d5ef4137290db..25bb365612314 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7996/mt7996.h ++++ b/drivers/net/wireless/mediatek/mt76/mt7996/mt7996.h +@@ -242,8 +242,7 @@ struct mt7996_dev { + u8 n_agrt; + } twt; + +- u32 reg_l1_backup; +- u32 reg_l2_backup; ++ spinlock_t reg_lock; + + u8 wtbl_size_group; + }; +diff --git a/drivers/net/wireless/realtek/rtw89/mac80211.c b/drivers/net/wireless/realtek/rtw89/mac80211.c +index e70757e4dc2c1..8aed0d101bf3b 100644 +--- a/drivers/net/wireless/realtek/rtw89/mac80211.c ++++ b/drivers/net/wireless/realtek/rtw89/mac80211.c +@@ -422,7 +422,7 @@ static void rtw89_ops_bss_info_changed(struct ieee80211_hw *hw, + * when disconnected by peer + */ + if (rtwdev->scanning) +- rtw89_hw_scan_abort(rtwdev, vif); ++ rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); + } + } + +@@ -971,7 +971,7 @@ static int rtw89_ops_remain_on_channel(struct ieee80211_hw *hw, + } + + if (rtwdev->scanning) +- rtw89_hw_scan_abort(rtwdev, vif); ++ rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); + + if (type == IEEE80211_ROC_TYPE_MGMT_TX) + roc->state = RTW89_ROC_MGMT; +diff --git a/drivers/net/wireless/realtek/rtw89/pci.h b/drivers/net/wireless/realtek/rtw89/pci.h +index 2f3d1ad3b0f7d..4259b79b138fb 100644 +--- a/drivers/net/wireless/realtek/rtw89/pci.h ++++ b/drivers/net/wireless/realtek/rtw89/pci.h +@@ -559,7 +559,7 @@ + #define RTW89_PCI_TXWD_NUM_MAX 512 + #define RTW89_PCI_TXWD_PAGE_SIZE 128 + #define RTW89_PCI_ADDRINFO_MAX 4 +-#define RTW89_PCI_RX_BUF_SIZE 11460 ++#define RTW89_PCI_RX_BUF_SIZE (11454 + 40) /* +40 for rtw89_rxdesc_long_v2 */ + + #define RTW89_PCI_POLL_BDRAM_RST_CNT 100 + #define RTW89_PCI_MULTITAG 8 +diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c +index f8e92404a6591..b985142fb84b9 100644 +--- a/drivers/nvme/host/pci.c ++++ b/drivers/nvme/host/pci.c +@@ -3361,6 +3361,9 @@ static const struct pci_device_id nvme_id_table[] = { + NVME_QUIRK_BOGUS_NID, }, + { PCI_VDEVICE(REDHAT, 0x0010), /* Qemu emulated controller */ + .driver_data = NVME_QUIRK_BOGUS_NID, }, ++ { PCI_DEVICE(0x126f, 0x2262), /* Silicon Motion generic */ ++ .driver_data = NVME_QUIRK_NO_DEEPEST_PS | ++ NVME_QUIRK_BOGUS_NID, }, + { PCI_DEVICE(0x126f, 0x2263), /* Silicon Motion unidentified */ + .driver_data = NVME_QUIRK_NO_NS_DESC_LIST | + NVME_QUIRK_BOGUS_NID, }, +diff --git a/drivers/perf/hisilicon/hisi_uncore_uc_pmu.c b/drivers/perf/hisilicon/hisi_uncore_uc_pmu.c +index 636fb79647c8c..481dcc9e8fbf8 100644 +--- a/drivers/perf/hisilicon/hisi_uncore_uc_pmu.c ++++ b/drivers/perf/hisilicon/hisi_uncore_uc_pmu.c +@@ -287,12 +287,52 @@ static u64 hisi_uc_pmu_read_counter(struct hisi_pmu *uc_pmu, + return readq(uc_pmu->base + HISI_UC_CNTR_REGn(hwc->idx)); + } + +-static void hisi_uc_pmu_write_counter(struct hisi_pmu *uc_pmu, ++static bool hisi_uc_pmu_get_glb_en_state(struct hisi_pmu *uc_pmu) ++{ ++ u32 val; ++ ++ val = readl(uc_pmu->base + HISI_UC_EVENT_CTRL_REG); ++ return !!FIELD_GET(HISI_UC_EVENT_GLB_EN, val); ++} ++ ++static void hisi_uc_pmu_write_counter_normal(struct hisi_pmu *uc_pmu, + struct hw_perf_event *hwc, u64 val) + { + writeq(val, uc_pmu->base + HISI_UC_CNTR_REGn(hwc->idx)); + } + ++static void hisi_uc_pmu_write_counter_quirk_v2(struct hisi_pmu *uc_pmu, ++ struct hw_perf_event *hwc, u64 val) ++{ ++ hisi_uc_pmu_start_counters(uc_pmu); ++ hisi_uc_pmu_write_counter_normal(uc_pmu, hwc, val); ++ hisi_uc_pmu_stop_counters(uc_pmu); ++} ++ ++static void hisi_uc_pmu_write_counter(struct hisi_pmu *uc_pmu, ++ struct hw_perf_event *hwc, u64 val) ++{ ++ bool enable = hisi_uc_pmu_get_glb_en_state(uc_pmu); ++ bool erratum = uc_pmu->identifier == HISI_PMU_V2; ++ ++ /* ++ * HiSilicon UC PMU v2 suffers the erratum 162700402 that the ++ * PMU counter cannot be set due to the lack of clock under power ++ * saving mode. This will lead to error or inaccurate counts. ++ * The clock can be enabled by the PMU global enabling control. ++ * The irq handler and pmu_start() will call the function to set ++ * period. If the function under irq context, the PMU has been ++ * enabled therefore we set counter directly. Other situations ++ * the PMU is disabled, we need to enable it to turn on the ++ * counter clock to set period, and then restore PMU enable ++ * status, the counter can hold its value without a clock. ++ */ ++ if (enable || !erratum) ++ hisi_uc_pmu_write_counter_normal(uc_pmu, hwc, val); ++ else ++ hisi_uc_pmu_write_counter_quirk_v2(uc_pmu, hwc, val); ++} ++ + static void hisi_uc_pmu_enable_counter_int(struct hisi_pmu *uc_pmu, + struct hw_perf_event *hwc) + { +diff --git a/drivers/pinctrl/renesas/core.c b/drivers/pinctrl/renesas/core.c +index d1e92bbed33ad..757bbc549b0e2 100644 +--- a/drivers/pinctrl/renesas/core.c ++++ b/drivers/pinctrl/renesas/core.c +@@ -909,9 +909,11 @@ static void __init sh_pfc_check_cfg_reg(const char *drvname, + sh_pfc_err("reg 0x%x: var_field_width declares %u instead of %u bits\n", + cfg_reg->reg, rw, cfg_reg->reg_width); + +- if (n != cfg_reg->nr_enum_ids) ++ if (n != cfg_reg->nr_enum_ids) { + sh_pfc_err("reg 0x%x: enum_ids[] has %u instead of %u values\n", + cfg_reg->reg, cfg_reg->nr_enum_ids, n); ++ n = cfg_reg->nr_enum_ids; ++ } + + check_enum_ids: + sh_pfc_check_reg_enums(drvname, cfg_reg->reg, cfg_reg->enum_ids, n); +diff --git a/drivers/platform/x86/intel/vbtn.c b/drivers/platform/x86/intel/vbtn.c +index 084c355c86f5f..5d13452bb947a 100644 +--- a/drivers/platform/x86/intel/vbtn.c ++++ b/drivers/platform/x86/intel/vbtn.c +@@ -136,8 +136,6 @@ static int intel_vbtn_input_setup(struct platform_device *device) + priv->switches_dev->id.bustype = BUS_HOST; + + if (priv->has_switches) { +- detect_tablet_mode(&device->dev); +- + ret = input_register_device(priv->switches_dev); + if (ret) + return ret; +@@ -316,6 +314,9 @@ static int intel_vbtn_probe(struct platform_device *device) + if (ACPI_FAILURE(status)) + dev_err(&device->dev, "Error VBDL failed with ACPI status %d\n", status); + } ++ // Check switches after buttons since VBDL may have side effects. ++ if (has_switches) ++ detect_tablet_mode(&device->dev); + + device_init_wakeup(&device->dev, true); + /* +diff --git a/drivers/platform/x86/touchscreen_dmi.c b/drivers/platform/x86/touchscreen_dmi.c +index 969477c83e56e..630ed0515b1e9 100644 +--- a/drivers/platform/x86/touchscreen_dmi.c ++++ b/drivers/platform/x86/touchscreen_dmi.c +@@ -1222,6 +1222,15 @@ const struct dmi_system_id touchscreen_dmi_table[] = { + DMI_MATCH(DMI_BIOS_VERSION, "CHUWI.D86JLBNR"), + }, + }, ++ { ++ /* Chuwi Vi8 dual-boot (CWI506) */ ++ .driver_data = (void *)&chuwi_vi8_data, ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Insyde"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "i86"), ++ DMI_MATCH(DMI_BIOS_VERSION, "CHUWI2.D86JHBNR02"), ++ }, ++ }, + { + /* Chuwi Vi8 Plus (CWI519) */ + .driver_data = (void *)&chuwi_vi8_plus_data, +diff --git a/drivers/pmdomain/imx/imx8mp-blk-ctrl.c b/drivers/pmdomain/imx/imx8mp-blk-ctrl.c +index c6ac32c1a8c17..31693add7d633 100644 +--- a/drivers/pmdomain/imx/imx8mp-blk-ctrl.c ++++ b/drivers/pmdomain/imx/imx8mp-blk-ctrl.c +@@ -55,7 +55,7 @@ struct imx8mp_blk_ctrl_domain_data { + const char *gpc_name; + }; + +-#define DOMAIN_MAX_CLKS 2 ++#define DOMAIN_MAX_CLKS 3 + #define DOMAIN_MAX_PATHS 3 + + struct imx8mp_blk_ctrl_domain { +@@ -457,8 +457,8 @@ static const struct imx8mp_blk_ctrl_domain_data imx8mp_hdmi_domain_data[] = { + }, + [IMX8MP_HDMIBLK_PD_LCDIF] = { + .name = "hdmiblk-lcdif", +- .clk_names = (const char *[]){ "axi", "apb" }, +- .num_clks = 2, ++ .clk_names = (const char *[]){ "axi", "apb", "fdcc" }, ++ .num_clks = 3, + .gpc_name = "lcdif", + .path_names = (const char *[]){"lcdif-hdmi"}, + .num_paths = 1, +@@ -483,8 +483,8 @@ static const struct imx8mp_blk_ctrl_domain_data imx8mp_hdmi_domain_data[] = { + }, + [IMX8MP_HDMIBLK_PD_HDMI_TX] = { + .name = "hdmiblk-hdmi-tx", +- .clk_names = (const char *[]){ "apb", "ref_266m" }, +- .num_clks = 2, ++ .clk_names = (const char *[]){ "apb", "ref_266m", "fdcc" }, ++ .num_clks = 3, + .gpc_name = "hdmi-tx", + }, + [IMX8MP_HDMIBLK_PD_HDMI_TX_PHY] = { +diff --git a/drivers/pmdomain/ti/omap_prm.c b/drivers/pmdomain/ti/omap_prm.c +index c2feae3a634ca..b8ceb3c2b81c2 100644 +--- a/drivers/pmdomain/ti/omap_prm.c ++++ b/drivers/pmdomain/ti/omap_prm.c +@@ -695,6 +695,8 @@ static int omap_prm_domain_init(struct device *dev, struct omap_prm *prm) + data = prm->data; + name = devm_kasprintf(dev, GFP_KERNEL, "prm_%s", + data->name); ++ if (!name) ++ return -ENOMEM; + + prmd->dev = dev; + prmd->prm = prm; +diff --git a/drivers/scsi/lpfc/lpfc_nportdisc.c b/drivers/scsi/lpfc/lpfc_nportdisc.c +index 1eb7f7e60bba5..3ed211d093dd1 100644 +--- a/drivers/scsi/lpfc/lpfc_nportdisc.c ++++ b/drivers/scsi/lpfc/lpfc_nportdisc.c +@@ -748,8 +748,10 @@ lpfc_rcv_padisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, + /* Save the ELS cmd */ + elsiocb->drvrTimeout = cmd; + +- lpfc_sli4_resume_rpi(ndlp, +- lpfc_mbx_cmpl_resume_rpi, elsiocb); ++ if (lpfc_sli4_resume_rpi(ndlp, ++ lpfc_mbx_cmpl_resume_rpi, ++ elsiocb)) ++ kfree(elsiocb); + goto out; + } + } +diff --git a/drivers/soundwire/dmi-quirks.c b/drivers/soundwire/dmi-quirks.c +index 9ebdd0cd0b1cf..91ab97a456fa9 100644 +--- a/drivers/soundwire/dmi-quirks.c ++++ b/drivers/soundwire/dmi-quirks.c +@@ -130,6 +130,14 @@ static const struct dmi_system_id adr_remap_quirk_table[] = { + }, + .driver_data = (void *)intel_rooks_county, + }, ++ { ++ /* quirk used for NUC15 LAPRC710 skew */ ++ .matches = { ++ DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"), ++ DMI_MATCH(DMI_BOARD_NAME, "LAPRC710"), ++ }, ++ .driver_data = (void *)intel_rooks_county, ++ }, + { + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), +diff --git a/drivers/thermal/thermal_of.c b/drivers/thermal/thermal_of.c +index 1e0655b63259f..d5174f11b91c2 100644 +--- a/drivers/thermal/thermal_of.c ++++ b/drivers/thermal/thermal_of.c +@@ -225,14 +225,18 @@ static int thermal_of_monitor_init(struct device_node *np, int *delay, int *pdel + int ret; + + ret = of_property_read_u32(np, "polling-delay-passive", pdelay); +- if (ret < 0) { +- pr_err("%pOFn: missing polling-delay-passive property\n", np); ++ if (ret == -EINVAL) { ++ *pdelay = 0; ++ } else if (ret < 0) { ++ pr_err("%pOFn: Couldn't get polling-delay-passive: %d\n", np, ret); + return ret; + } + + ret = of_property_read_u32(np, "polling-delay", delay); +- if (ret < 0) { +- pr_err("%pOFn: missing polling-delay property\n", np); ++ if (ret == -EINVAL) { ++ *delay = 0; ++ } else if (ret < 0) { ++ pr_err("%pOFn: Couldn't get polling-delay: %d\n", np, ret); + return ret; + } + +diff --git a/drivers/thunderbolt/quirks.c b/drivers/thunderbolt/quirks.c +index e6bfa63b40aee..e81de9c30eac9 100644 +--- a/drivers/thunderbolt/quirks.c ++++ b/drivers/thunderbolt/quirks.c +@@ -43,6 +43,12 @@ static void quirk_usb3_maximum_bandwidth(struct tb_switch *sw) + } + } + ++static void quirk_block_rpm_in_redrive(struct tb_switch *sw) ++{ ++ sw->quirks |= QUIRK_KEEP_POWER_IN_DP_REDRIVE; ++ tb_sw_dbg(sw, "preventing runtime PM in DP redrive mode\n"); ++} ++ + struct tb_quirk { + u16 hw_vendor_id; + u16 hw_device_id; +@@ -86,6 +92,14 @@ static const struct tb_quirk tb_quirks[] = { + quirk_usb3_maximum_bandwidth }, + { 0x8087, PCI_DEVICE_ID_INTEL_BARLOW_RIDGE_HUB_40G_BRIDGE, 0x0000, 0x0000, + quirk_usb3_maximum_bandwidth }, ++ /* ++ * Block Runtime PM in DP redrive mode for Intel Barlow Ridge host ++ * controllers. ++ */ ++ { 0x8087, PCI_DEVICE_ID_INTEL_BARLOW_RIDGE_HOST_80G_NHI, 0x0000, 0x0000, ++ quirk_block_rpm_in_redrive }, ++ { 0x8087, PCI_DEVICE_ID_INTEL_BARLOW_RIDGE_HOST_40G_NHI, 0x0000, 0x0000, ++ quirk_block_rpm_in_redrive }, + /* + * CLx is not supported on AMD USB4 Yellow Carp and Pink Sardine platforms. + */ +diff --git a/drivers/thunderbolt/tb.c b/drivers/thunderbolt/tb.c +index 27bd6ca6f99e4..ecfb5714e822d 100644 +--- a/drivers/thunderbolt/tb.c ++++ b/drivers/thunderbolt/tb.c +@@ -1416,6 +1416,49 @@ static void tb_tunnel_dp(struct tb *tb) + pm_runtime_put_autosuspend(&in->sw->dev); + } + ++static void tb_enter_redrive(struct tb_port *port) ++{ ++ struct tb_switch *sw = port->sw; ++ ++ if (!(sw->quirks & QUIRK_KEEP_POWER_IN_DP_REDRIVE)) ++ return; ++ ++ /* ++ * If we get hot-unplug for the DP IN port of the host router ++ * and the DP resource is not available anymore it means there ++ * is a monitor connected directly to the Type-C port and we are ++ * in "redrive" mode. For this to work we cannot enter RTD3 so ++ * we bump up the runtime PM reference count here. ++ */ ++ if (!tb_port_is_dpin(port)) ++ return; ++ if (tb_route(sw)) ++ return; ++ if (!tb_switch_query_dp_resource(sw, port)) { ++ port->redrive = true; ++ pm_runtime_get(&sw->dev); ++ tb_port_dbg(port, "enter redrive mode, keeping powered\n"); ++ } ++} ++ ++static void tb_exit_redrive(struct tb_port *port) ++{ ++ struct tb_switch *sw = port->sw; ++ ++ if (!(sw->quirks & QUIRK_KEEP_POWER_IN_DP_REDRIVE)) ++ return; ++ ++ if (!tb_port_is_dpin(port)) ++ return; ++ if (tb_route(sw)) ++ return; ++ if (port->redrive && tb_switch_query_dp_resource(sw, port)) { ++ port->redrive = false; ++ pm_runtime_put(&sw->dev); ++ tb_port_dbg(port, "exit redrive mode\n"); ++ } ++} ++ + static void tb_dp_resource_unavailable(struct tb *tb, struct tb_port *port) + { + struct tb_port *in, *out; +@@ -1432,7 +1475,10 @@ static void tb_dp_resource_unavailable(struct tb *tb, struct tb_port *port) + } + + tunnel = tb_find_tunnel(tb, TB_TUNNEL_DP, in, out); +- tb_deactivate_and_free_tunnel(tunnel); ++ if (tunnel) ++ tb_deactivate_and_free_tunnel(tunnel); ++ else ++ tb_enter_redrive(port); + list_del_init(&port->list); + + /* +@@ -1459,6 +1505,7 @@ static void tb_dp_resource_available(struct tb *tb, struct tb_port *port) + tb_port_dbg(port, "DP %s resource available\n", + tb_port_is_dpin(port) ? "IN" : "OUT"); + list_add_tail(&port->list, &tcm->dp_resources); ++ tb_exit_redrive(port); + + /* Look for suitable DP IN <-> DP OUT pairs now */ + tb_tunnel_dp(tb); +diff --git a/drivers/thunderbolt/tb.h b/drivers/thunderbolt/tb.h +index d2a55ad2fd3e6..4893d2c7ac968 100644 +--- a/drivers/thunderbolt/tb.h ++++ b/drivers/thunderbolt/tb.h +@@ -23,6 +23,8 @@ + #define QUIRK_FORCE_POWER_LINK_CONTROLLER BIT(0) + /* Disable CLx if not supported */ + #define QUIRK_NO_CLX BIT(1) ++/* Need to keep power on while USB4 port is in redrive mode */ ++#define QUIRK_KEEP_POWER_IN_DP_REDRIVE BIT(2) + + /** + * struct tb_nvm - Structure holding NVM information +@@ -261,6 +263,7 @@ struct tb_bandwidth_group { + * @group_list: The adapter is linked to the group's list of ports through this + * @max_bw: Maximum possible bandwidth through this adapter if set to + * non-zero. ++ * @redrive: For DP IN, if true the adapter is in redrive mode. + * + * In USB4 terminology this structure represents an adapter (protocol or + * lane adapter). +@@ -289,6 +292,7 @@ struct tb_port { + struct tb_bandwidth_group *group; + struct list_head group_list; + unsigned int max_bw; ++ bool redrive; + }; + + /** +diff --git a/drivers/usb/gadget/function/uvc_video.c b/drivers/usb/gadget/function/uvc_video.c +index 91af3b1ef0d41..281e75027b344 100644 +--- a/drivers/usb/gadget/function/uvc_video.c ++++ b/drivers/usb/gadget/function/uvc_video.c +@@ -35,6 +35,9 @@ uvc_video_encode_header(struct uvc_video *video, struct uvc_buffer *buf, + + data[1] = UVC_STREAM_EOH | video->fid; + ++ if (video->queue.flags & UVC_QUEUE_DROP_INCOMPLETE) ++ data[1] |= UVC_STREAM_ERR; ++ + if (video->queue.buf_used == 0 && ts.tv_sec) { + /* dwClockFrequency is 48 MHz */ + u32 pts = ((u64)ts.tv_sec * USEC_PER_SEC + ts.tv_nsec / NSEC_PER_USEC) * 48; +diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c +index 0956495bba575..2b871540bb500 100644 +--- a/drivers/usb/host/sl811-hcd.c ++++ b/drivers/usb/host/sl811-hcd.c +@@ -585,6 +585,7 @@ done(struct sl811 *sl811, struct sl811h_ep *ep, u8 bank) + finish_request(sl811, ep, urb, urbstat); + } + ++#ifdef QUIRK2 + static inline u8 checkdone(struct sl811 *sl811) + { + u8 ctl; +@@ -616,6 +617,7 @@ static inline u8 checkdone(struct sl811 *sl811) + #endif + return irqstat; + } ++#endif + + static irqreturn_t sl811h_irq(struct usb_hcd *hcd) + { +diff --git a/drivers/usb/typec/tcpm/tcpci.c b/drivers/usb/typec/tcpm/tcpci.c +index 0ee3e6e29bb17..7118551827f6a 100644 +--- a/drivers/usb/typec/tcpm/tcpci.c ++++ b/drivers/usb/typec/tcpm/tcpci.c +@@ -889,6 +889,7 @@ MODULE_DEVICE_TABLE(i2c, tcpci_id); + #ifdef CONFIG_OF + static const struct of_device_id tcpci_of_match[] = { + { .compatible = "nxp,ptn5110", }, ++ { .compatible = "tcpci", }, + {}, + }; + MODULE_DEVICE_TABLE(of, tcpci_of_match); +diff --git a/drivers/usb/typec/ucsi/ucsi.c b/drivers/usb/typec/ucsi/ucsi.c +index 70d9f4eebf1a7..c4f5ee171cdeb 100644 +--- a/drivers/usb/typec/ucsi/ucsi.c ++++ b/drivers/usb/typec/ucsi/ucsi.c +@@ -36,6 +36,19 @@ + */ + #define UCSI_SWAP_TIMEOUT_MS 5000 + ++static int ucsi_read_message_in(struct ucsi *ucsi, void *buf, ++ size_t buf_size) ++{ ++ /* ++ * Below UCSI 2.0, MESSAGE_IN was limited to 16 bytes. Truncate the ++ * reads here. ++ */ ++ if (ucsi->version <= UCSI_VERSION_1_2) ++ buf_size = clamp(buf_size, 0, 16); ++ ++ return ucsi->ops->read(ucsi, UCSI_MESSAGE_IN, buf, buf_size); ++} ++ + static int ucsi_acknowledge_command(struct ucsi *ucsi) + { + u64 ctrl; +@@ -72,7 +85,7 @@ static int ucsi_read_error(struct ucsi *ucsi) + if (ret < 0) + return ret; + +- ret = ucsi->ops->read(ucsi, UCSI_MESSAGE_IN, &error, sizeof(error)); ++ ret = ucsi_read_message_in(ucsi, &error, sizeof(error)); + if (ret) + return ret; + +@@ -174,7 +187,7 @@ int ucsi_send_command(struct ucsi *ucsi, u64 command, + length = ret; + + if (data) { +- ret = ucsi->ops->read(ucsi, UCSI_MESSAGE_IN, data, size); ++ ret = ucsi_read_message_in(ucsi, data, size); + if (ret) + goto out; + } +@@ -1593,6 +1606,15 @@ int ucsi_register(struct ucsi *ucsi) + if (!ucsi->version) + return -ENODEV; + ++ /* ++ * Version format is JJ.M.N (JJ = Major version, M = Minor version, ++ * N = sub-minor version). ++ */ ++ dev_dbg(ucsi->dev, "Registered UCSI interface with version %x.%x.%x", ++ UCSI_BCD_GET_MAJOR(ucsi->version), ++ UCSI_BCD_GET_MINOR(ucsi->version), ++ UCSI_BCD_GET_SUBMINOR(ucsi->version)); ++ + queue_delayed_work(system_long_wq, &ucsi->work, 0); + + ucsi_debugfs_register(ucsi); +diff --git a/drivers/usb/typec/ucsi/ucsi.h b/drivers/usb/typec/ucsi/ucsi.h +index 13ec976b1c747..2a886e58cd632 100644 +--- a/drivers/usb/typec/ucsi/ucsi.h ++++ b/drivers/usb/typec/ucsi/ucsi.h +@@ -23,6 +23,17 @@ struct dentry; + #define UCSI_CONTROL 8 + #define UCSI_MESSAGE_IN 16 + #define UCSI_MESSAGE_OUT 32 ++#define UCSIv2_MESSAGE_OUT 272 ++ ++/* UCSI versions */ ++#define UCSI_VERSION_1_2 0x0120 ++#define UCSI_VERSION_2_0 0x0200 ++#define UCSI_VERSION_2_1 0x0210 ++#define UCSI_VERSION_3_0 0x0300 ++ ++#define UCSI_BCD_GET_MAJOR(_v_) (((_v_) >> 8) & 0xFF) ++#define UCSI_BCD_GET_MINOR(_v_) (((_v_) >> 4) & 0x0F) ++#define UCSI_BCD_GET_SUBMINOR(_v_) ((_v_) & 0x0F) + + /* Command Status and Connector Change Indication (CCI) bits */ + #define UCSI_CCI_CONNECTOR(_c_) (((_c_) & GENMASK(7, 1)) >> 1) +diff --git a/drivers/video/fbdev/core/fbmon.c b/drivers/video/fbdev/core/fbmon.c +index 79e5bfbdd34c2..0a26399dbc899 100644 +--- a/drivers/video/fbdev/core/fbmon.c ++++ b/drivers/video/fbdev/core/fbmon.c +@@ -1311,7 +1311,7 @@ int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var, struct fb_inf + int fb_videomode_from_videomode(const struct videomode *vm, + struct fb_videomode *fbmode) + { +- unsigned int htotal, vtotal; ++ unsigned int htotal, vtotal, total; + + fbmode->xres = vm->hactive; + fbmode->left_margin = vm->hback_porch; +@@ -1344,8 +1344,9 @@ int fb_videomode_from_videomode(const struct videomode *vm, + vtotal = vm->vactive + vm->vfront_porch + vm->vback_porch + + vm->vsync_len; + /* prevent division by zero */ +- if (htotal && vtotal) { +- fbmode->refresh = vm->pixelclock / (htotal * vtotal); ++ total = htotal * vtotal; ++ if (total) { ++ fbmode->refresh = vm->pixelclock / total; + /* a mode must have htotal and vtotal != 0 or it is invalid */ + } else { + fbmode->refresh = 0; +diff --git a/drivers/video/fbdev/via/accel.c b/drivers/video/fbdev/via/accel.c +index 0a1bc7a4d7853..1e04026f08091 100644 +--- a/drivers/video/fbdev/via/accel.c ++++ b/drivers/video/fbdev/via/accel.c +@@ -115,7 +115,7 @@ static int hw_bitblt_1(void __iomem *engine, u8 op, u32 width, u32 height, + + if (op != VIA_BITBLT_FILL) { + tmp = src_mem ? 0 : src_addr; +- if (dst_addr & 0xE0000007) { ++ if (tmp & 0xE0000007) { + printk(KERN_WARNING "hw_bitblt_1: Unsupported source " + "address %X\n", tmp); + return -EINVAL; +@@ -260,7 +260,7 @@ static int hw_bitblt_2(void __iomem *engine, u8 op, u32 width, u32 height, + writel(tmp, engine + 0x18); + + tmp = src_mem ? 0 : src_addr; +- if (dst_addr & 0xE0000007) { ++ if (tmp & 0xE0000007) { + printk(KERN_WARNING "hw_bitblt_2: Unsupported source " + "address %X\n", tmp); + return -EINVAL; +diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c +index 586a1673459eb..db61bcb3aab17 100644 +--- a/drivers/xen/balloon.c ++++ b/drivers/xen/balloon.c +@@ -673,7 +673,6 @@ EXPORT_SYMBOL(xen_free_ballooned_pages); + + static void __init balloon_add_regions(void) + { +-#if defined(CONFIG_XEN_PV) + unsigned long start_pfn, pages; + unsigned long pfn, extra_pfn_end; + unsigned int i; +@@ -697,7 +696,6 @@ static void __init balloon_add_regions(void) + + balloon_stats.total_pages += extra_pfn_end - start_pfn; + } +-#endif + } + + static int __init balloon_init(void) +diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c +index 744a02b7fd671..203e5964c9b0f 100644 +--- a/fs/btrfs/export.c ++++ b/fs/btrfs/export.c +@@ -174,8 +174,15 @@ struct dentry *btrfs_get_parent(struct dentry *child) + ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); + if (ret < 0) + goto fail; ++ if (ret == 0) { ++ /* ++ * Key with offset of -1 found, there would have to exist an ++ * inode with such number or a root with such id. ++ */ ++ ret = -EUCLEAN; ++ goto fail; ++ } + +- BUG_ON(ret == 0); /* Key with offset of -1 found */ + if (path->slots[0] == 0) { + ret = -ENOENT; + goto fail; +diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c +index 6a1102954a0ab..b430e03260fbf 100644 +--- a/fs/btrfs/send.c ++++ b/fs/btrfs/send.c +@@ -1070,7 +1070,15 @@ static int iterate_inode_ref(struct btrfs_root *root, struct btrfs_path *path, + ret = PTR_ERR(start); + goto out; + } +- BUG_ON(start < p->buf); ++ if (unlikely(start < p->buf)) { ++ btrfs_err(root->fs_info, ++ "send: path ref buffer underflow for key (%llu %u %llu)", ++ found_key->objectid, ++ found_key->type, ++ found_key->offset); ++ ret = -EINVAL; ++ goto out; ++ } + } + p->start = start; + } else { +diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c +index 36adbb3d096a9..453d037987fb3 100644 +--- a/fs/btrfs/volumes.c ++++ b/fs/btrfs/volumes.c +@@ -3352,7 +3352,17 @@ static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info) + mutex_unlock(&fs_info->reclaim_bgs_lock); + goto error; + } +- BUG_ON(ret == 0); /* Corruption */ ++ if (ret == 0) { ++ /* ++ * On the first search we would find chunk tree with ++ * offset -1, which is not possible. On subsequent ++ * loops this would find an existing item on an invalid ++ * offset (one less than the previous one, wrong ++ * alignment and size). ++ */ ++ ret = -EUCLEAN; ++ goto error; ++ } + + ret = btrfs_previous_item(chunk_root, path, key.objectid, + key.type); +diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c +index 257b70c5ded45..a8a3ea2fd690f 100644 +--- a/fs/ext4/mballoc.c ++++ b/fs/ext4/mballoc.c +@@ -3060,7 +3060,10 @@ static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v) + for (i = 0; i <= 13; i++) + seq_printf(seq, " %-5u", i <= blocksize_bits + 1 ? + sg.info.bb_counters[i] : 0); +- seq_puts(seq, " ]\n"); ++ seq_puts(seq, " ]"); ++ if (EXT4_MB_GRP_BBITMAP_CORRUPT(&sg.info)) ++ seq_puts(seq, " Block bitmap corrupted!"); ++ seq_puts(seq, "\n"); + + return 0; + } +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index 3ea4d8f11e7bb..83fc3f092a0c7 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -6865,6 +6865,10 @@ static int ext4_write_dquot(struct dquot *dquot) + if (IS_ERR(handle)) + return PTR_ERR(handle); + ret = dquot_commit(dquot); ++ if (ret < 0) ++ ext4_error_err(dquot->dq_sb, -ret, ++ "Failed to commit dquot type %d", ++ dquot->dq_id.type); + err = ext4_journal_stop(handle); + if (!ret) + ret = err; +@@ -6881,6 +6885,10 @@ static int ext4_acquire_dquot(struct dquot *dquot) + if (IS_ERR(handle)) + return PTR_ERR(handle); + ret = dquot_acquire(dquot); ++ if (ret < 0) ++ ext4_error_err(dquot->dq_sb, -ret, ++ "Failed to acquire dquot type %d", ++ dquot->dq_id.type); + err = ext4_journal_stop(handle); + if (!ret) + ret = err; +@@ -6900,6 +6908,10 @@ static int ext4_release_dquot(struct dquot *dquot) + return PTR_ERR(handle); + } + ret = dquot_release(dquot); ++ if (ret < 0) ++ ext4_error_err(dquot->dq_sb, -ret, ++ "Failed to release dquot type %d", ++ dquot->dq_id.type); + err = ext4_journal_stop(handle); + if (!ret) + ret = err; +diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c +index 2ee21286ac8f0..54075fe3de9b1 100644 +--- a/fs/isofs/inode.c ++++ b/fs/isofs/inode.c +@@ -908,8 +908,22 @@ static int isofs_fill_super(struct super_block *s, void *data, int silent) + * we then decide whether to use the Joliet descriptor. + */ + inode = isofs_iget(s, sbi->s_firstdatazone, 0); +- if (IS_ERR(inode)) +- goto out_no_root; ++ ++ /* ++ * Fix for broken CDs with a corrupt root inode but a correct Joliet ++ * root directory. ++ */ ++ if (IS_ERR(inode)) { ++ if (joliet_level && sbi->s_firstdatazone != first_data_zone) { ++ printk(KERN_NOTICE ++ "ISOFS: root inode is unusable. " ++ "Disabling Rock Ridge and switching to Joliet."); ++ sbi->s_rock = 0; ++ inode = NULL; ++ } else { ++ goto out_no_root; ++ } ++ } + + /* + * Fix for broken CDs with Rock Ridge and empty ISO root directory but +diff --git a/fs/kernfs/dir.c b/fs/kernfs/dir.c +index 62d39ecf0a466..2405aeb39b9a2 100644 +--- a/fs/kernfs/dir.c ++++ b/fs/kernfs/dir.c +@@ -529,6 +529,20 @@ void kernfs_get(struct kernfs_node *kn) + } + EXPORT_SYMBOL_GPL(kernfs_get); + ++static void kernfs_free_rcu(struct rcu_head *rcu) ++{ ++ struct kernfs_node *kn = container_of(rcu, struct kernfs_node, rcu); ++ ++ kfree_const(kn->name); ++ ++ if (kn->iattr) { ++ simple_xattrs_free(&kn->iattr->xattrs, NULL); ++ kmem_cache_free(kernfs_iattrs_cache, kn->iattr); ++ } ++ ++ kmem_cache_free(kernfs_node_cache, kn); ++} ++ + /** + * kernfs_put - put a reference count on a kernfs_node + * @kn: the target kernfs_node +@@ -557,16 +571,11 @@ void kernfs_put(struct kernfs_node *kn) + if (kernfs_type(kn) == KERNFS_LINK) + kernfs_put(kn->symlink.target_kn); + +- kfree_const(kn->name); +- +- if (kn->iattr) { +- simple_xattrs_free(&kn->iattr->xattrs, NULL); +- kmem_cache_free(kernfs_iattrs_cache, kn->iattr); +- } + spin_lock(&kernfs_idr_lock); + idr_remove(&root->ino_idr, (u32)kernfs_ino(kn)); + spin_unlock(&kernfs_idr_lock); +- kmem_cache_free(kernfs_node_cache, kn); ++ ++ call_rcu(&kn->rcu, kernfs_free_rcu); + + kn = parent; + if (kn) { +@@ -575,7 +584,7 @@ void kernfs_put(struct kernfs_node *kn) + } else { + /* just released the root kn, free @root too */ + idr_destroy(&root->ino_idr); +- kfree(root); ++ kfree_rcu(root, rcu); + } + } + EXPORT_SYMBOL_GPL(kernfs_put); +@@ -715,7 +724,7 @@ struct kernfs_node *kernfs_find_and_get_node_by_id(struct kernfs_root *root, + ino_t ino = kernfs_id_ino(id); + u32 gen = kernfs_id_gen(id); + +- spin_lock(&kernfs_idr_lock); ++ rcu_read_lock(); + + kn = idr_find(&root->ino_idr, (u32)ino); + if (!kn) +@@ -739,10 +748,10 @@ struct kernfs_node *kernfs_find_and_get_node_by_id(struct kernfs_root *root, + if (unlikely(!__kernfs_active(kn) || !atomic_inc_not_zero(&kn->count))) + goto err_unlock; + +- spin_unlock(&kernfs_idr_lock); ++ rcu_read_unlock(); + return kn; + err_unlock: +- spin_unlock(&kernfs_idr_lock); ++ rcu_read_unlock(); + return NULL; + } + +diff --git a/fs/kernfs/kernfs-internal.h b/fs/kernfs/kernfs-internal.h +index a9b854cdfdb5f..210dac7e9ee25 100644 +--- a/fs/kernfs/kernfs-internal.h ++++ b/fs/kernfs/kernfs-internal.h +@@ -49,6 +49,8 @@ struct kernfs_root { + struct rw_semaphore kernfs_rwsem; + struct rw_semaphore kernfs_iattr_rwsem; + struct rw_semaphore kernfs_supers_rwsem; ++ ++ struct rcu_head rcu; + }; + + /* +1 to avoid triggering overflow warning when negating it */ +diff --git a/fs/orangefs/super.c b/fs/orangefs/super.c +index 5254256a224d7..4ca8ed410c3cf 100644 +--- a/fs/orangefs/super.c ++++ b/fs/orangefs/super.c +@@ -527,7 +527,7 @@ struct dentry *orangefs_mount(struct file_system_type *fst, + sb->s_fs_info = kzalloc(sizeof(struct orangefs_sb_info_s), GFP_KERNEL); + if (!ORANGEFS_SB(sb)) { + d = ERR_PTR(-ENOMEM); +- goto free_sb_and_op; ++ goto free_op; + } + + ret = orangefs_fill_sb(sb, +diff --git a/fs/pstore/zone.c b/fs/pstore/zone.c +index 2770746bb7aa1..abca117725c81 100644 +--- a/fs/pstore/zone.c ++++ b/fs/pstore/zone.c +@@ -973,6 +973,8 @@ static ssize_t psz_kmsg_read(struct pstore_zone *zone, + char *buf = kasprintf(GFP_KERNEL, "%s: Total %d times\n", + kmsg_dump_reason_str(record->reason), + record->count); ++ if (!buf) ++ return -ENOMEM; + hlen = strlen(buf); + record->buf = krealloc(buf, hlen + size, GFP_KERNEL); + if (!record->buf) { +diff --git a/fs/sysv/itree.c b/fs/sysv/itree.c +index edb94e55de8e5..7b2a07a31e463 100644 +--- a/fs/sysv/itree.c ++++ b/fs/sysv/itree.c +@@ -82,9 +82,6 @@ static inline sysv_zone_t *block_end(struct buffer_head *bh) + return (sysv_zone_t*)((char*)bh->b_data + bh->b_size); + } + +-/* +- * Requires read_lock(&pointers_lock) or write_lock(&pointers_lock) +- */ + static Indirect *get_branch(struct inode *inode, + int depth, + int offsets[], +@@ -104,15 +101,18 @@ static Indirect *get_branch(struct inode *inode, + bh = sb_bread(sb, block); + if (!bh) + goto failure; ++ read_lock(&pointers_lock); + if (!verify_chain(chain, p)) + goto changed; + add_chain(++p, bh, (sysv_zone_t*)bh->b_data + *++offsets); ++ read_unlock(&pointers_lock); + if (!p->key) + goto no_block; + } + return NULL; + + changed: ++ read_unlock(&pointers_lock); + brelse(bh); + *err = -EAGAIN; + goto no_block; +@@ -218,9 +218,7 @@ static int get_block(struct inode *inode, sector_t iblock, struct buffer_head *b + goto out; + + reread: +- read_lock(&pointers_lock); + partial = get_branch(inode, depth, offsets, chain, &err); +- read_unlock(&pointers_lock); + + /* Simplest case - block found, no allocation needed */ + if (!partial) { +@@ -290,9 +288,9 @@ static Indirect *find_shared(struct inode *inode, + *top = 0; + for (k = depth; k > 1 && !offsets[k-1]; k--) + ; ++ partial = get_branch(inode, k, offsets, chain, &err); + + write_lock(&pointers_lock); +- partial = get_branch(inode, k, offsets, chain, &err); + if (!partial) + partial = chain + k-1; + /* +diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h +index 0b7eab0ef7d7f..d9c20ae23b632 100644 +--- a/include/acpi/acpi_bus.h ++++ b/include/acpi/acpi_bus.h +@@ -652,6 +652,7 @@ bool acpi_device_override_status(struct acpi_device *adev, unsigned long long *s + bool acpi_quirk_skip_acpi_ac_and_battery(void); + int acpi_install_cmos_rtc_space_handler(acpi_handle handle); + void acpi_remove_cmos_rtc_space_handler(acpi_handle handle); ++int acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *skip); + #else + static inline bool acpi_device_override_status(struct acpi_device *adev, + unsigned long long *status) +@@ -669,23 +670,22 @@ static inline int acpi_install_cmos_rtc_space_handler(acpi_handle handle) + static inline void acpi_remove_cmos_rtc_space_handler(acpi_handle handle) + { + } ++static inline int ++acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *skip) ++{ ++ *skip = false; ++ return 0; ++} + #endif + + #if IS_ENABLED(CONFIG_X86_ANDROID_TABLETS) + bool acpi_quirk_skip_i2c_client_enumeration(struct acpi_device *adev); +-int acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *skip); + bool acpi_quirk_skip_gpio_event_handlers(void); + #else + static inline bool acpi_quirk_skip_i2c_client_enumeration(struct acpi_device *adev) + { + return false; + } +-static inline int +-acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *skip) +-{ +- *skip = false; +- return 0; +-} + static inline bool acpi_quirk_skip_gpio_event_handlers(void) + { + return false; +diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h +index 2a36f3218b510..5a952d00ea159 100644 +--- a/include/linux/kernfs.h ++++ b/include/linux/kernfs.h +@@ -223,6 +223,8 @@ struct kernfs_node { + unsigned short flags; + umode_t mode; + struct kernfs_iattrs *iattr; ++ ++ struct rcu_head rcu; + }; + + /* +diff --git a/include/linux/overflow.h b/include/linux/overflow.h +index f9b60313eaea2..e04f679476473 100644 +--- a/include/linux/overflow.h ++++ b/include/linux/overflow.h +@@ -31,8 +31,10 @@ + * credit to Christian Biere. + */ + #define __type_half_max(type) ((type)1 << (8*sizeof(type) - 1 - is_signed_type(type))) +-#define type_max(T) ((T)((__type_half_max(T) - 1) + __type_half_max(T))) +-#define type_min(T) ((T)((T)-type_max(T)-(T)1)) ++#define __type_max(T) ((T)((__type_half_max(T) - 1) + __type_half_max(T))) ++#define type_max(t) __type_max(typeof(t)) ++#define __type_min(T) ((T)((T)-type_max(T)-(T)1)) ++#define type_min(t) __type_min(typeof(t)) + + /* + * Avoids triggering -Wtype-limits compilation warning, +@@ -130,10 +132,10 @@ static inline bool __must_check __must_check_overflow(bool overflow) + + #define __overflows_type_constexpr(x, T) ( \ + is_unsigned_type(typeof(x)) ? \ +- (x) > type_max(typeof(T)) : \ ++ (x) > type_max(T) : \ + is_unsigned_type(typeof(T)) ? \ +- (x) < 0 || (x) > type_max(typeof(T)) : \ +- (x) < type_min(typeof(T)) || (x) > type_max(typeof(T))) ++ (x) < 0 || (x) > type_max(T) : \ ++ (x) < type_min(T) || (x) > type_max(T)) + + #define __overflows_type(x, T) ({ \ + typeof(T) v = 0; \ +diff --git a/include/linux/randomize_kstack.h b/include/linux/randomize_kstack.h +index 5d868505a94e4..6d92b68efbf6c 100644 +--- a/include/linux/randomize_kstack.h ++++ b/include/linux/randomize_kstack.h +@@ -80,7 +80,7 @@ DECLARE_PER_CPU(u32, kstack_offset); + if (static_branch_maybe(CONFIG_RANDOMIZE_KSTACK_OFFSET_DEFAULT, \ + &randomize_kstack_offset)) { \ + u32 offset = raw_cpu_read(kstack_offset); \ +- offset ^= (rand); \ ++ offset = ror32(offset, 5) ^ (rand); \ + raw_cpu_write(kstack_offset, offset); \ + } \ + } while (0) +diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h +index 9ad656b28847f..6466c2f792923 100644 +--- a/include/linux/rcupdate.h ++++ b/include/linux/rcupdate.h +@@ -189,9 +189,9 @@ void rcu_tasks_trace_qs_blkd(struct task_struct *t); + do { \ + int ___rttq_nesting = READ_ONCE((t)->trc_reader_nesting); \ + \ +- if (likely(!READ_ONCE((t)->trc_reader_special.b.need_qs)) && \ ++ if (unlikely(READ_ONCE((t)->trc_reader_special.b.need_qs) == TRC_NEED_QS) && \ + likely(!___rttq_nesting)) { \ +- rcu_trc_cmpxchg_need_qs((t), 0, TRC_NEED_QS_CHECKED); \ ++ rcu_trc_cmpxchg_need_qs((t), TRC_NEED_QS, TRC_NEED_QS_CHECKED); \ + } else if (___rttq_nesting && ___rttq_nesting != INT_MIN && \ + !READ_ONCE((t)->trc_reader_special.b.blocked)) { \ + rcu_tasks_trace_qs_blkd(t); \ +diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h +index 9e61f6df6bc55..7d54808a1e8f9 100644 +--- a/include/linux/skbuff.h ++++ b/include/linux/skbuff.h +@@ -2627,6 +2627,8 @@ static inline void skb_put_u8(struct sk_buff *skb, u8 val) + void *skb_push(struct sk_buff *skb, unsigned int len); + static inline void *__skb_push(struct sk_buff *skb, unsigned int len) + { ++ DEBUG_NET_WARN_ON_ONCE(len > INT_MAX); ++ + skb->data -= len; + skb->len += len; + return skb->data; +@@ -2635,6 +2637,8 @@ static inline void *__skb_push(struct sk_buff *skb, unsigned int len) + void *skb_pull(struct sk_buff *skb, unsigned int len); + static inline void *__skb_pull(struct sk_buff *skb, unsigned int len) + { ++ DEBUG_NET_WARN_ON_ONCE(len > INT_MAX); ++ + skb->len -= len; + if (unlikely(skb->len < skb->data_len)) { + #if defined(CONFIG_DEBUG_NET) +@@ -2659,6 +2663,8 @@ void *__pskb_pull_tail(struct sk_buff *skb, int delta); + static inline enum skb_drop_reason + pskb_may_pull_reason(struct sk_buff *skb, unsigned int len) + { ++ DEBUG_NET_WARN_ON_ONCE(len > INT_MAX); ++ + if (likely(len <= skb_headlen(skb))) + return SKB_NOT_DROPPED_YET; + +@@ -2831,6 +2837,11 @@ static inline void skb_set_inner_network_header(struct sk_buff *skb, + skb->inner_network_header += offset; + } + ++static inline bool skb_inner_network_header_was_set(const struct sk_buff *skb) ++{ ++ return skb->inner_network_header > 0; ++} ++ + static inline unsigned char *skb_inner_mac_header(const struct sk_buff *skb) + { + return skb->head + skb->inner_mac_header; +diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h +index 8ada7dc802d30..8f9bee0e21c3b 100644 +--- a/include/linux/sunrpc/sched.h ++++ b/include/linux/sunrpc/sched.h +@@ -186,7 +186,7 @@ struct rpc_wait_queue { + unsigned char maxpriority; /* maximum priority (0 if queue is not a priority queue) */ + unsigned char priority; /* current priority */ + unsigned char nr; /* # tasks remaining for cookie */ +- unsigned short qlen; /* total # tasks waiting in queue */ ++ unsigned int qlen; /* total # tasks waiting in queue */ + struct rpc_timer timer_list; + #if IS_ENABLED(CONFIG_SUNRPC_DEBUG) || IS_ENABLED(CONFIG_TRACEPOINTS) + const char * name; +diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h +index 03e68a8e229f5..35c5f75a3a5ee 100644 +--- a/include/net/bluetooth/hci.h ++++ b/include/net/bluetooth/hci.h +@@ -339,6 +339,14 @@ enum { + * during the hdev->setup vendor callback. + */ + HCI_QUIRK_BROKEN_LE_CODED, ++ ++ /* ++ * When this quirk is set, the HCI_OP_READ_ENC_KEY_SIZE command is ++ * skipped during an HCI_EV_ENCRYPT_CHANGE event. This is required ++ * for Actions Semiconductor ATS2851 based controllers, which erroneously ++ * claim to support it. ++ */ ++ HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE, + }; + + /* HCI device flags */ +diff --git a/include/uapi/linux/input-event-codes.h b/include/uapi/linux/input-event-codes.h +index 022a520e31fc2..03edf2ccdf6c8 100644 +--- a/include/uapi/linux/input-event-codes.h ++++ b/include/uapi/linux/input-event-codes.h +@@ -602,6 +602,7 @@ + + #define KEY_ALS_TOGGLE 0x230 /* Ambient light sensor */ + #define KEY_ROTATE_LOCK_TOGGLE 0x231 /* Display rotation lock */ ++#define KEY_REFRESH_RATE_TOGGLE 0x232 /* Display refresh rate toggle */ + + #define KEY_BUTTONCONFIG 0x240 /* AL Button Configuration */ + #define KEY_TASKMANAGER 0x241 /* AL Task/Project Manager */ +diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c +index 2c0a9a98272ca..62ff7cee5db5f 100644 +--- a/io_uring/io_uring.c ++++ b/io_uring/io_uring.c +@@ -2117,6 +2117,13 @@ static void io_init_req_drain(struct io_kiocb *req) + } + } + ++static __cold int io_init_fail_req(struct io_kiocb *req, int err) ++{ ++ /* ensure per-opcode data is cleared if we fail before prep */ ++ memset(&req->cmd.data, 0, sizeof(req->cmd.data)); ++ return err; ++} ++ + static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req, + const struct io_uring_sqe *sqe) + __must_hold(&ctx->uring_lock) +@@ -2137,29 +2144,29 @@ static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req, + + if (unlikely(opcode >= IORING_OP_LAST)) { + req->opcode = 0; +- return -EINVAL; ++ return io_init_fail_req(req, -EINVAL); + } + def = &io_issue_defs[opcode]; + if (unlikely(sqe_flags & ~SQE_COMMON_FLAGS)) { + /* enforce forwards compatibility on users */ + if (sqe_flags & ~SQE_VALID_FLAGS) +- return -EINVAL; ++ return io_init_fail_req(req, -EINVAL); + if (sqe_flags & IOSQE_BUFFER_SELECT) { + if (!def->buffer_select) +- return -EOPNOTSUPP; ++ return io_init_fail_req(req, -EOPNOTSUPP); + req->buf_index = READ_ONCE(sqe->buf_group); + } + if (sqe_flags & IOSQE_CQE_SKIP_SUCCESS) + ctx->drain_disabled = true; + if (sqe_flags & IOSQE_IO_DRAIN) { + if (ctx->drain_disabled) +- return -EOPNOTSUPP; ++ return io_init_fail_req(req, -EOPNOTSUPP); + io_init_req_drain(req); + } + } + if (unlikely(ctx->restricted || ctx->drain_active || ctx->drain_next)) { + if (ctx->restricted && !io_check_restriction(ctx, req, sqe_flags)) +- return -EACCES; ++ return io_init_fail_req(req, -EACCES); + /* knock it to the slow queue path, will be drained there */ + if (ctx->drain_active) + req->flags |= REQ_F_FORCE_ASYNC; +@@ -2172,9 +2179,9 @@ static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req, + } + + if (!def->ioprio && sqe->ioprio) +- return -EINVAL; ++ return io_init_fail_req(req, -EINVAL); + if (!def->iopoll && (ctx->flags & IORING_SETUP_IOPOLL)) +- return -EINVAL; ++ return io_init_fail_req(req, -EINVAL); + + if (def->needs_file) { + struct io_submit_state *state = &ctx->submit_state; +@@ -2198,12 +2205,12 @@ static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req, + + req->creds = xa_load(&ctx->personalities, personality); + if (!req->creds) +- return -EINVAL; ++ return io_init_fail_req(req, -EINVAL); + get_cred(req->creds); + ret = security_uring_override_creds(req->creds); + if (ret) { + put_cred(req->creds); +- return ret; ++ return io_init_fail_req(req, ret); + } + req->flags |= REQ_F_CREDS; + } +diff --git a/kernel/dma/direct.c b/kernel/dma/direct.c +index 9596ae1aa0dac..fc2d10b2aca6f 100644 +--- a/kernel/dma/direct.c ++++ b/kernel/dma/direct.c +@@ -295,7 +295,7 @@ void *dma_direct_alloc(struct device *dev, size_t size, + } else { + ret = page_address(page); + if (dma_set_decrypted(dev, ret, size)) +- goto out_free_pages; ++ goto out_leak_pages; + } + + memset(ret, 0, size); +@@ -316,6 +316,8 @@ void *dma_direct_alloc(struct device *dev, size_t size, + out_free_pages: + __dma_direct_free_pages(dev, page, size); + return NULL; ++out_leak_pages: ++ return NULL; + } + + void dma_direct_free(struct device *dev, size_t size, +@@ -378,12 +380,11 @@ struct page *dma_direct_alloc_pages(struct device *dev, size_t size, + + ret = page_address(page); + if (dma_set_decrypted(dev, ret, size)) +- goto out_free_pages; ++ goto out_leak_pages; + memset(ret, 0, size); + *dma_handle = phys_to_dma_direct(dev, page_to_phys(page)); + return page; +-out_free_pages: +- __dma_direct_free_pages(dev, page, size); ++out_leak_pages: + return NULL; + } + +diff --git a/kernel/panic.c b/kernel/panic.c +index ffa037fa777d5..ef9f9a4e928de 100644 +--- a/kernel/panic.c ++++ b/kernel/panic.c +@@ -442,6 +442,14 @@ void panic(const char *fmt, ...) + + /* Do not scroll important messages printed above */ + suppress_printk = 1; ++ ++ /* ++ * The final messages may not have been printed if in a context that ++ * defers printing (such as NMI) and irq_work is not available. ++ * Explicitly flush the kernel log buffer one last time. ++ */ ++ console_flush_on_panic(CONSOLE_FLUSH_PENDING); ++ + local_irq_enable(); + for (i = 0; ; i += PANIC_TIMER_STEP) { + touch_softlockup_watchdog(); +diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c +index 35d32d66fb114..0fca282c0a254 100644 +--- a/kernel/printk/printk.c ++++ b/kernel/printk/printk.c +@@ -2309,8 +2309,7 @@ asmlinkage int vprintk_emit(int facility, int level, + if (unlikely(suppress_printk)) + return 0; + +- if (unlikely(suppress_panic_printk) && +- atomic_read(&panic_cpu) != raw_smp_processor_id()) ++ if (unlikely(suppress_panic_printk) && other_cpu_in_panic()) + return 0; + + if (level == LOGLEVEL_SCHED) { +diff --git a/kernel/rcu/tree_nocb.h b/kernel/rcu/tree_nocb.h +index 5598212d1f274..2b24405b9cd2b 100644 +--- a/kernel/rcu/tree_nocb.h ++++ b/kernel/rcu/tree_nocb.h +@@ -1383,7 +1383,7 @@ lazy_rcu_shrink_scan(struct shrinker *shrink, struct shrink_control *sc) + rcu_nocb_unlock_irqrestore(rdp, flags); + continue; + } +- WARN_ON_ONCE(!rcu_nocb_flush_bypass(rdp, NULL, jiffies, false)); ++ rcu_nocb_try_flush_bypass(rdp, jiffies); + rcu_nocb_unlock_irqrestore(rdp, flags); + wake_nocb_gp(rdp, false); + sc->nr_to_scan -= _count; +diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c +index 3fedd051f12c0..06249b37d8019 100644 +--- a/kernel/trace/ring_buffer.c ++++ b/kernel/trace/ring_buffer.c +@@ -4436,7 +4436,7 @@ int ring_buffer_iter_empty(struct ring_buffer_iter *iter) + cpu_buffer = iter->cpu_buffer; + reader = cpu_buffer->reader_page; + head_page = cpu_buffer->head_page; +- commit_page = cpu_buffer->commit_page; ++ commit_page = READ_ONCE(cpu_buffer->commit_page); + commit_ts = commit_page->page->time_stamp; + + /* +diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c +index bb0e5902a3e60..80e71ce32f09f 100644 +--- a/net/bluetooth/hci_event.c ++++ b/net/bluetooth/hci_event.c +@@ -3679,7 +3679,8 @@ static void hci_encrypt_change_evt(struct hci_dev *hdev, void *data, + * controller really supports it. If it doesn't, assume + * the default size (16). + */ +- if (!(hdev->commands[20] & 0x10)) { ++ if (!(hdev->commands[20] & 0x10) || ++ test_bit(HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE, &hdev->quirks)) { + conn->enc_key_size = HCI_LINK_KEY_SIZE; + goto notify; + } +diff --git a/net/ipv4/ip_tunnel.c b/net/ipv4/ip_tunnel.c +index b1b6dcf2161fb..acf93f34a8213 100644 +--- a/net/ipv4/ip_tunnel.c ++++ b/net/ipv4/ip_tunnel.c +@@ -1298,6 +1298,7 @@ int ip_tunnel_init(struct net_device *dev) + + if (tunnel->collect_md) + netif_keep_dst(dev); ++ netdev_lockdep_set_classes(dev); + return 0; + } + EXPORT_SYMBOL_GPL(ip_tunnel_init); +diff --git a/net/ipv6/ip6_gre.c b/net/ipv6/ip6_gre.c +index 26c3287beb29c..289b83347d9d5 100644 +--- a/net/ipv6/ip6_gre.c ++++ b/net/ipv6/ip6_gre.c +@@ -1514,6 +1514,7 @@ static int ip6gre_tunnel_init_common(struct net_device *dev) + ip6gre_tnl_init_features(dev); + + netdev_hold(dev, &tunnel->dev_tracker, GFP_KERNEL); ++ netdev_lockdep_set_classes(dev); + return 0; + + cleanup_dst_cache_init: +@@ -1906,6 +1907,7 @@ static int ip6erspan_tap_init(struct net_device *dev) + ip6erspan_tnl_link_config(tunnel, 1); + + netdev_hold(dev, &tunnel->dev_tracker, GFP_KERNEL); ++ netdev_lockdep_set_classes(dev); + return 0; + + cleanup_dst_cache_init: +diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c +index 9bbabf750a21e..70478027a7af7 100644 +--- a/net/ipv6/ip6_tunnel.c ++++ b/net/ipv6/ip6_tunnel.c +@@ -1898,6 +1898,7 @@ ip6_tnl_dev_init_gen(struct net_device *dev) + dev->max_mtu = IP6_MAX_MTU - dev->hard_header_len; + + netdev_hold(dev, &t->dev_tracker, GFP_KERNEL); ++ netdev_lockdep_set_classes(dev); + return 0; + + destroy_dst: +diff --git a/net/ipv6/ip6_vti.c b/net/ipv6/ip6_vti.c +index 73c85d4e0e9cd..04e4368fe4655 100644 +--- a/net/ipv6/ip6_vti.c ++++ b/net/ipv6/ip6_vti.c +@@ -935,6 +935,7 @@ static inline int vti6_dev_init_gen(struct net_device *dev) + if (!dev->tstats) + return -ENOMEM; + netdev_hold(dev, &t->dev_tracker, GFP_KERNEL); ++ netdev_lockdep_set_classes(dev); + return 0; + } + +diff --git a/net/ipv6/sit.c b/net/ipv6/sit.c +index cc24cefdb85c0..eb4c8e2a2b12e 100644 +--- a/net/ipv6/sit.c ++++ b/net/ipv6/sit.c +@@ -1460,6 +1460,7 @@ static int ipip6_tunnel_init(struct net_device *dev) + return err; + } + netdev_hold(dev, &tunnel->dev_tracker, GFP_KERNEL); ++ netdev_lockdep_set_classes(dev); + return 0; + } + +diff --git a/net/mpls/mpls_gso.c b/net/mpls/mpls_gso.c +index 533d082f0701e..45d1e6a157fc7 100644 +--- a/net/mpls/mpls_gso.c ++++ b/net/mpls/mpls_gso.c +@@ -27,6 +27,9 @@ static struct sk_buff *mpls_gso_segment(struct sk_buff *skb, + __be16 mpls_protocol; + unsigned int mpls_hlen; + ++ if (!skb_inner_network_header_was_set(skb)) ++ goto out; ++ + skb_reset_network_header(skb); + mpls_hlen = skb_inner_network_header(skb) - skb_network_header(skb); + if (unlikely(!mpls_hlen || mpls_hlen % MPLS_HLEN)) +diff --git a/net/smc/smc_pnet.c b/net/smc/smc_pnet.c +index 11775401df689..306b536fa89e9 100644 +--- a/net/smc/smc_pnet.c ++++ b/net/smc/smc_pnet.c +@@ -806,6 +806,16 @@ static void smc_pnet_create_pnetids_list(struct net *net) + u8 ndev_pnetid[SMC_MAX_PNETID_LEN]; + struct net_device *dev; + ++ /* Newly created netns do not have devices. ++ * Do not even acquire rtnl. ++ */ ++ if (list_empty(&net->dev_base_head)) ++ return; ++ ++ /* Note: This might not be needed, because smc_pnet_netdev_event() ++ * is also calling smc_pnet_add_base_pnetid() when handling ++ * NETDEV_UP event. ++ */ + rtnl_lock(); + for_each_netdev(net, dev) + smc_pnet_add_base_pnetid(net, dev, ndev_pnetid); +diff --git a/net/wireless/util.c b/net/wireless/util.c +index 1783ab9d57a31..9aa7bdce20b26 100644 +--- a/net/wireless/util.c ++++ b/net/wireless/util.c +@@ -797,15 +797,19 @@ ieee80211_amsdu_subframe_length(void *field, u8 mesh_flags, u8 hdr_type) + + bool ieee80211_is_valid_amsdu(struct sk_buff *skb, u8 mesh_hdr) + { +- int offset = 0, remaining, subframe_len, padding; ++ int offset = 0, subframe_len, padding; + + for (offset = 0; offset < skb->len; offset += subframe_len + padding) { ++ int remaining = skb->len - offset; + struct { + __be16 len; + u8 mesh_flags; + } hdr; + u16 len; + ++ if (sizeof(hdr) > remaining) ++ return false; ++ + if (skb_copy_bits(skb, offset + 2 * ETH_ALEN, &hdr, sizeof(hdr)) < 0) + return false; + +@@ -813,7 +817,6 @@ bool ieee80211_is_valid_amsdu(struct sk_buff *skb, u8 mesh_hdr) + mesh_hdr); + subframe_len = sizeof(struct ethhdr) + len; + padding = (4 - subframe_len) & 0x3; +- remaining = skb->len - offset; + + if (subframe_len > remaining) + return false; +@@ -831,7 +834,7 @@ void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list, + { + unsigned int hlen = ALIGN(extra_headroom, 4); + struct sk_buff *frame = NULL; +- int offset = 0, remaining; ++ int offset = 0; + struct { + struct ethhdr eth; + uint8_t flags; +@@ -845,10 +848,14 @@ void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list, + copy_len = sizeof(hdr); + + while (!last) { ++ int remaining = skb->len - offset; + unsigned int subframe_len; + int len, mesh_len = 0; + u8 padding; + ++ if (copy_len > remaining) ++ goto purge; ++ + skb_copy_bits(skb, offset, &hdr, copy_len); + if (iftype == NL80211_IFTYPE_MESH_POINT) + mesh_len = __ieee80211_get_mesh_hdrlen(hdr.flags); +@@ -858,7 +865,6 @@ void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list, + padding = (4 - subframe_len) & 0x3; + + /* the last MSDU has no padding */ +- remaining = skb->len - offset; + if (subframe_len > remaining) + goto purge; + /* mitigate A-MSDU aggregation injection attacks */ +diff --git a/scripts/gcc-plugins/stackleak_plugin.c b/scripts/gcc-plugins/stackleak_plugin.c +index c5c2ce113c923..d20c47d21ad83 100644 +--- a/scripts/gcc-plugins/stackleak_plugin.c ++++ b/scripts/gcc-plugins/stackleak_plugin.c +@@ -467,6 +467,8 @@ static bool stackleak_gate(void) + return false; + if (STRING_EQUAL(section, ".entry.text")) + return false; ++ if (STRING_EQUAL(section, ".head.text")) ++ return false; + } + + return track_frame_size >= 0; +diff --git a/scripts/mod/modpost.c b/scripts/mod/modpost.c +index 7d53942445d75..269bd79bcd9ad 100644 +--- a/scripts/mod/modpost.c ++++ b/scripts/mod/modpost.c +@@ -1098,7 +1098,9 @@ static void default_mismatch_handler(const char *modname, struct elf_info *elf, + sec_mismatch_count++; + + warn("%s: section mismatch in reference: %s+0x%x (section: %s) -> %s (section: %s)\n", +- modname, fromsym, (unsigned int)(faddr - from->st_value), fromsec, tosym, tosec); ++ modname, fromsym, ++ (unsigned int)(faddr - (from ? from->st_value : 0)), ++ fromsec, tosym, tosec); + + if (mismatch->mismatch == EXTABLE_TO_NON_TEXT) { + if (match(tosec, mismatch->bad_tosec)) +diff --git a/sound/firewire/amdtp-stream.c b/sound/firewire/amdtp-stream.c +index 7be17bca257f0..c9f153f85ae6b 100644 +--- a/sound/firewire/amdtp-stream.c ++++ b/sound/firewire/amdtp-stream.c +@@ -773,10 +773,14 @@ static int check_cip_header(struct amdtp_stream *s, const __be32 *buf, + } else { + unsigned int dbc_interval; + +- if (*data_blocks > 0 && s->ctx_data.tx.dbc_interval > 0) +- dbc_interval = s->ctx_data.tx.dbc_interval; +- else +- dbc_interval = *data_blocks; ++ if (!(s->flags & CIP_DBC_IS_PAYLOAD_QUADLETS)) { ++ if (*data_blocks > 0 && s->ctx_data.tx.dbc_interval > 0) ++ dbc_interval = s->ctx_data.tx.dbc_interval; ++ else ++ dbc_interval = *data_blocks; ++ } else { ++ dbc_interval = payload_length / sizeof(__be32); ++ } + + lost = dbc != ((*data_block_counter + dbc_interval) & 0xff); + } +diff --git a/sound/firewire/amdtp-stream.h b/sound/firewire/amdtp-stream.h +index b7ff44751ab93..a1ed2e80f91a7 100644 +--- a/sound/firewire/amdtp-stream.h ++++ b/sound/firewire/amdtp-stream.h +@@ -37,6 +37,9 @@ + * the value of current SYT_INTERVAL; e.g. initial value is not zero. + * @CIP_UNAWARE_SYT: For outgoing packet, the value in SYT field of CIP is 0xffff. + * For incoming packet, the value in SYT field of CIP is not handled. ++ * @CIP_DBC_IS_PAYLOAD_QUADLETS: Available for incoming packet, and only effective with ++ * CIP_DBC_IS_END_EVENT flag. The value of dbc field is the number of accumulated quadlets ++ * in CIP payload, instead of the number of accumulated data blocks. + */ + enum cip_flags { + CIP_NONBLOCKING = 0x00, +@@ -51,6 +54,7 @@ enum cip_flags { + CIP_NO_HEADER = 0x100, + CIP_UNALIGHED_DBC = 0x200, + CIP_UNAWARE_SYT = 0x400, ++ CIP_DBC_IS_PAYLOAD_QUADLETS = 0x800, + }; + + /** +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index b1c2fb43cab69..6841de9d423e3 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -2645,6 +2645,7 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { + SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS), ++ SND_PCI_QUIRK(0x1558, 0x66a6, "Clevo PE60SN[CDE]-[GS]", 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), +@@ -7428,6 +7429,7 @@ enum { + ALC287_FIXUP_LEGION_16ITHG6, + ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK, + ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, ++ ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN, + ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS, + ALC236_FIXUP_DELL_DUAL_CODECS, + ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI, +@@ -9552,6 +9554,12 @@ static const struct hda_fixup alc269_fixups[] = { + .chained = true, + .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK, + }, ++ [ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = { ++ .type = HDA_FIXUP_FUNC, ++ .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin, ++ .chained = true, ++ .chain_id = ALC287_FIXUP_CS35L41_I2C_2, ++ }, + [ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = { + .type = HDA_FIXUP_FUNC, + .v.func = alc295_fixup_dell_inspiron_top_speakers, +@@ -10090,12 +10098,14 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC), + SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC), + SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK), ++ SND_PCI_QUIRK(0x1558, 0x0353, "Clevo V35[05]SN[CDE]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), ++ SND_PCI_QUIRK(0x1558, 0x2624, "Clevo L240TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), +@@ -10257,6 +10267,8 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C), + SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C), + SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C), ++ SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN), ++ SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN), + SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI), + SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC), + SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI), +diff --git a/sound/soc/amd/yc/acp6x-mach.c b/sound/soc/amd/yc/acp6x-mach.c +index 1d1452c29ed02..69c68d8e7a6b5 100644 +--- a/sound/soc/amd/yc/acp6x-mach.c ++++ b/sound/soc/amd/yc/acp6x-mach.c +@@ -311,6 +311,13 @@ static const struct dmi_system_id yc_acp_quirk_table[] = { + DMI_MATCH(DMI_PRODUCT_NAME, "E1504FA"), + } + }, ++ { ++ .driver_data = &acp6x_card, ++ .matches = { ++ DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK COMPUTER INC."), ++ DMI_MATCH(DMI_PRODUCT_NAME, "M7600RE"), ++ } ++ }, + { + .driver_data = &acp6x_card, + .matches = { +diff --git a/sound/soc/intel/avs/board_selection.c b/sound/soc/intel/avs/board_selection.c +index 59a13feec57b2..0db5e530a8de2 100644 +--- a/sound/soc/intel/avs/board_selection.c ++++ b/sound/soc/intel/avs/board_selection.c +@@ -227,6 +227,82 @@ static struct snd_soc_acpi_mach avs_gml_i2s_machines[] = { + {}, + }; + ++static struct snd_soc_acpi_mach avs_cnl_i2s_machines[] = { ++ { ++ .id = "INT34C2", ++ .drv_name = "avs_rt274", ++ .mach_params = { ++ .i2s_link_mask = AVS_SSP(0), ++ }, ++ .tplg_filename = "rt274-tplg.bin", ++ }, ++ { ++ .id = "10EC5682", ++ .drv_name = "avs_rt5682", ++ .mach_params = { ++ .i2s_link_mask = AVS_SSP(1), ++ }, ++ .tplg_filename = "rt5682-tplg.bin", ++ }, ++ {}, ++}; ++ ++static struct snd_soc_acpi_mach avs_icl_i2s_machines[] = { ++ { ++ .id = "INT343A", ++ .drv_name = "avs_rt298", ++ .mach_params = { ++ .i2s_link_mask = AVS_SSP(0), ++ }, ++ .tplg_filename = "rt298-tplg.bin", ++ }, ++ { ++ .id = "INT34C2", ++ .drv_name = "avs_rt274", ++ .mach_params = { ++ .i2s_link_mask = AVS_SSP(0), ++ }, ++ .tplg_filename = "rt274-tplg.bin", ++ }, ++ {}, ++}; ++ ++static struct snd_soc_acpi_mach avs_tgl_i2s_machines[] = { ++ { ++ .id = "INT34C2", ++ .drv_name = "avs_rt274", ++ .mach_params = { ++ .i2s_link_mask = AVS_SSP(0), ++ }, ++ .tplg_filename = "rt274-tplg.bin", ++ }, ++ { ++ .id = "10EC0298", ++ .drv_name = "avs_rt298", ++ .mach_params = { ++ .i2s_link_mask = AVS_SSP(0), ++ }, ++ .tplg_filename = "rt298-tplg.bin", ++ }, ++ { ++ .id = "10EC1308", ++ .drv_name = "avs_rt1308", ++ .mach_params = { ++ .i2s_link_mask = AVS_SSP(1), ++ }, ++ .tplg_filename = "rt1308-tplg.bin", ++ }, ++ { ++ .id = "ESSX8336", ++ .drv_name = "avs_es8336", ++ .mach_params = { ++ .i2s_link_mask = AVS_SSP(0), ++ }, ++ .tplg_filename = "es8336-tplg.bin", ++ }, ++ {}, ++}; ++ + static struct snd_soc_acpi_mach avs_test_i2s_machines[] = { + { + .drv_name = "avs_i2s_test", +@@ -287,6 +363,15 @@ static const struct avs_acpi_boards i2s_boards[] = { + AVS_MACH_ENTRY(HDA_KBL_LP, avs_kbl_i2s_machines), + AVS_MACH_ENTRY(HDA_APL, avs_apl_i2s_machines), + AVS_MACH_ENTRY(HDA_GML, avs_gml_i2s_machines), ++ AVS_MACH_ENTRY(HDA_CNL_LP, avs_cnl_i2s_machines), ++ AVS_MACH_ENTRY(HDA_CNL_H, avs_cnl_i2s_machines), ++ AVS_MACH_ENTRY(HDA_CML_LP, avs_cnl_i2s_machines), ++ AVS_MACH_ENTRY(HDA_ICL_LP, avs_icl_i2s_machines), ++ AVS_MACH_ENTRY(HDA_TGL_LP, avs_tgl_i2s_machines), ++ AVS_MACH_ENTRY(HDA_EHL_0, avs_tgl_i2s_machines), ++ AVS_MACH_ENTRY(HDA_ADL_P, avs_tgl_i2s_machines), ++ AVS_MACH_ENTRY(HDA_RPL_P_0, avs_tgl_i2s_machines), ++ AVS_MACH_ENTRY(HDA_RPL_M, avs_tgl_i2s_machines), + {}, + }; + +diff --git a/sound/soc/intel/boards/sof_sdw.c b/sound/soc/intel/boards/sof_sdw.c +index 9ed572141fe5b..0ea7812125fee 100644 +--- a/sound/soc/intel/boards/sof_sdw.c ++++ b/sound/soc/intel/boards/sof_sdw.c +@@ -243,6 +243,17 @@ static const struct dmi_system_id sof_sdw_quirk_table[] = { + SOF_SDW_PCH_DMIC | + RT711_JD2_100K), + }, ++ { ++ /* NUC15 LAPRC710 skews */ ++ .callback = sof_sdw_quirk_cb, ++ .matches = { ++ DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"), ++ DMI_MATCH(DMI_BOARD_NAME, "LAPRC710"), ++ }, ++ .driver_data = (void *)(SOF_SDW_TGL_HDMI | ++ SOF_SDW_PCH_DMIC | ++ RT711_JD2_100K), ++ }, + /* TigerLake-SDCA devices */ + { + .callback = sof_sdw_quirk_cb, +diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c +index 9de98c01d8151..e65fe3a7c3e42 100644 +--- a/sound/soc/soc-core.c ++++ b/sound/soc/soc-core.c +@@ -1105,6 +1105,9 @@ static int snd_soc_add_pcm_runtime(struct snd_soc_card *card, + if (!snd_soc_is_matching_component(platform, component)) + continue; + ++ if (snd_soc_component_is_dummy(component) && component->num_dai) ++ continue; ++ + snd_soc_rtd_add_component(rtd, component); + } + } +diff --git a/sound/soc/sof/amd/acp.c b/sound/soc/sof/amd/acp.c +index cc006d7038d97..add386f749ae9 100644 +--- a/sound/soc/sof/amd/acp.c ++++ b/sound/soc/sof/amd/acp.c +@@ -28,11 +28,10 @@ MODULE_PARM_DESC(enable_fw_debug, "Enable Firmware debug"); + + const struct dmi_system_id acp_sof_quirk_table[] = { + { +- /* Valve Jupiter device */ ++ /* Steam Deck OLED device */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Valve"), + DMI_MATCH(DMI_PRODUCT_NAME, "Galileo"), +- DMI_MATCH(DMI_PRODUCT_FAMILY, "Sephiroth"), + }, + .driver_data = (void *)SECURED_FIRMWARE, + }, +diff --git a/tools/iio/iio_utils.c b/tools/iio/iio_utils.c +index 6a00a6eecaef0..c5c5082cb24e5 100644 +--- a/tools/iio/iio_utils.c ++++ b/tools/iio/iio_utils.c +@@ -376,7 +376,7 @@ int build_channel_array(const char *device_dir, int buffer_idx, + goto error_close_dir; + } + +- seekdir(dp, 0); ++ rewinddir(dp); + while (ent = readdir(dp), ent) { + if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"), + "_en") == 0) { +diff --git a/tools/lib/perf/evlist.c b/tools/lib/perf/evlist.c +index b8b066d0dc5e4..ceb34123f38ed 100644 +--- a/tools/lib/perf/evlist.c ++++ b/tools/lib/perf/evlist.c +@@ -248,10 +248,10 @@ u64 perf_evlist__read_format(struct perf_evlist *evlist) + + static void perf_evlist__id_hash(struct perf_evlist *evlist, + struct perf_evsel *evsel, +- int cpu, int thread, u64 id) ++ int cpu_map_idx, int thread, u64 id) + { + int hash; +- struct perf_sample_id *sid = SID(evsel, cpu, thread); ++ struct perf_sample_id *sid = SID(evsel, cpu_map_idx, thread); + + sid->id = id; + sid->evsel = evsel; +@@ -269,21 +269,27 @@ void perf_evlist__reset_id_hash(struct perf_evlist *evlist) + + void perf_evlist__id_add(struct perf_evlist *evlist, + struct perf_evsel *evsel, +- int cpu, int thread, u64 id) ++ int cpu_map_idx, int thread, u64 id) + { +- perf_evlist__id_hash(evlist, evsel, cpu, thread, id); ++ if (!SID(evsel, cpu_map_idx, thread)) ++ return; ++ ++ perf_evlist__id_hash(evlist, evsel, cpu_map_idx, thread, id); + evsel->id[evsel->ids++] = id; + } + + int perf_evlist__id_add_fd(struct perf_evlist *evlist, + struct perf_evsel *evsel, +- int cpu, int thread, int fd) ++ int cpu_map_idx, int thread, int fd) + { + u64 read_data[4] = { 0, }; + int id_idx = 1; /* The first entry is the counter value */ + u64 id; + int ret; + ++ if (!SID(evsel, cpu_map_idx, thread)) ++ return -1; ++ + ret = ioctl(fd, PERF_EVENT_IOC_ID, &id); + if (!ret) + goto add; +@@ -312,7 +318,7 @@ int perf_evlist__id_add_fd(struct perf_evlist *evlist, + id = read_data[id_idx]; + + add: +- perf_evlist__id_add(evlist, evsel, cpu, thread, id); ++ perf_evlist__id_add(evlist, evsel, cpu_map_idx, thread, id); + return 0; + } + +diff --git a/tools/lib/perf/include/internal/evlist.h b/tools/lib/perf/include/internal/evlist.h +index 3339bc2f17655..79e11d71072a0 100644 +--- a/tools/lib/perf/include/internal/evlist.h ++++ b/tools/lib/perf/include/internal/evlist.h +@@ -126,11 +126,11 @@ u64 perf_evlist__read_format(struct perf_evlist *evlist); + + void perf_evlist__id_add(struct perf_evlist *evlist, + struct perf_evsel *evsel, +- int cpu, int thread, u64 id); ++ int cpu_map_idx, int thread, u64 id); + + int perf_evlist__id_add_fd(struct perf_evlist *evlist, + struct perf_evsel *evsel, +- int cpu, int thread, int fd); ++ int cpu_map_idx, int thread, int fd); + + void perf_evlist__reset_id_hash(struct perf_evlist *evlist); + +diff --git a/tools/power/x86/x86_energy_perf_policy/x86_energy_perf_policy.c b/tools/power/x86/x86_energy_perf_policy/x86_energy_perf_policy.c +index 5fd9e594079cf..ebda9c366b2ba 100644 +--- a/tools/power/x86/x86_energy_perf_policy/x86_energy_perf_policy.c ++++ b/tools/power/x86/x86_energy_perf_policy/x86_energy_perf_policy.c +@@ -1241,6 +1241,7 @@ unsigned int get_pkg_num(int cpu) + retval = fscanf(fp, "%d\n", &pkg); + if (retval != 1) + errx(1, "%s: failed to parse", pathname); ++ fclose(fp); + return pkg; + } + +diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl +index 829f5bdfd2e43..24451f8f42910 100755 +--- a/tools/testing/ktest/ktest.pl ++++ b/tools/testing/ktest/ktest.pl +@@ -843,6 +843,7 @@ sub set_value { + if ($lvalue =~ /^(TEST|BISECT|CONFIG_BISECT)_TYPE(\[.*\])?$/ && + $prvalue !~ /^(config_|)bisect$/ && + $prvalue !~ /^build$/ && ++ $prvalue !~ /^make_warnings_file$/ && + $buildonly) { + + # Note if a test is something other than build, then we +diff --git a/tools/testing/selftests/net/mptcp/mptcp_join.sh b/tools/testing/selftests/net/mptcp/mptcp_join.sh +index 00cf4efac4c21..1e1c3d713360e 100755 +--- a/tools/testing/selftests/net/mptcp/mptcp_join.sh ++++ b/tools/testing/selftests/net/mptcp/mptcp_join.sh +@@ -1740,7 +1740,10 @@ chk_rm_nr() + # in case of simult flush, the subflow removal count on each side is + # unreliable + count=$((count + cnt)) +- [ "$count" != "$rm_subflow_nr" ] && suffix="$count in [$rm_subflow_nr:$((rm_subflow_nr*2))]" ++ if [ "$count" != "$rm_subflow_nr" ]; then ++ suffix="$count in [$rm_subflow_nr:$((rm_subflow_nr*2))]" ++ extra_msg="$extra_msg simult" ++ fi + if [ $count -ge "$rm_subflow_nr" ] && \ + [ "$count" -le "$((rm_subflow_nr *2 ))" ]; then + print_ok "$suffix"
