diff options
| author |   Mike Pagano <mpagano@gentoo.org> | 2019-05-08 06:07:37 -0400 |
|---|---|---|
| committer | Mike Pagano <mpagano@gentoo.org> | 2019-05-08 06:07:37 -0400 |
| commit | 25848a16762409a137897779ef10e7684c59c4b5 (patch) | |
| tree | b986c2851661aa3b13bbeb1824cc64296e992a04 | |
| parent | update readme (diff) | |
| download | linux-patches-25848a16.tar.gz linux-patches-25848a16.tar.bz2 linux-patches-25848a16.zip | |
Linux patch 5.0.145.0-15
Signed-off-by: Mike Pagano <mpagano@gentoo.org>
| -rw-r--r-- | 0000_README | 4 | ||||
| -rw-r--r-- | 1013_linux-5.0.14.patch | 4322 |
2 files changed, 4326 insertions, 0 deletions
diff --git a/0000_README b/0000_README index dcd96942..b2a53898 100644 --- a/0000_README +++ b/0000_README @@ -95,6 +95,10 @@ Patch: 1012_linux-5.0.13.patch From: http://www.kernel.org Desc: Linux 5.0.13 +Patch: 1013_linux-5.0.14.patch +From: http://www.kernel.org +Desc: Linux 5.0.14 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1013_linux-5.0.14.patch b/1013_linux-5.0.14.patch new file mode 100644 index 00000000..133615fb --- /dev/null +++ b/1013_linux-5.0.14.patch @@ -0,0 +1,4322 @@ +diff --git a/Documentation/driver-api/usb/power-management.rst b/Documentation/driver-api/usb/power-management.rst +index 79beb807996b..4a74cf6f2797 100644 +--- a/Documentation/driver-api/usb/power-management.rst ++++ b/Documentation/driver-api/usb/power-management.rst +@@ -370,11 +370,15 @@ autosuspend the interface's device. When the usage counter is = 0 + then the interface is considered to be idle, and the kernel may + autosuspend the device. + +-Drivers need not be concerned about balancing changes to the usage +-counter; the USB core will undo any remaining "get"s when a driver +-is unbound from its interface. As a corollary, drivers must not call +-any of the ``usb_autopm_*`` functions after their ``disconnect`` +-routine has returned. ++Drivers must be careful to balance their overall changes to the usage ++counter. Unbalanced "get"s will remain in effect when a driver is ++unbound from its interface, preventing the device from going into ++runtime suspend should the interface be bound to a driver again. On ++the other hand, drivers are allowed to achieve this balance by calling ++the ``usb_autopm_*`` functions even after their ``disconnect`` routine ++has returned -- say from within a work-queue routine -- provided they ++retain an active reference to the interface (via ``usb_get_intf`` and ++``usb_put_intf``). + + Drivers using the async routines are responsible for their own + synchronization and mutual exclusion. +diff --git a/Makefile b/Makefile +index 51a819544505..5ce29665eeed 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 0 +-SUBLEVEL = 13 ++SUBLEVEL = 14 + EXTRAVERSION = + NAME = Shy Crocodile + +diff --git a/arch/arc/lib/memset-archs.S b/arch/arc/lib/memset-archs.S +index f230bb7092fd..b3373f5c88e0 100644 +--- a/arch/arc/lib/memset-archs.S ++++ b/arch/arc/lib/memset-archs.S +@@ -30,10 +30,10 @@ + + #else + +-.macro PREALLOC_INSTR ++.macro PREALLOC_INSTR reg, off + .endm + +-.macro PREFETCHW_INSTR ++.macro PREFETCHW_INSTR reg, off + .endm + + #endif +diff --git a/arch/arm/boot/dts/am33xx-l4.dtsi b/arch/arm/boot/dts/am33xx-l4.dtsi +index 7b818d9d2eab..8396faa9ac28 100644 +--- a/arch/arm/boot/dts/am33xx-l4.dtsi ++++ b/arch/arm/boot/dts/am33xx-l4.dtsi +@@ -1763,7 +1763,7 @@ + reg = <0xcc000 0x4>; + reg-names = "rev"; + /* Domains (P, C): per_pwrdm, l4ls_clkdm */ +- clocks = <&l4ls_clkctrl AM3_D_CAN0_CLKCTRL 0>; ++ clocks = <&l4ls_clkctrl AM3_L4LS_D_CAN0_CLKCTRL 0>; + clock-names = "fck"; + #address-cells = <1>; + #size-cells = <1>; +@@ -1786,7 +1786,7 @@ + reg = <0xd0000 0x4>; + reg-names = "rev"; + /* Domains (P, C): per_pwrdm, l4ls_clkdm */ +- clocks = <&l4ls_clkctrl AM3_D_CAN1_CLKCTRL 0>; ++ clocks = <&l4ls_clkctrl AM3_L4LS_D_CAN1_CLKCTRL 0>; + clock-names = "fck"; + #address-cells = <1>; + #size-cells = <1>; +diff --git a/arch/arm/boot/dts/rk3288.dtsi b/arch/arm/boot/dts/rk3288.dtsi +index 09868dcee34b..df0c5456c94f 100644 +--- a/arch/arm/boot/dts/rk3288.dtsi ++++ b/arch/arm/boot/dts/rk3288.dtsi +@@ -1282,27 +1282,27 @@ + gpu_opp_table: gpu-opp-table { + compatible = "operating-points-v2"; + +- opp@100000000 { ++ opp-100000000 { + opp-hz = /bits/ 64 <100000000>; + opp-microvolt = <950000>; + }; +- opp@200000000 { ++ opp-200000000 { + opp-hz = /bits/ 64 <200000000>; + opp-microvolt = <950000>; + }; +- opp@300000000 { ++ opp-300000000 { + opp-hz = /bits/ 64 <300000000>; + opp-microvolt = <1000000>; + }; +- opp@400000000 { ++ opp-400000000 { + opp-hz = /bits/ 64 <400000000>; + opp-microvolt = <1100000>; + }; +- opp@500000000 { ++ opp-500000000 { + opp-hz = /bits/ 64 <500000000>; + opp-microvolt = <1200000>; + }; +- opp@600000000 { ++ opp-600000000 { + opp-hz = /bits/ 64 <600000000>; + opp-microvolt = <1250000>; + }; +diff --git a/arch/arm/mach-at91/pm.c b/arch/arm/mach-at91/pm.c +index 51e808adb00c..2a757dcaa1a5 100644 +--- a/arch/arm/mach-at91/pm.c ++++ b/arch/arm/mach-at91/pm.c +@@ -591,13 +591,13 @@ static int __init at91_pm_backup_init(void) + + np = of_find_compatible_node(NULL, NULL, "atmel,sama5d2-securam"); + if (!np) +- goto securam_fail; ++ goto securam_fail_no_ref_dev; + + pdev = of_find_device_by_node(np); + of_node_put(np); + if (!pdev) { + pr_warn("%s: failed to find securam device!\n", __func__); +- goto securam_fail; ++ goto securam_fail_no_ref_dev; + } + + sram_pool = gen_pool_get(&pdev->dev, NULL); +@@ -620,6 +620,8 @@ static int __init at91_pm_backup_init(void) + return 0; + + securam_fail: ++ put_device(&pdev->dev); ++securam_fail_no_ref_dev: + iounmap(pm_data.sfrbu); + pm_data.sfrbu = NULL; + return ret; +diff --git a/arch/arm/mach-iop13xx/setup.c b/arch/arm/mach-iop13xx/setup.c +index 53c316f7301e..fe4932fda01d 100644 +--- a/arch/arm/mach-iop13xx/setup.c ++++ b/arch/arm/mach-iop13xx/setup.c +@@ -300,7 +300,7 @@ static struct resource iop13xx_adma_2_resources[] = { + } + }; + +-static u64 iop13xx_adma_dmamask = DMA_BIT_MASK(64); ++static u64 iop13xx_adma_dmamask = DMA_BIT_MASK(32); + static struct iop_adma_platform_data iop13xx_adma_0_data = { + .hw_id = 0, + .pool_size = PAGE_SIZE, +@@ -324,7 +324,7 @@ static struct platform_device iop13xx_adma_0_channel = { + .resource = iop13xx_adma_0_resources, + .dev = { + .dma_mask = &iop13xx_adma_dmamask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + .platform_data = (void *) &iop13xx_adma_0_data, + }, + }; +@@ -336,7 +336,7 @@ static struct platform_device iop13xx_adma_1_channel = { + .resource = iop13xx_adma_1_resources, + .dev = { + .dma_mask = &iop13xx_adma_dmamask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + .platform_data = (void *) &iop13xx_adma_1_data, + }, + }; +@@ -348,7 +348,7 @@ static struct platform_device iop13xx_adma_2_channel = { + .resource = iop13xx_adma_2_resources, + .dev = { + .dma_mask = &iop13xx_adma_dmamask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + .platform_data = (void *) &iop13xx_adma_2_data, + }, + }; +diff --git a/arch/arm/mach-iop13xx/tpmi.c b/arch/arm/mach-iop13xx/tpmi.c +index db511ec2b1df..116feb6b261e 100644 +--- a/arch/arm/mach-iop13xx/tpmi.c ++++ b/arch/arm/mach-iop13xx/tpmi.c +@@ -152,7 +152,7 @@ static struct resource iop13xx_tpmi_3_resources[] = { + } + }; + +-u64 iop13xx_tpmi_mask = DMA_BIT_MASK(64); ++u64 iop13xx_tpmi_mask = DMA_BIT_MASK(32); + static struct platform_device iop13xx_tpmi_0_device = { + .name = "iop-tpmi", + .id = 0, +@@ -160,7 +160,7 @@ static struct platform_device iop13xx_tpmi_0_device = { + .resource = iop13xx_tpmi_0_resources, + .dev = { + .dma_mask = &iop13xx_tpmi_mask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + }, + }; + +@@ -171,7 +171,7 @@ static struct platform_device iop13xx_tpmi_1_device = { + .resource = iop13xx_tpmi_1_resources, + .dev = { + .dma_mask = &iop13xx_tpmi_mask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + }, + }; + +@@ -182,7 +182,7 @@ static struct platform_device iop13xx_tpmi_2_device = { + .resource = iop13xx_tpmi_2_resources, + .dev = { + .dma_mask = &iop13xx_tpmi_mask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + }, + }; + +@@ -193,7 +193,7 @@ static struct platform_device iop13xx_tpmi_3_device = { + .resource = iop13xx_tpmi_3_resources, + .dev = { + .dma_mask = &iop13xx_tpmi_mask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + }, + }; + +diff --git a/arch/arm/mach-omap2/display.c b/arch/arm/mach-omap2/display.c +index 1444b4b4bd9f..439e143cad7b 100644 +--- a/arch/arm/mach-omap2/display.c ++++ b/arch/arm/mach-omap2/display.c +@@ -250,8 +250,10 @@ static int __init omapdss_init_of(void) + if (!node) + return 0; + +- if (!of_device_is_available(node)) ++ if (!of_device_is_available(node)) { ++ of_node_put(node); + return 0; ++ } + + pdev = of_find_device_by_node(node); + +diff --git a/arch/arm/plat-iop/adma.c b/arch/arm/plat-iop/adma.c +index a4d1f8de3b5b..d9612221e484 100644 +--- a/arch/arm/plat-iop/adma.c ++++ b/arch/arm/plat-iop/adma.c +@@ -143,7 +143,7 @@ struct platform_device iop3xx_dma_0_channel = { + .resource = iop3xx_dma_0_resources, + .dev = { + .dma_mask = &iop3xx_adma_dmamask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + .platform_data = (void *) &iop3xx_dma_0_data, + }, + }; +@@ -155,7 +155,7 @@ struct platform_device iop3xx_dma_1_channel = { + .resource = iop3xx_dma_1_resources, + .dev = { + .dma_mask = &iop3xx_adma_dmamask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + .platform_data = (void *) &iop3xx_dma_1_data, + }, + }; +@@ -167,7 +167,7 @@ struct platform_device iop3xx_aau_channel = { + .resource = iop3xx_aau_resources, + .dev = { + .dma_mask = &iop3xx_adma_dmamask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + .platform_data = (void *) &iop3xx_aau_data, + }, + }; +diff --git a/arch/arm/plat-orion/common.c b/arch/arm/plat-orion/common.c +index a2399fd66e97..1e970873439c 100644 +--- a/arch/arm/plat-orion/common.c ++++ b/arch/arm/plat-orion/common.c +@@ -622,7 +622,7 @@ static struct platform_device orion_xor0_shared = { + .resource = orion_xor0_shared_resources, + .dev = { + .dma_mask = &orion_xor_dmamask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + .platform_data = &orion_xor0_pdata, + }, + }; +@@ -683,7 +683,7 @@ static struct platform_device orion_xor1_shared = { + .resource = orion_xor1_shared_resources, + .dev = { + .dma_mask = &orion_xor_dmamask, +- .coherent_dma_mask = DMA_BIT_MASK(64), ++ .coherent_dma_mask = DMA_BIT_MASK(32), + .platform_data = &orion_xor1_pdata, + }, + }; +diff --git a/arch/arm64/boot/dts/rockchip/rk3328-roc-cc.dts b/arch/arm64/boot/dts/rockchip/rk3328-roc-cc.dts +index 99d0d9912950..a91f87df662e 100644 +--- a/arch/arm64/boot/dts/rockchip/rk3328-roc-cc.dts ++++ b/arch/arm64/boot/dts/rockchip/rk3328-roc-cc.dts +@@ -107,8 +107,8 @@ + snps,reset-gpio = <&gpio1 RK_PC2 GPIO_ACTIVE_LOW>; + snps,reset-active-low; + snps,reset-delays-us = <0 10000 50000>; +- tx_delay = <0x25>; +- rx_delay = <0x11>; ++ tx_delay = <0x24>; ++ rx_delay = <0x18>; + status = "okay"; + }; + +diff --git a/arch/arm64/kernel/sdei.c b/arch/arm64/kernel/sdei.c +index 5ba4465e44f0..ea94cf8f9dc6 100644 +--- a/arch/arm64/kernel/sdei.c ++++ b/arch/arm64/kernel/sdei.c +@@ -94,6 +94,9 @@ static bool on_sdei_normal_stack(unsigned long sp, struct stack_info *info) + unsigned long low = (unsigned long)raw_cpu_read(sdei_stack_normal_ptr); + unsigned long high = low + SDEI_STACK_SIZE; + ++ if (!low) ++ return false; ++ + if (sp < low || sp >= high) + return false; + +@@ -111,6 +114,9 @@ static bool on_sdei_critical_stack(unsigned long sp, struct stack_info *info) + unsigned long low = (unsigned long)raw_cpu_read(sdei_stack_critical_ptr); + unsigned long high = low + SDEI_STACK_SIZE; + ++ if (!low) ++ return false; ++ + if (sp < low || sp >= high) + return false; + +diff --git a/arch/powerpc/kernel/kvm.c b/arch/powerpc/kernel/kvm.c +index 683b5b3805bd..cd381e2291df 100644 +--- a/arch/powerpc/kernel/kvm.c ++++ b/arch/powerpc/kernel/kvm.c +@@ -22,6 +22,7 @@ + #include <linux/kvm_host.h> + #include <linux/init.h> + #include <linux/export.h> ++#include <linux/kmemleak.h> + #include <linux/kvm_para.h> + #include <linux/slab.h> + #include <linux/of.h> +@@ -712,6 +713,12 @@ static void kvm_use_magic_page(void) + + static __init void kvm_free_tmp(void) + { ++ /* ++ * Inform kmemleak about the hole in the .bss section since the ++ * corresponding pages will be unmapped with DEBUG_PAGEALLOC=y. ++ */ ++ kmemleak_free_part(&kvm_tmp[kvm_tmp_index], ++ ARRAY_SIZE(kvm_tmp) - kvm_tmp_index); + free_reserved_area(&kvm_tmp[kvm_tmp_index], + &kvm_tmp[ARRAY_SIZE(kvm_tmp)], -1, NULL); + } +diff --git a/arch/powerpc/mm/slice.c b/arch/powerpc/mm/slice.c +index 06898c13901d..aec91dbcdc0b 100644 +--- a/arch/powerpc/mm/slice.c ++++ b/arch/powerpc/mm/slice.c +@@ -32,6 +32,7 @@ + #include <linux/export.h> + #include <linux/hugetlb.h> + #include <linux/sched/mm.h> ++#include <linux/security.h> + #include <asm/mman.h> + #include <asm/mmu.h> + #include <asm/copro.h> +@@ -377,6 +378,7 @@ static unsigned long slice_find_area_topdown(struct mm_struct *mm, + int pshift = max_t(int, mmu_psize_defs[psize].shift, PAGE_SHIFT); + unsigned long addr, found, prev; + struct vm_unmapped_area_info info; ++ unsigned long min_addr = max(PAGE_SIZE, mmap_min_addr); + + info.flags = VM_UNMAPPED_AREA_TOPDOWN; + info.length = len; +@@ -393,7 +395,7 @@ static unsigned long slice_find_area_topdown(struct mm_struct *mm, + if (high_limit > DEFAULT_MAP_WINDOW) + addr += mm->context.slb_addr_limit - DEFAULT_MAP_WINDOW; + +- while (addr > PAGE_SIZE) { ++ while (addr > min_addr) { + info.high_limit = addr; + if (!slice_scan_available(addr - 1, available, 0, &addr)) + continue; +@@ -405,8 +407,8 @@ static unsigned long slice_find_area_topdown(struct mm_struct *mm, + * Check if we need to reduce the range, or if we can + * extend it to cover the previous available slice. + */ +- if (addr < PAGE_SIZE) +- addr = PAGE_SIZE; ++ if (addr < min_addr) ++ addr = min_addr; + else if (slice_scan_available(addr - 1, available, 0, &prev)) { + addr = prev; + goto prev_slice; +@@ -528,7 +530,7 @@ unsigned long slice_get_unmapped_area(unsigned long addr, unsigned long len, + addr = _ALIGN_UP(addr, page_size); + slice_dbg(" aligned addr=%lx\n", addr); + /* Ignore hint if it's too large or overlaps a VMA */ +- if (addr > high_limit - len || ++ if (addr > high_limit - len || addr < mmap_min_addr || + !slice_area_is_free(mm, addr, len)) + addr = 0; + } +diff --git a/arch/riscv/include/asm/uaccess.h b/arch/riscv/include/asm/uaccess.h +index 637b896894fc..aa82df30e38a 100644 +--- a/arch/riscv/include/asm/uaccess.h ++++ b/arch/riscv/include/asm/uaccess.h +@@ -301,7 +301,7 @@ do { \ + " .balign 4\n" \ + "4:\n" \ + " li %0, %6\n" \ +- " jump 2b, %1\n" \ ++ " jump 3b, %1\n" \ + " .previous\n" \ + " .section __ex_table,\"a\"\n" \ + " .balign " RISCV_SZPTR "\n" \ +diff --git a/arch/sh/boards/of-generic.c b/arch/sh/boards/of-generic.c +index 958f46da3a79..d91065e81a4e 100644 +--- a/arch/sh/boards/of-generic.c ++++ b/arch/sh/boards/of-generic.c +@@ -164,10 +164,10 @@ static struct sh_machine_vector __initmv sh_of_generic_mv = { + + struct sh_clk_ops; + +-void __init arch_init_clk_ops(struct sh_clk_ops **ops, int idx) ++void __init __weak arch_init_clk_ops(struct sh_clk_ops **ops, int idx) + { + } + +-void __init plat_irq_setup(void) ++void __init __weak plat_irq_setup(void) + { + } +diff --git a/arch/x86/events/amd/core.c b/arch/x86/events/amd/core.c +index d45f3fbd232e..f15441b07dad 100644 +--- a/arch/x86/events/amd/core.c ++++ b/arch/x86/events/amd/core.c +@@ -116,6 +116,110 @@ static __initconst const u64 amd_hw_cache_event_ids + }, + }; + ++static __initconst const u64 amd_hw_cache_event_ids_f17h ++ [PERF_COUNT_HW_CACHE_MAX] ++ [PERF_COUNT_HW_CACHE_OP_MAX] ++ [PERF_COUNT_HW_CACHE_RESULT_MAX] = { ++[C(L1D)] = { ++ [C(OP_READ)] = { ++ [C(RESULT_ACCESS)] = 0x0040, /* Data Cache Accesses */ ++ [C(RESULT_MISS)] = 0xc860, /* L2$ access from DC Miss */ ++ }, ++ [C(OP_WRITE)] = { ++ [C(RESULT_ACCESS)] = 0, ++ [C(RESULT_MISS)] = 0, ++ }, ++ [C(OP_PREFETCH)] = { ++ [C(RESULT_ACCESS)] = 0xff5a, /* h/w prefetch DC Fills */ ++ [C(RESULT_MISS)] = 0, ++ }, ++}, ++[C(L1I)] = { ++ [C(OP_READ)] = { ++ [C(RESULT_ACCESS)] = 0x0080, /* Instruction cache fetches */ ++ [C(RESULT_MISS)] = 0x0081, /* Instruction cache misses */ ++ }, ++ [C(OP_WRITE)] = { ++ [C(RESULT_ACCESS)] = -1, ++ [C(RESULT_MISS)] = -1, ++ }, ++ [C(OP_PREFETCH)] = { ++ [C(RESULT_ACCESS)] = 0, ++ [C(RESULT_MISS)] = 0, ++ }, ++}, ++[C(LL)] = { ++ [C(OP_READ)] = { ++ [C(RESULT_ACCESS)] = 0, ++ [C(RESULT_MISS)] = 0, ++ }, ++ [C(OP_WRITE)] = { ++ [C(RESULT_ACCESS)] = 0, ++ [C(RESULT_MISS)] = 0, ++ }, ++ [C(OP_PREFETCH)] = { ++ [C(RESULT_ACCESS)] = 0, ++ [C(RESULT_MISS)] = 0, ++ }, ++}, ++[C(DTLB)] = { ++ [C(OP_READ)] = { ++ [C(RESULT_ACCESS)] = 0xff45, /* All L2 DTLB accesses */ ++ [C(RESULT_MISS)] = 0xf045, /* L2 DTLB misses (PT walks) */ ++ }, ++ [C(OP_WRITE)] = { ++ [C(RESULT_ACCESS)] = 0, ++ [C(RESULT_MISS)] = 0, ++ }, ++ [C(OP_PREFETCH)] = { ++ [C(RESULT_ACCESS)] = 0, ++ [C(RESULT_MISS)] = 0, ++ }, ++}, ++[C(ITLB)] = { ++ [C(OP_READ)] = { ++ [C(RESULT_ACCESS)] = 0x0084, /* L1 ITLB misses, L2 ITLB hits */ ++ [C(RESULT_MISS)] = 0xff85, /* L1 ITLB misses, L2 misses */ ++ }, ++ [C(OP_WRITE)] = { ++ [C(RESULT_ACCESS)] = -1, ++ [C(RESULT_MISS)] = -1, ++ }, ++ [C(OP_PREFETCH)] = { ++ [C(RESULT_ACCESS)] = -1, ++ [C(RESULT_MISS)] = -1, ++ }, ++}, ++[C(BPU)] = { ++ [C(OP_READ)] = { ++ [C(RESULT_ACCESS)] = 0x00c2, /* Retired Branch Instr. */ ++ [C(RESULT_MISS)] = 0x00c3, /* Retired Mispredicted BI */ ++ }, ++ [C(OP_WRITE)] = { ++ [C(RESULT_ACCESS)] = -1, ++ [C(RESULT_MISS)] = -1, ++ }, ++ [C(OP_PREFETCH)] = { ++ [C(RESULT_ACCESS)] = -1, ++ [C(RESULT_MISS)] = -1, ++ }, ++}, ++[C(NODE)] = { ++ [C(OP_READ)] = { ++ [C(RESULT_ACCESS)] = 0, ++ [C(RESULT_MISS)] = 0, ++ }, ++ [C(OP_WRITE)] = { ++ [C(RESULT_ACCESS)] = -1, ++ [C(RESULT_MISS)] = -1, ++ }, ++ [C(OP_PREFETCH)] = { ++ [C(RESULT_ACCESS)] = -1, ++ [C(RESULT_MISS)] = -1, ++ }, ++}, ++}; ++ + /* + * AMD Performance Monitor K7 and later, up to and including Family 16h: + */ +@@ -865,9 +969,10 @@ __init int amd_pmu_init(void) + x86_pmu.amd_nb_constraints = 0; + } + +- /* Events are common for all AMDs */ +- memcpy(hw_cache_event_ids, amd_hw_cache_event_ids, +- sizeof(hw_cache_event_ids)); ++ if (boot_cpu_data.x86 >= 0x17) ++ memcpy(hw_cache_event_ids, amd_hw_cache_event_ids_f17h, sizeof(hw_cache_event_ids)); ++ else ++ memcpy(hw_cache_event_ids, amd_hw_cache_event_ids, sizeof(hw_cache_event_ids)); + + return 0; + } +diff --git a/arch/x86/kernel/cpu/mce/severity.c b/arch/x86/kernel/cpu/mce/severity.c +index dc3e26e905a3..65201e180fe0 100644 +--- a/arch/x86/kernel/cpu/mce/severity.c ++++ b/arch/x86/kernel/cpu/mce/severity.c +@@ -165,6 +165,11 @@ static struct severity { + SER, MASK(MCI_STATUS_OVER|MCI_UC_SAR|MCI_ADDR|MCACOD, MCI_UC_SAR|MCI_ADDR|MCACOD_DATA), + KERNEL + ), ++ MCESEV( ++ PANIC, "Instruction fetch error in kernel", ++ SER, MASK(MCI_STATUS_OVER|MCI_UC_SAR|MCI_ADDR|MCACOD, MCI_UC_SAR|MCI_ADDR|MCACOD_INSTR), ++ KERNEL ++ ), + #endif + MCESEV( + PANIC, "Action required: unknown MCACOD", +diff --git a/arch/x86/kvm/lapic.c b/arch/x86/kvm/lapic.c +index 4b6c2da7265c..3339697de6e5 100644 +--- a/arch/x86/kvm/lapic.c ++++ b/arch/x86/kvm/lapic.c +@@ -70,7 +70,6 @@ + #define APIC_BROADCAST 0xFF + #define X2APIC_BROADCAST 0xFFFFFFFFul + +-static bool lapic_timer_advance_adjust_done = false; + #define LAPIC_TIMER_ADVANCE_ADJUST_DONE 100 + /* step-by-step approximation to mitigate fluctuation */ + #define LAPIC_TIMER_ADVANCE_ADJUST_STEP 8 +@@ -1479,14 +1478,32 @@ static bool lapic_timer_int_injected(struct kvm_vcpu *vcpu) + return false; + } + ++static inline void __wait_lapic_expire(struct kvm_vcpu *vcpu, u64 guest_cycles) ++{ ++ u64 timer_advance_ns = vcpu->arch.apic->lapic_timer.timer_advance_ns; ++ ++ /* ++ * If the guest TSC is running at a different ratio than the host, then ++ * convert the delay to nanoseconds to achieve an accurate delay. Note ++ * that __delay() uses delay_tsc whenever the hardware has TSC, thus ++ * always for VMX enabled hardware. ++ */ ++ if (vcpu->arch.tsc_scaling_ratio == kvm_default_tsc_scaling_ratio) { ++ __delay(min(guest_cycles, ++ nsec_to_cycles(vcpu, timer_advance_ns))); ++ } else { ++ u64 delay_ns = guest_cycles * 1000000ULL; ++ do_div(delay_ns, vcpu->arch.virtual_tsc_khz); ++ ndelay(min_t(u32, delay_ns, timer_advance_ns)); ++ } ++} ++ + void wait_lapic_expire(struct kvm_vcpu *vcpu) + { + struct kvm_lapic *apic = vcpu->arch.apic; ++ u32 timer_advance_ns = apic->lapic_timer.timer_advance_ns; + u64 guest_tsc, tsc_deadline, ns; + +- if (!lapic_in_kernel(vcpu)) +- return; +- + if (apic->lapic_timer.expired_tscdeadline == 0) + return; + +@@ -1498,33 +1515,37 @@ void wait_lapic_expire(struct kvm_vcpu *vcpu) + guest_tsc = kvm_read_l1_tsc(vcpu, rdtsc()); + trace_kvm_wait_lapic_expire(vcpu->vcpu_id, guest_tsc - tsc_deadline); + +- /* __delay is delay_tsc whenever the hardware has TSC, thus always. */ + if (guest_tsc < tsc_deadline) +- __delay(min(tsc_deadline - guest_tsc, +- nsec_to_cycles(vcpu, lapic_timer_advance_ns))); ++ __wait_lapic_expire(vcpu, tsc_deadline - guest_tsc); + +- if (!lapic_timer_advance_adjust_done) { ++ if (!apic->lapic_timer.timer_advance_adjust_done) { + /* too early */ + if (guest_tsc < tsc_deadline) { + ns = (tsc_deadline - guest_tsc) * 1000000ULL; + do_div(ns, vcpu->arch.virtual_tsc_khz); +- lapic_timer_advance_ns -= min((unsigned int)ns, +- lapic_timer_advance_ns / LAPIC_TIMER_ADVANCE_ADJUST_STEP); ++ timer_advance_ns -= min((u32)ns, ++ timer_advance_ns / LAPIC_TIMER_ADVANCE_ADJUST_STEP); + } else { + /* too late */ + ns = (guest_tsc - tsc_deadline) * 1000000ULL; + do_div(ns, vcpu->arch.virtual_tsc_khz); +- lapic_timer_advance_ns += min((unsigned int)ns, +- lapic_timer_advance_ns / LAPIC_TIMER_ADVANCE_ADJUST_STEP); ++ timer_advance_ns += min((u32)ns, ++ timer_advance_ns / LAPIC_TIMER_ADVANCE_ADJUST_STEP); + } + if (abs(guest_tsc - tsc_deadline) < LAPIC_TIMER_ADVANCE_ADJUST_DONE) +- lapic_timer_advance_adjust_done = true; ++ apic->lapic_timer.timer_advance_adjust_done = true; ++ if (unlikely(timer_advance_ns > 5000)) { ++ timer_advance_ns = 0; ++ apic->lapic_timer.timer_advance_adjust_done = true; ++ } ++ apic->lapic_timer.timer_advance_ns = timer_advance_ns; + } + } + + static void start_sw_tscdeadline(struct kvm_lapic *apic) + { +- u64 guest_tsc, tscdeadline = apic->lapic_timer.tscdeadline; ++ struct kvm_timer *ktimer = &apic->lapic_timer; ++ u64 guest_tsc, tscdeadline = ktimer->tscdeadline; + u64 ns = 0; + ktime_t expire; + struct kvm_vcpu *vcpu = apic->vcpu; +@@ -1539,13 +1560,15 @@ static void start_sw_tscdeadline(struct kvm_lapic *apic) + + now = ktime_get(); + guest_tsc = kvm_read_l1_tsc(vcpu, rdtsc()); +- if (likely(tscdeadline > guest_tsc)) { +- ns = (tscdeadline - guest_tsc) * 1000000ULL; +- do_div(ns, this_tsc_khz); ++ ++ ns = (tscdeadline - guest_tsc) * 1000000ULL; ++ do_div(ns, this_tsc_khz); ++ ++ if (likely(tscdeadline > guest_tsc) && ++ likely(ns > apic->lapic_timer.timer_advance_ns)) { + expire = ktime_add_ns(now, ns); +- expire = ktime_sub_ns(expire, lapic_timer_advance_ns); +- hrtimer_start(&apic->lapic_timer.timer, +- expire, HRTIMER_MODE_ABS_PINNED); ++ expire = ktime_sub_ns(expire, ktimer->timer_advance_ns); ++ hrtimer_start(&ktimer->timer, expire, HRTIMER_MODE_ABS_PINNED); + } else + apic_timer_expired(apic); + +@@ -2252,7 +2275,7 @@ static enum hrtimer_restart apic_timer_fn(struct hrtimer *data) + return HRTIMER_NORESTART; + } + +-int kvm_create_lapic(struct kvm_vcpu *vcpu) ++int kvm_create_lapic(struct kvm_vcpu *vcpu, int timer_advance_ns) + { + struct kvm_lapic *apic; + +@@ -2276,6 +2299,14 @@ int kvm_create_lapic(struct kvm_vcpu *vcpu) + hrtimer_init(&apic->lapic_timer.timer, CLOCK_MONOTONIC, + HRTIMER_MODE_ABS_PINNED); + apic->lapic_timer.timer.function = apic_timer_fn; ++ if (timer_advance_ns == -1) { ++ apic->lapic_timer.timer_advance_ns = 1000; ++ apic->lapic_timer.timer_advance_adjust_done = false; ++ } else { ++ apic->lapic_timer.timer_advance_ns = timer_advance_ns; ++ apic->lapic_timer.timer_advance_adjust_done = true; ++ } ++ + + /* + * APIC is created enabled. This will prevent kvm_lapic_set_base from +diff --git a/arch/x86/kvm/lapic.h b/arch/x86/kvm/lapic.h +index ff6ef9c3d760..d6d049ba3045 100644 +--- a/arch/x86/kvm/lapic.h ++++ b/arch/x86/kvm/lapic.h +@@ -31,8 +31,10 @@ struct kvm_timer { + u32 timer_mode_mask; + u64 tscdeadline; + u64 expired_tscdeadline; ++ u32 timer_advance_ns; + atomic_t pending; /* accumulated triggered timers */ + bool hv_timer_in_use; ++ bool timer_advance_adjust_done; + }; + + struct kvm_lapic { +@@ -62,7 +64,7 @@ struct kvm_lapic { + + struct dest_map; + +-int kvm_create_lapic(struct kvm_vcpu *vcpu); ++int kvm_create_lapic(struct kvm_vcpu *vcpu, int timer_advance_ns); + void kvm_free_lapic(struct kvm_vcpu *vcpu); + + int kvm_apic_has_interrupt(struct kvm_vcpu *vcpu); +diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c +index e544cec812f9..2a07e43ee666 100644 +--- a/arch/x86/kvm/svm.c ++++ b/arch/x86/kvm/svm.c +@@ -6815,7 +6815,8 @@ static int sev_dbg_crypt(struct kvm *kvm, struct kvm_sev_cmd *argp, bool dec) + struct page **src_p, **dst_p; + struct kvm_sev_dbg debug; + unsigned long n; +- int ret, size; ++ unsigned int size; ++ int ret; + + if (!sev_guest(kvm)) + return -ENOTTY; +@@ -6823,6 +6824,11 @@ static int sev_dbg_crypt(struct kvm *kvm, struct kvm_sev_cmd *argp, bool dec) + if (copy_from_user(&debug, (void __user *)(uintptr_t)argp->data, sizeof(debug))) + return -EFAULT; + ++ if (!debug.len || debug.src_uaddr + debug.len < debug.src_uaddr) ++ return -EINVAL; ++ if (!debug.dst_uaddr) ++ return -EINVAL; ++ + vaddr = debug.src_uaddr; + size = debug.len; + vaddr_end = vaddr + size; +@@ -6873,8 +6879,8 @@ static int sev_dbg_crypt(struct kvm *kvm, struct kvm_sev_cmd *argp, bool dec) + dst_vaddr, + len, &argp->error); + +- sev_unpin_memory(kvm, src_p, 1); +- sev_unpin_memory(kvm, dst_p, 1); ++ sev_unpin_memory(kvm, src_p, n); ++ sev_unpin_memory(kvm, dst_p, n); + + if (ret) + goto err; +diff --git a/arch/x86/kvm/vmx/nested.c b/arch/x86/kvm/vmx/nested.c +index a4bcac94392c..8f8c42b04875 100644 +--- a/arch/x86/kvm/vmx/nested.c ++++ b/arch/x86/kvm/vmx/nested.c +@@ -2793,7 +2793,7 @@ static int nested_vmx_check_vmentry_hw(struct kvm_vcpu *vcpu) + [fail]"i"(offsetof(struct vcpu_vmx, fail)), + [host_rsp]"i"(offsetof(struct vcpu_vmx, host_rsp)), + [wordsize]"i"(sizeof(ulong)) +- : "rax", "cc", "memory" ++ : "cc", "memory" + ); + + preempt_enable(); +diff --git a/arch/x86/kvm/vmx/vmx.c b/arch/x86/kvm/vmx/vmx.c +index e7fe8c692362..da6fdd5434a1 100644 +--- a/arch/x86/kvm/vmx/vmx.c ++++ b/arch/x86/kvm/vmx/vmx.c +@@ -6465,7 +6465,7 @@ static void __vmx_vcpu_run(struct kvm_vcpu *vcpu, struct vcpu_vmx *vmx) + "xor %%edi, %%edi \n\t" + "xor %%ebp, %%ebp \n\t" + "pop %%" _ASM_BP "; pop %%" _ASM_DX " \n\t" +- : ASM_CALL_CONSTRAINT ++ : ASM_CALL_CONSTRAINT, "=S"((int){0}) + : "c"(vmx), "d"((unsigned long)HOST_RSP), "S"(evmcs_rsp), + [launched]"i"(offsetof(struct vcpu_vmx, __launched)), + [fail]"i"(offsetof(struct vcpu_vmx, fail)), +@@ -7133,6 +7133,7 @@ static int vmx_set_hv_timer(struct kvm_vcpu *vcpu, u64 guest_deadline_tsc) + { + struct vcpu_vmx *vmx; + u64 tscl, guest_tscl, delta_tsc, lapic_timer_advance_cycles; ++ struct kvm_timer *ktimer = &vcpu->arch.apic->lapic_timer; + + if (kvm_mwait_in_guest(vcpu->kvm)) + return -EOPNOTSUPP; +@@ -7141,7 +7142,8 @@ static int vmx_set_hv_timer(struct kvm_vcpu *vcpu, u64 guest_deadline_tsc) + tscl = rdtsc(); + guest_tscl = kvm_read_l1_tsc(vcpu, tscl); + delta_tsc = max(guest_deadline_tsc, guest_tscl) - guest_tscl; +- lapic_timer_advance_cycles = nsec_to_cycles(vcpu, lapic_timer_advance_ns); ++ lapic_timer_advance_cycles = nsec_to_cycles(vcpu, ++ ktimer->timer_advance_ns); + + if (delta_tsc > lapic_timer_advance_cycles) + delta_tsc -= lapic_timer_advance_cycles; +diff --git a/arch/x86/kvm/vmx/vmx.h b/arch/x86/kvm/vmx/vmx.h +index 1abae731c3e4..b26cb680ba38 100644 +--- a/arch/x86/kvm/vmx/vmx.h ++++ b/arch/x86/kvm/vmx/vmx.h +@@ -444,7 +444,8 @@ static inline u32 vmx_vmentry_ctrl(void) + { + u32 vmentry_ctrl = vmcs_config.vmentry_ctrl; + if (pt_mode == PT_MODE_SYSTEM) +- vmentry_ctrl &= ~(VM_EXIT_PT_CONCEAL_PIP | VM_EXIT_CLEAR_IA32_RTIT_CTL); ++ vmentry_ctrl &= ~(VM_ENTRY_PT_CONCEAL_PIP | ++ VM_ENTRY_LOAD_IA32_RTIT_CTL); + /* Loading of EFER and PERF_GLOBAL_CTRL are toggled dynamically */ + return vmentry_ctrl & + ~(VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL | VM_ENTRY_LOAD_IA32_EFER); +@@ -454,9 +455,10 @@ static inline u32 vmx_vmexit_ctrl(void) + { + u32 vmexit_ctrl = vmcs_config.vmexit_ctrl; + if (pt_mode == PT_MODE_SYSTEM) +- vmexit_ctrl &= ~(VM_ENTRY_PT_CONCEAL_PIP | VM_ENTRY_LOAD_IA32_RTIT_CTL); ++ vmexit_ctrl &= ~(VM_EXIT_PT_CONCEAL_PIP | ++ VM_EXIT_CLEAR_IA32_RTIT_CTL); + /* Loading of EFER and PERF_GLOBAL_CTRL are toggled dynamically */ +- return vmcs_config.vmexit_ctrl & ++ return vmexit_ctrl & + ~(VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL | VM_EXIT_LOAD_IA32_EFER); + } + +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index 7e413ea19a9a..3eeb7183fc09 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -136,10 +136,14 @@ EXPORT_SYMBOL_GPL(kvm_default_tsc_scaling_ratio); + static u32 __read_mostly tsc_tolerance_ppm = 250; + module_param(tsc_tolerance_ppm, uint, S_IRUGO | S_IWUSR); + +-/* lapic timer advance (tscdeadline mode only) in nanoseconds */ +-unsigned int __read_mostly lapic_timer_advance_ns = 1000; ++/* ++ * lapic timer advance (tscdeadline mode only) in nanoseconds. '-1' enables ++ * adaptive tuning starting from default advancment of 1000ns. '0' disables ++ * advancement entirely. Any other value is used as-is and disables adaptive ++ * tuning, i.e. allows priveleged userspace to set an exact advancement time. ++ */ ++static int __read_mostly lapic_timer_advance_ns = -1; + module_param(lapic_timer_advance_ns, uint, S_IRUGO | S_IWUSR); +-EXPORT_SYMBOL_GPL(lapic_timer_advance_ns); + + static bool __read_mostly vector_hashing = true; + module_param(vector_hashing, bool, S_IRUGO); +@@ -7882,7 +7886,8 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) + } + + trace_kvm_entry(vcpu->vcpu_id); +- if (lapic_timer_advance_ns) ++ if (lapic_in_kernel(vcpu) && ++ vcpu->arch.apic->lapic_timer.timer_advance_ns) + wait_lapic_expire(vcpu); + guest_enter_irqoff(); + +@@ -9070,7 +9075,7 @@ int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) + goto fail_free_pio_data; + + if (irqchip_in_kernel(vcpu->kvm)) { +- r = kvm_create_lapic(vcpu); ++ r = kvm_create_lapic(vcpu, lapic_timer_advance_ns); + if (r < 0) + goto fail_mmu_destroy; + } else +diff --git a/arch/x86/kvm/x86.h b/arch/x86/kvm/x86.h +index de3d46769ee3..b457160dc7ba 100644 +--- a/arch/x86/kvm/x86.h ++++ b/arch/x86/kvm/x86.h +@@ -294,8 +294,6 @@ extern u64 kvm_supported_xcr0(void); + + extern unsigned int min_timer_period_us; + +-extern unsigned int lapic_timer_advance_ns; +- + extern bool enable_vmware_backdoor; + + extern struct static_key kvm_no_apic_vcpu; +diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c +index f905a2371080..8dacdb96899e 100644 +--- a/arch/x86/mm/init.c ++++ b/arch/x86/mm/init.c +@@ -5,6 +5,7 @@ + #include <linux/memblock.h> + #include <linux/swapfile.h> + #include <linux/swapops.h> ++#include <linux/kmemleak.h> + + #include <asm/set_memory.h> + #include <asm/e820/api.h> +@@ -766,6 +767,11 @@ void free_init_pages(const char *what, unsigned long begin, unsigned long end) + if (debug_pagealloc_enabled()) { + pr_info("debug: unmapping init [mem %#010lx-%#010lx]\n", + begin, end - 1); ++ /* ++ * Inform kmemleak about the hole in the memory since the ++ * corresponding pages will be unmapped. ++ */ ++ kmemleak_free_part((void *)begin, end - begin); + set_memory_np(begin, (end - begin) >> PAGE_SHIFT); + } else { + /* +diff --git a/arch/x86/mm/kaslr.c b/arch/x86/mm/kaslr.c +index 3f452ffed7e9..d669c5e797e0 100644 +--- a/arch/x86/mm/kaslr.c ++++ b/arch/x86/mm/kaslr.c +@@ -94,7 +94,7 @@ void __init kernel_randomize_memory(void) + if (!kaslr_memory_enabled()) + return; + +- kaslr_regions[0].size_tb = 1 << (__PHYSICAL_MASK_SHIFT - TB_SHIFT); ++ kaslr_regions[0].size_tb = 1 << (MAX_PHYSMEM_BITS - TB_SHIFT); + kaslr_regions[1].size_tb = VMALLOC_SIZE_TB; + + /* +diff --git a/arch/x86/mm/tlb.c b/arch/x86/mm/tlb.c +index 999d6d8f0bef..9a49335e717a 100644 +--- a/arch/x86/mm/tlb.c ++++ b/arch/x86/mm/tlb.c +@@ -731,7 +731,7 @@ void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start, + { + int cpu; + +- struct flush_tlb_info info __aligned(SMP_CACHE_BYTES) = { ++ struct flush_tlb_info info = { + .mm = mm, + .stride_shift = stride_shift, + .freed_tables = freed_tables, +diff --git a/block/blk-mq.c b/block/blk-mq.c +index 16f9675c57e6..5a2585d69c81 100644 +--- a/block/blk-mq.c ++++ b/block/blk-mq.c +@@ -1716,11 +1716,12 @@ void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule) + unsigned int depth; + + list_splice_init(&plug->mq_list, &list); +- plug->rq_count = 0; + + if (plug->rq_count > 2 && plug->multiple_queues) + list_sort(NULL, &list, plug_rq_cmp); + ++ plug->rq_count = 0; ++ + this_q = NULL; + this_hctx = NULL; + this_ctx = NULL; +@@ -2341,7 +2342,7 @@ static int blk_mq_init_hctx(struct request_queue *q, + return 0; + + free_fq: +- kfree(hctx->fq); ++ blk_free_flush_queue(hctx->fq); + exit_hctx: + if (set->ops->exit_hctx) + set->ops->exit_hctx(hctx, hctx_idx); +diff --git a/drivers/block/null_blk_main.c b/drivers/block/null_blk_main.c +index 62c9654b9ce8..fd7a9be54595 100644 +--- a/drivers/block/null_blk_main.c ++++ b/drivers/block/null_blk_main.c +@@ -1749,6 +1749,11 @@ static int __init null_init(void) + return -EINVAL; + } + ++ if (g_home_node != NUMA_NO_NODE && g_home_node >= nr_online_nodes) { ++ pr_err("null_blk: invalid home_node value\n"); ++ g_home_node = NUMA_NO_NODE; ++ } ++ + if (g_queue_mode == NULL_Q_RQ) { + pr_err("null_blk: legacy IO path no longer available\n"); + return -EINVAL; +diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c +index 87ccef4bd69e..32a21b8d1d85 100644 +--- a/drivers/block/xsysace.c ++++ b/drivers/block/xsysace.c +@@ -1090,6 +1090,8 @@ static int ace_setup(struct ace_device *ace) + return 0; + + err_read: ++ /* prevent double queue cleanup */ ++ ace->gd->queue = NULL; + put_disk(ace->gd); + err_alloc_disk: + blk_cleanup_queue(ace->queue); +diff --git a/drivers/bluetooth/btmtkuart.c b/drivers/bluetooth/btmtkuart.c +index 4593baff2bc9..19eecf198321 100644 +--- a/drivers/bluetooth/btmtkuart.c ++++ b/drivers/bluetooth/btmtkuart.c +@@ -115,11 +115,13 @@ static int mtk_hci_wmt_sync(struct hci_dev *hdev, u8 op, u8 flag, u16 plen, + TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT); + if (err == -EINTR) { + bt_dev_err(hdev, "Execution of wmt command interrupted"); ++ clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state); + return err; + } + + if (err) { + bt_dev_err(hdev, "Execution of wmt command timed out"); ++ clear_bit(BTMTKUART_TX_WAIT_VND_EVT, &bdev->tx_state); + return -ETIMEDOUT; + } + +diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c +index 4761499db9ee..470ee68555d9 100644 +--- a/drivers/bluetooth/btusb.c ++++ b/drivers/bluetooth/btusb.c +@@ -2885,6 +2885,7 @@ static int btusb_config_oob_wake(struct hci_dev *hdev) + return 0; + } + ++ irq_set_status_flags(irq, IRQ_NOAUTOEN); + ret = devm_request_irq(&hdev->dev, irq, btusb_oob_wake_handler, + 0, "OOB Wake-on-BT", data); + if (ret) { +@@ -2899,7 +2900,6 @@ static int btusb_config_oob_wake(struct hci_dev *hdev) + } + + data->oob_wake_irq = irq; +- disable_irq(irq); + bt_dev_info(hdev, "OOB Wake-on-BT configured at IRQ %u", irq); + return 0; + } +diff --git a/drivers/clk/qcom/gcc-msm8998.c b/drivers/clk/qcom/gcc-msm8998.c +index 1b779396e04f..42de947173f8 100644 +--- a/drivers/clk/qcom/gcc-msm8998.c ++++ b/drivers/clk/qcom/gcc-msm8998.c +@@ -1112,6 +1112,7 @@ static struct clk_rcg2 ufs_axi_clk_src = { + + static const struct freq_tbl ftbl_usb30_master_clk_src[] = { + F(19200000, P_XO, 1, 0, 0), ++ F(60000000, P_GPLL0_OUT_MAIN, 10, 0, 0), + F(120000000, P_GPLL0_OUT_MAIN, 5, 0, 0), + F(150000000, P_GPLL0_OUT_MAIN, 4, 0, 0), + { } +diff --git a/drivers/clk/x86/clk-pmc-atom.c b/drivers/clk/x86/clk-pmc-atom.c +index d977193842df..19174835693b 100644 +--- a/drivers/clk/x86/clk-pmc-atom.c ++++ b/drivers/clk/x86/clk-pmc-atom.c +@@ -165,7 +165,7 @@ static const struct clk_ops plt_clk_ops = { + }; + + static struct clk_plt *plt_clk_register(struct platform_device *pdev, int id, +- void __iomem *base, ++ const struct pmc_clk_data *pmc_data, + const char **parent_names, + int num_parents) + { +@@ -184,9 +184,17 @@ static struct clk_plt *plt_clk_register(struct platform_device *pdev, int id, + init.num_parents = num_parents; + + pclk->hw.init = &init; +- pclk->reg = base + PMC_CLK_CTL_OFFSET + id * PMC_CLK_CTL_SIZE; ++ pclk->reg = pmc_data->base + PMC_CLK_CTL_OFFSET + id * PMC_CLK_CTL_SIZE; + spin_lock_init(&pclk->lock); + ++ /* ++ * On some systems, the pmc_plt_clocks already enabled by the ++ * firmware are being marked as critical to avoid them being ++ * gated by the clock framework. ++ */ ++ if (pmc_data->critical && plt_clk_is_enabled(&pclk->hw)) ++ init.flags |= CLK_IS_CRITICAL; ++ + ret = devm_clk_hw_register(&pdev->dev, &pclk->hw); + if (ret) { + pclk = ERR_PTR(ret); +@@ -332,7 +340,7 @@ static int plt_clk_probe(struct platform_device *pdev) + return PTR_ERR(parent_names); + + for (i = 0; i < PMC_CLK_NUM; i++) { +- data->clks[i] = plt_clk_register(pdev, i, pmc_data->base, ++ data->clks[i] = plt_clk_register(pdev, i, pmc_data, + parent_names, data->nparents); + if (IS_ERR(data->clks[i])) { + err = PTR_ERR(data->clks[i]); +diff --git a/drivers/gpio/gpio-mxc.c b/drivers/gpio/gpio-mxc.c +index 2d1dfa1e0745..e86e61dda4b7 100644 +--- a/drivers/gpio/gpio-mxc.c ++++ b/drivers/gpio/gpio-mxc.c +@@ -438,8 +438,11 @@ static int mxc_gpio_probe(struct platform_device *pdev) + + /* the controller clock is optional */ + port->clk = devm_clk_get(&pdev->dev, NULL); +- if (IS_ERR(port->clk)) ++ if (IS_ERR(port->clk)) { ++ if (PTR_ERR(port->clk) == -EPROBE_DEFER) ++ return -EPROBE_DEFER; + port->clk = NULL; ++ } + + err = clk_prepare_enable(port->clk); + if (err) { +diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c +index 9993b692598f..860e21ec6a49 100644 +--- a/drivers/hid/hid-core.c ++++ b/drivers/hid/hid-core.c +@@ -1301,10 +1301,10 @@ static u32 __extract(u8 *report, unsigned offset, int n) + u32 hid_field_extract(const struct hid_device *hid, u8 *report, + unsigned offset, unsigned n) + { +- if (n > 32) { +- hid_warn(hid, "hid_field_extract() called with n (%d) > 32! (%s)\n", ++ if (n > 256) { ++ hid_warn(hid, "hid_field_extract() called with n (%d) > 256! (%s)\n", + n, current->comm); +- n = 32; ++ n = 256; + } + + return __extract(report, offset, n); +diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c +index ac9fda1b5a72..1384e57182af 100644 +--- a/drivers/hid/hid-debug.c ++++ b/drivers/hid/hid-debug.c +@@ -1060,10 +1060,15 @@ static int hid_debug_rdesc_show(struct seq_file *f, void *p) + seq_printf(f, "\n\n"); + + /* dump parsed data and input mappings */ ++ if (down_interruptible(&hdev->driver_input_lock)) ++ return 0; ++ + hid_dump_device(hdev, f); + seq_printf(f, "\n"); + hid_dump_input_mapping(hdev, f); + ++ up(&hdev->driver_input_lock); ++ + return 0; + } + +diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c +index 59a5608b8dc0..ff92a7b2fc89 100644 +--- a/drivers/hid/hid-input.c ++++ b/drivers/hid/hid-input.c +@@ -995,6 +995,7 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel + case 0x1b8: map_key_clear(KEY_VIDEO); break; + case 0x1bc: map_key_clear(KEY_MESSENGER); break; + case 0x1bd: map_key_clear(KEY_INFO); break; ++ case 0x1cb: map_key_clear(KEY_ASSISTANT); break; + case 0x201: map_key_clear(KEY_NEW); break; + case 0x202: map_key_clear(KEY_OPEN); break; + case 0x203: map_key_clear(KEY_CLOSE); break; +diff --git a/drivers/hid/hid-logitech-hidpp.c b/drivers/hid/hid-logitech-hidpp.c +index f040c8a7f9a9..199cc256e9d9 100644 +--- a/drivers/hid/hid-logitech-hidpp.c ++++ b/drivers/hid/hid-logitech-hidpp.c +@@ -2111,6 +2111,13 @@ static int hidpp_ff_init(struct hidpp_device *hidpp, u8 feature_index) + kfree(data); + return -ENOMEM; + } ++ data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue"); ++ if (!data->wq) { ++ kfree(data->effect_ids); ++ kfree(data); ++ return -ENOMEM; ++ } ++ + data->hidpp = hidpp; + data->feature_index = feature_index; + data->version = version; +@@ -2155,7 +2162,6 @@ static int hidpp_ff_init(struct hidpp_device *hidpp, u8 feature_index) + /* ignore boost value at response.fap.params[2] */ + + /* init the hardware command queue */ +- data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue"); + atomic_set(&data->workqueue_size, 0); + + /* initialize with zero autocenter to get wheel in usable state */ +diff --git a/drivers/hid/hid-quirks.c b/drivers/hid/hid-quirks.c +index 94088c0ed68a..e24790c988c0 100644 +--- a/drivers/hid/hid-quirks.c ++++ b/drivers/hid/hid-quirks.c +@@ -744,7 +744,6 @@ static const struct hid_device_id hid_ignore_list[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) }, + { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) }, + { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) }, +- { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, 0x0400) }, + { HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) }, + { HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) }, + { HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) }, +@@ -1025,6 +1024,10 @@ bool hid_ignore(struct hid_device *hdev) + if (hdev->product == 0x0401 && + strncmp(hdev->name, "ELAN0800", 8) != 0) + return true; ++ /* Same with product id 0x0400 */ ++ if (hdev->product == 0x0400 && ++ strncmp(hdev->name, "QTEC0001", 8) != 0) ++ return true; + break; + } + +diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c +index fa9ad53845d9..d4b72e4ffd71 100644 +--- a/drivers/i2c/busses/i2c-imx.c ++++ b/drivers/i2c/busses/i2c-imx.c +@@ -510,9 +510,9 @@ static int i2c_imx_clk_notifier_call(struct notifier_block *nb, + unsigned long action, void *data) + { + struct clk_notifier_data *ndata = data; +- struct imx_i2c_struct *i2c_imx = container_of(&ndata->clk, ++ struct imx_i2c_struct *i2c_imx = container_of(nb, + struct imx_i2c_struct, +- clk); ++ clk_change_nb); + + if (action & POST_RATE_CHANGE) + i2c_imx_set_clk(i2c_imx, ndata->new_rate); +diff --git a/drivers/i2c/busses/i2c-stm32f7.c b/drivers/i2c/busses/i2c-stm32f7.c +index 13e1213561d4..4284fc991cfd 100644 +--- a/drivers/i2c/busses/i2c-stm32f7.c ++++ b/drivers/i2c/busses/i2c-stm32f7.c +@@ -432,7 +432,7 @@ static int stm32f7_i2c_compute_timing(struct stm32f7_i2c_dev *i2c_dev, + STM32F7_I2C_ANALOG_FILTER_DELAY_MAX : 0); + dnf_delay = setup->dnf * i2cclk; + +- sdadel_min = setup->fall_time - i2c_specs[setup->speed].hddat_min - ++ sdadel_min = i2c_specs[setup->speed].hddat_min + setup->fall_time - + af_delay_min - (setup->dnf + 3) * i2cclk; + + sdadel_max = i2c_specs[setup->speed].vddat_max - setup->rise_time - +diff --git a/drivers/i2c/busses/i2c-synquacer.c b/drivers/i2c/busses/i2c-synquacer.c +index 2184b7c3580e..6b8d803bd30e 100644 +--- a/drivers/i2c/busses/i2c-synquacer.c ++++ b/drivers/i2c/busses/i2c-synquacer.c +@@ -602,6 +602,8 @@ static int synquacer_i2c_probe(struct platform_device *pdev) + i2c->adapter = synquacer_i2c_ops; + i2c_set_adapdata(&i2c->adapter, i2c); + i2c->adapter.dev.parent = &pdev->dev; ++ i2c->adapter.dev.of_node = pdev->dev.of_node; ++ ACPI_COMPANION_SET(&i2c->adapter.dev, ACPI_COMPANION(&pdev->dev)); + i2c->adapter.nr = pdev->id; + init_completion(&i2c->completion); + +diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c +index af87a16ac3a5..60fb2afc0e50 100644 +--- a/drivers/i2c/i2c-core-base.c ++++ b/drivers/i2c/i2c-core-base.c +@@ -327,6 +327,8 @@ static int i2c_device_probe(struct device *dev) + + if (client->flags & I2C_CLIENT_HOST_NOTIFY) { + dev_dbg(dev, "Using Host Notify IRQ\n"); ++ /* Keep adapter active when Host Notify is required */ ++ pm_runtime_get_sync(&client->adapter->dev); + irq = i2c_smbus_host_notify_to_irq(client); + } else if (dev->of_node) { + irq = of_irq_get_byname(dev->of_node, "irq"); +@@ -431,6 +433,8 @@ static int i2c_device_remove(struct device *dev) + device_init_wakeup(&client->dev, false); + + client->irq = client->init_irq; ++ if (client->flags & I2C_CLIENT_HOST_NOTIFY) ++ pm_runtime_put(&client->adapter->dev); + + return status; + } +diff --git a/drivers/infiniband/core/security.c b/drivers/infiniband/core/security.c +index 1efadbccf394..7662e9347238 100644 +--- a/drivers/infiniband/core/security.c ++++ b/drivers/infiniband/core/security.c +@@ -710,16 +710,20 @@ int ib_mad_agent_security_setup(struct ib_mad_agent *agent, + dev_name(&agent->device->dev), + agent->port_num); + if (ret) +- return ret; ++ goto free_security; + + agent->lsm_nb.notifier_call = ib_mad_agent_security_change; + ret = register_lsm_notifier(&agent->lsm_nb); + if (ret) +- return ret; ++ goto free_security; + + agent->smp_allowed = true; + agent->lsm_nb_reg = true; + return 0; ++ ++free_security: ++ security_ib_free_security(agent->security); ++ return ret; + } + + void ib_mad_agent_security_cleanup(struct ib_mad_agent *agent) +@@ -727,9 +731,10 @@ void ib_mad_agent_security_cleanup(struct ib_mad_agent *agent) + if (!rdma_protocol_ib(agent->device, agent->port_num)) + return; + +- security_ib_free_security(agent->security); + if (agent->lsm_nb_reg) + unregister_lsm_notifier(&agent->lsm_nb); ++ ++ security_ib_free_security(agent->security); + } + + int ib_mad_enforce_security(struct ib_mad_agent_private *map, u16 pkey_index) +diff --git a/drivers/infiniband/core/verbs.c b/drivers/infiniband/core/verbs.c +index ac011836bb54..3220fb42ecce 100644 +--- a/drivers/infiniband/core/verbs.c ++++ b/drivers/infiniband/core/verbs.c +@@ -1106,8 +1106,8 @@ struct ib_qp *ib_open_qp(struct ib_xrcd *xrcd, + } + EXPORT_SYMBOL(ib_open_qp); + +-static struct ib_qp *ib_create_xrc_qp(struct ib_qp *qp, +- struct ib_qp_init_attr *qp_init_attr) ++static struct ib_qp *create_xrc_qp(struct ib_qp *qp, ++ struct ib_qp_init_attr *qp_init_attr) + { + struct ib_qp *real_qp = qp; + +@@ -1122,10 +1122,10 @@ static struct ib_qp *ib_create_xrc_qp(struct ib_qp *qp, + + qp = __ib_open_qp(real_qp, qp_init_attr->event_handler, + qp_init_attr->qp_context); +- if (!IS_ERR(qp)) +- __ib_insert_xrcd_qp(qp_init_attr->xrcd, real_qp); +- else +- real_qp->device->ops.destroy_qp(real_qp); ++ if (IS_ERR(qp)) ++ return qp; ++ ++ __ib_insert_xrcd_qp(qp_init_attr->xrcd, real_qp); + return qp; + } + +@@ -1156,10 +1156,8 @@ struct ib_qp *ib_create_qp(struct ib_pd *pd, + return qp; + + ret = ib_create_qp_security(qp, device); +- if (ret) { +- ib_destroy_qp(qp); +- return ERR_PTR(ret); +- } ++ if (ret) ++ goto err; + + qp->real_qp = qp; + qp->qp_type = qp_init_attr->qp_type; +@@ -1172,8 +1170,15 @@ struct ib_qp *ib_create_qp(struct ib_pd *pd, + INIT_LIST_HEAD(&qp->sig_mrs); + qp->port = 0; + +- if (qp_init_attr->qp_type == IB_QPT_XRC_TGT) +- return ib_create_xrc_qp(qp, qp_init_attr); ++ if (qp_init_attr->qp_type == IB_QPT_XRC_TGT) { ++ struct ib_qp *xrc_qp = create_xrc_qp(qp, qp_init_attr); ++ ++ if (IS_ERR(xrc_qp)) { ++ ret = PTR_ERR(xrc_qp); ++ goto err; ++ } ++ return xrc_qp; ++ } + + qp->event_handler = qp_init_attr->event_handler; + qp->qp_context = qp_init_attr->qp_context; +@@ -1200,11 +1205,8 @@ struct ib_qp *ib_create_qp(struct ib_pd *pd, + + if (qp_init_attr->cap.max_rdma_ctxs) { + ret = rdma_rw_init_mrs(qp, qp_init_attr); +- if (ret) { +- pr_err("failed to init MR pool ret= %d\n", ret); +- ib_destroy_qp(qp); +- return ERR_PTR(ret); +- } ++ if (ret) ++ goto err; + } + + /* +@@ -1217,6 +1219,11 @@ struct ib_qp *ib_create_qp(struct ib_pd *pd, + device->attrs.max_sge_rd); + + return qp; ++ ++err: ++ ib_destroy_qp(qp); ++ return ERR_PTR(ret); ++ + } + EXPORT_SYMBOL(ib_create_qp); + +diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c +index e9c336cff8f5..f367f3db7ff8 100644 +--- a/drivers/infiniband/ulp/srpt/ib_srpt.c ++++ b/drivers/infiniband/ulp/srpt/ib_srpt.c +@@ -2887,8 +2887,19 @@ static void srpt_queue_tm_rsp(struct se_cmd *cmd) + srpt_queue_response(cmd); + } + ++/* ++ * This function is called for aborted commands if no response is sent to the ++ * initiator. Make sure that the credits freed by aborting a command are ++ * returned to the initiator the next time a response is sent by incrementing ++ * ch->req_lim_delta. ++ */ + static void srpt_aborted_task(struct se_cmd *cmd) + { ++ struct srpt_send_ioctx *ioctx = container_of(cmd, ++ struct srpt_send_ioctx, cmd); ++ struct srpt_rdma_ch *ch = ioctx->ch; ++ ++ atomic_inc(&ch->req_lim_delta); + } + + static int srpt_queue_status(struct se_cmd *cmd) +diff --git a/drivers/input/keyboard/snvs_pwrkey.c b/drivers/input/keyboard/snvs_pwrkey.c +index effb63205d3d..4c67cf30a5d9 100644 +--- a/drivers/input/keyboard/snvs_pwrkey.c ++++ b/drivers/input/keyboard/snvs_pwrkey.c +@@ -148,6 +148,9 @@ static int imx_snvs_pwrkey_probe(struct platform_device *pdev) + return error; + } + ++ pdata->input = input; ++ platform_set_drvdata(pdev, pdata); ++ + error = devm_request_irq(&pdev->dev, pdata->irq, + imx_snvs_pwrkey_interrupt, + 0, pdev->name, pdev); +@@ -163,9 +166,6 @@ static int imx_snvs_pwrkey_probe(struct platform_device *pdev) + return error; + } + +- pdata->input = input; +- platform_set_drvdata(pdev, pdata); +- + device_init_wakeup(&pdev->dev, pdata->wakeup); + + return 0; +diff --git a/drivers/input/touchscreen/stmfts.c b/drivers/input/touchscreen/stmfts.c +index 704e99046916..b6f95f20f924 100644 +--- a/drivers/input/touchscreen/stmfts.c ++++ b/drivers/input/touchscreen/stmfts.c +@@ -106,27 +106,29 @@ struct stmfts_data { + bool running; + }; + +-static void stmfts_brightness_set(struct led_classdev *led_cdev, ++static int stmfts_brightness_set(struct led_classdev *led_cdev, + enum led_brightness value) + { + struct stmfts_data *sdata = container_of(led_cdev, + struct stmfts_data, led_cdev); + int err; + +- if (value == sdata->led_status || !sdata->ledvdd) +- return; +- +- if (!value) { +- regulator_disable(sdata->ledvdd); +- } else { +- err = regulator_enable(sdata->ledvdd); +- if (err) +- dev_warn(&sdata->client->dev, +- "failed to disable ledvdd regulator: %d\n", +- err); ++ if (value != sdata->led_status && sdata->ledvdd) { ++ if (!value) { ++ regulator_disable(sdata->ledvdd); ++ } else { ++ err = regulator_enable(sdata->ledvdd); ++ if (err) { ++ dev_warn(&sdata->client->dev, ++ "failed to disable ledvdd regulator: %d\n", ++ err); ++ return err; ++ } ++ } ++ sdata->led_status = value; + } + +- sdata->led_status = value; ++ return 0; + } + + static enum led_brightness stmfts_brightness_get(struct led_classdev *led_cdev) +@@ -608,7 +610,7 @@ static int stmfts_enable_led(struct stmfts_data *sdata) + sdata->led_cdev.name = STMFTS_DEV_NAME; + sdata->led_cdev.max_brightness = LED_ON; + sdata->led_cdev.brightness = LED_OFF; +- sdata->led_cdev.brightness_set = stmfts_brightness_set; ++ sdata->led_cdev.brightness_set_blocking = stmfts_brightness_set; + sdata->led_cdev.brightness_get = stmfts_brightness_get; + + err = devm_led_classdev_register(&sdata->client->dev, &sdata->led_cdev); +diff --git a/drivers/media/i2c/ov7670.c b/drivers/media/i2c/ov7670.c +index a70a6ff7b36e..4939a83b50e4 100644 +--- a/drivers/media/i2c/ov7670.c ++++ b/drivers/media/i2c/ov7670.c +@@ -160,10 +160,10 @@ MODULE_PARM_DESC(debug, "Debug level (0-1)"); + #define REG_GFIX 0x69 /* Fix gain control */ + + #define REG_DBLV 0x6b /* PLL control an debugging */ +-#define DBLV_BYPASS 0x00 /* Bypass PLL */ +-#define DBLV_X4 0x01 /* clock x4 */ +-#define DBLV_X6 0x10 /* clock x6 */ +-#define DBLV_X8 0x11 /* clock x8 */ ++#define DBLV_BYPASS 0x0a /* Bypass PLL */ ++#define DBLV_X4 0x4a /* clock x4 */ ++#define DBLV_X6 0x8a /* clock x6 */ ++#define DBLV_X8 0xca /* clock x8 */ + + #define REG_SCALING_XSC 0x70 /* Test pattern and horizontal scale factor */ + #define TEST_PATTTERN_0 0x80 +@@ -863,7 +863,7 @@ static int ov7675_set_framerate(struct v4l2_subdev *sd, + if (ret < 0) + return ret; + +- return ov7670_write(sd, REG_DBLV, DBLV_X4); ++ return 0; + } + + static void ov7670_get_framerate_legacy(struct v4l2_subdev *sd, +@@ -1801,11 +1801,7 @@ static int ov7670_probe(struct i2c_client *client, + if (config->clock_speed) + info->clock_speed = config->clock_speed; + +- /* +- * It should be allowed for ov7670 too when it is migrated to +- * the new frame rate formula. +- */ +- if (config->pll_bypass && id->driver_data != MODEL_OV7670) ++ if (config->pll_bypass) + info->pll_bypass = true; + + if (config->pclk_hb_disable) +diff --git a/drivers/mfd/twl-core.c b/drivers/mfd/twl-core.c +index 299016bc46d9..104477b512a2 100644 +--- a/drivers/mfd/twl-core.c ++++ b/drivers/mfd/twl-core.c +@@ -1245,6 +1245,28 @@ free: + return status; + } + ++static int __maybe_unused twl_suspend(struct device *dev) ++{ ++ struct i2c_client *client = to_i2c_client(dev); ++ ++ if (client->irq) ++ disable_irq(client->irq); ++ ++ return 0; ++} ++ ++static int __maybe_unused twl_resume(struct device *dev) ++{ ++ struct i2c_client *client = to_i2c_client(dev); ++ ++ if (client->irq) ++ enable_irq(client->irq); ++ ++ return 0; ++} ++ ++static SIMPLE_DEV_PM_OPS(twl_dev_pm_ops, twl_suspend, twl_resume); ++ + static const struct i2c_device_id twl_ids[] = { + { "twl4030", TWL4030_VAUX2 }, /* "Triton 2" */ + { "twl5030", 0 }, /* T2 updated */ +@@ -1262,6 +1284,7 @@ static const struct i2c_device_id twl_ids[] = { + /* One Client Driver , 4 Clients */ + static struct i2c_driver twl_driver = { + .driver.name = DRIVER_NAME, ++ .driver.pm = &twl_dev_pm_ops, + .id_table = twl_ids, + .probe = twl_probe, + .remove = twl_remove, +diff --git a/drivers/mtd/nand/raw/marvell_nand.c b/drivers/mtd/nand/raw/marvell_nand.c +index 84283c6bb0ff..66a161b8f745 100644 +--- a/drivers/mtd/nand/raw/marvell_nand.c ++++ b/drivers/mtd/nand/raw/marvell_nand.c +@@ -722,12 +722,6 @@ static void marvell_nfc_select_target(struct nand_chip *chip, + struct marvell_nfc *nfc = to_marvell_nfc(chip->controller); + u32 ndcr_generic; + +- if (chip == nfc->selected_chip && die_nr == marvell_nand->selected_die) +- return; +- +- writel_relaxed(marvell_nand->ndtr0, nfc->regs + NDTR0); +- writel_relaxed(marvell_nand->ndtr1, nfc->regs + NDTR1); +- + /* + * Reset the NDCR register to a clean state for this particular chip, + * also clear ND_RUN bit. +@@ -739,6 +733,12 @@ static void marvell_nfc_select_target(struct nand_chip *chip, + /* Also reset the interrupt status register */ + marvell_nfc_clear_int(nfc, NDCR_ALL_INT); + ++ if (chip == nfc->selected_chip && die_nr == marvell_nand->selected_die) ++ return; ++ ++ writel_relaxed(marvell_nand->ndtr0, nfc->regs + NDTR0); ++ writel_relaxed(marvell_nand->ndtr1, nfc->regs + NDTR1); ++ + nfc->selected_chip = chip; + marvell_nand->selected_die = die_nr; + } +diff --git a/drivers/net/bonding/bond_sysfs_slave.c b/drivers/net/bonding/bond_sysfs_slave.c +index 2f120b2ffef0..4985268e2273 100644 +--- a/drivers/net/bonding/bond_sysfs_slave.c ++++ b/drivers/net/bonding/bond_sysfs_slave.c +@@ -55,7 +55,9 @@ static SLAVE_ATTR_RO(link_failure_count); + + static ssize_t perm_hwaddr_show(struct slave *slave, char *buf) + { +- return sprintf(buf, "%pM\n", slave->perm_hwaddr); ++ return sprintf(buf, "%*phC\n", ++ slave->dev->addr_len, ++ slave->perm_hwaddr); + } + static SLAVE_ATTR_RO(perm_hwaddr); + +diff --git a/drivers/net/ethernet/chelsio/libcxgb/libcxgb_ppm.c b/drivers/net/ethernet/chelsio/libcxgb/libcxgb_ppm.c +index 74849be5f004..e2919005ead3 100644 +--- a/drivers/net/ethernet/chelsio/libcxgb/libcxgb_ppm.c ++++ b/drivers/net/ethernet/chelsio/libcxgb/libcxgb_ppm.c +@@ -354,7 +354,10 @@ static struct cxgbi_ppm_pool *ppm_alloc_cpu_pool(unsigned int *total, + ppmax = max; + + /* pool size must be multiple of unsigned long */ +- bmap = BITS_TO_LONGS(ppmax); ++ bmap = ppmax / BITS_PER_TYPE(unsigned long); ++ if (!bmap) ++ return NULL; ++ + ppmax = (bmap * sizeof(unsigned long)) << 3; + + alloc_sz = sizeof(*pools) + sizeof(unsigned long) * bmap; +@@ -402,6 +405,10 @@ int cxgbi_ppm_init(void **ppm_pp, struct net_device *ndev, + if (reserve_factor) { + ppmax_pool = ppmax / reserve_factor; + pool = ppm_alloc_cpu_pool(&ppmax_pool, &pool_index_max); ++ if (!pool) { ++ ppmax_pool = 0; ++ reserve_factor = 0; ++ } + + pr_debug("%s: ppmax %u, cpu total %u, per cpu %u.\n", + ndev->name, ppmax, ppmax_pool, pool_index_max); +diff --git a/drivers/net/ethernet/hisilicon/hns/hnae.c b/drivers/net/ethernet/hisilicon/hns/hnae.c +index 79d03f8ee7b1..c7fa97a7e1f4 100644 +--- a/drivers/net/ethernet/hisilicon/hns/hnae.c ++++ b/drivers/net/ethernet/hisilicon/hns/hnae.c +@@ -150,7 +150,6 @@ out_buffer_fail: + /* free desc along with its attached buffer */ + static void hnae_free_desc(struct hnae_ring *ring) + { +- hnae_free_buffers(ring); + dma_unmap_single(ring_to_dev(ring), ring->desc_dma_addr, + ring->desc_num * sizeof(ring->desc[0]), + ring_to_dma_dir(ring)); +@@ -183,6 +182,9 @@ static int hnae_alloc_desc(struct hnae_ring *ring) + /* fini ring, also free the buffer for the ring */ + static void hnae_fini_ring(struct hnae_ring *ring) + { ++ if (is_rx_ring(ring)) ++ hnae_free_buffers(ring); ++ + hnae_free_desc(ring); + kfree(ring->desc_cb); + ring->desc_cb = NULL; +diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c +index ac55db065f16..f5ff07cb2b72 100644 +--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c ++++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c +@@ -2750,6 +2750,17 @@ int hns_dsaf_get_regs_count(void) + return DSAF_DUMP_REGS_NUM; + } + ++static int hns_dsaf_get_port_id(u8 port) ++{ ++ if (port < DSAF_SERVICE_NW_NUM) ++ return port; ++ ++ if (port >= DSAF_BASE_INNER_PORT_NUM) ++ return port - DSAF_BASE_INNER_PORT_NUM + DSAF_SERVICE_NW_NUM; ++ ++ return -EINVAL; ++} ++ + static void set_promisc_tcam_enable(struct dsaf_device *dsaf_dev, u32 port) + { + struct dsaf_tbl_tcam_ucast_cfg tbl_tcam_ucast = {0, 1, 0, 0, 0x80}; +@@ -2815,23 +2826,33 @@ static void set_promisc_tcam_enable(struct dsaf_device *dsaf_dev, u32 port) + memset(&temp_key, 0x0, sizeof(temp_key)); + mask_entry.addr[0] = 0x01; + hns_dsaf_set_mac_key(dsaf_dev, &mask_key, mask_entry.in_vlan_id, +- port, mask_entry.addr); ++ 0xf, mask_entry.addr); + tbl_tcam_mcast.tbl_mcast_item_vld = 1; + tbl_tcam_mcast.tbl_mcast_old_en = 0; + +- if (port < DSAF_SERVICE_NW_NUM) { +- mskid = port; +- } else if (port >= DSAF_BASE_INNER_PORT_NUM) { +- mskid = port - DSAF_BASE_INNER_PORT_NUM + DSAF_SERVICE_NW_NUM; +- } else { ++ /* set MAC port to handle multicast */ ++ mskid = hns_dsaf_get_port_id(port); ++ if (mskid == -EINVAL) { + dev_err(dsaf_dev->dev, "%s,pnum(%d)error,key(%#x:%#x)\n", + dsaf_dev->ae_dev.name, port, + mask_key.high.val, mask_key.low.val); + return; + } ++ dsaf_set_bit(tbl_tcam_mcast.tbl_mcast_port_msk[mskid / 32], ++ mskid % 32, 1); + ++ /* set pool bit map to handle multicast */ ++ mskid = hns_dsaf_get_port_id(port_num); ++ if (mskid == -EINVAL) { ++ dev_err(dsaf_dev->dev, ++ "%s, pool bit map pnum(%d)error,key(%#x:%#x)\n", ++ dsaf_dev->ae_dev.name, port_num, ++ mask_key.high.val, mask_key.low.val); ++ return; ++ } + dsaf_set_bit(tbl_tcam_mcast.tbl_mcast_port_msk[mskid / 32], + mskid % 32, 1); ++ + memcpy(&temp_key, &mask_key, sizeof(mask_key)); + hns_dsaf_tcam_mc_cfg_vague(dsaf_dev, entry_index, &tbl_tcam_data_mc, + (struct dsaf_tbl_tcam_data *)(&mask_key), +diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_xgmac.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_xgmac.c +index ba4316910dea..a60f207768fc 100644 +--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_xgmac.c ++++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_xgmac.c +@@ -129,7 +129,7 @@ static void hns_xgmac_lf_rf_control_init(struct mac_driver *mac_drv) + dsaf_set_bit(val, XGMAC_UNIDIR_EN_B, 0); + dsaf_set_bit(val, XGMAC_RF_TX_EN_B, 1); + dsaf_set_field(val, XGMAC_LF_RF_INSERT_M, XGMAC_LF_RF_INSERT_S, 0); +- dsaf_write_reg(mac_drv, XGMAC_MAC_TX_LF_RF_CONTROL_REG, val); ++ dsaf_write_dev(mac_drv, XGMAC_MAC_TX_LF_RF_CONTROL_REG, val); + } + + /** +diff --git a/drivers/net/ethernet/hisilicon/hns/hns_enet.c b/drivers/net/ethernet/hisilicon/hns/hns_enet.c +index 60e7d7ae3787..4cd86ba1f050 100644 +--- a/drivers/net/ethernet/hisilicon/hns/hns_enet.c ++++ b/drivers/net/ethernet/hisilicon/hns/hns_enet.c +@@ -29,9 +29,6 @@ + + #define SERVICE_TIMER_HZ (1 * HZ) + +-#define NIC_TX_CLEAN_MAX_NUM 256 +-#define NIC_RX_CLEAN_MAX_NUM 64 +- + #define RCB_IRQ_NOT_INITED 0 + #define RCB_IRQ_INITED 1 + #define HNS_BUFFER_SIZE_2048 2048 +@@ -376,8 +373,6 @@ netdev_tx_t hns_nic_net_xmit_hw(struct net_device *ndev, + wmb(); /* commit all data before submit */ + assert(skb->queue_mapping < priv->ae_handle->q_num); + hnae_queue_xmit(priv->ae_handle->qs[skb->queue_mapping], buf_num); +- ring->stats.tx_pkts++; +- ring->stats.tx_bytes += skb->len; + + return NETDEV_TX_OK; + +@@ -999,6 +994,9 @@ static int hns_nic_tx_poll_one(struct hns_nic_ring_data *ring_data, + /* issue prefetch for next Tx descriptor */ + prefetch(&ring->desc_cb[ring->next_to_clean]); + } ++ /* update tx ring statistics. */ ++ ring->stats.tx_pkts += pkts; ++ ring->stats.tx_bytes += bytes; + + NETIF_TX_UNLOCK(ring); + +@@ -2152,7 +2150,7 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv) + hns_nic_tx_fini_pro_v2; + + netif_napi_add(priv->netdev, &rd->napi, +- hns_nic_common_poll, NIC_TX_CLEAN_MAX_NUM); ++ hns_nic_common_poll, NAPI_POLL_WEIGHT); + rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED; + } + for (i = h->q_num; i < h->q_num * 2; i++) { +@@ -2165,7 +2163,7 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv) + hns_nic_rx_fini_pro_v2; + + netif_napi_add(priv->netdev, &rd->napi, +- hns_nic_common_poll, NIC_RX_CLEAN_MAX_NUM); ++ hns_nic_common_poll, NAPI_POLL_WEIGHT); + rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED; + } + +diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/Makefile b/drivers/net/ethernet/hisilicon/hns3/hns3pf/Makefile +index fffe8c1c45d3..0fb61d440d3b 100644 +--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/Makefile ++++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/Makefile +@@ -3,7 +3,7 @@ + # Makefile for the HISILICON network device drivers. + # + +-ccflags-y := -Idrivers/net/ethernet/hisilicon/hns3 ++ccflags-y := -I $(srctree)/drivers/net/ethernet/hisilicon/hns3 + + obj-$(CONFIG_HNS3_HCLGE) += hclge.o + hclge-objs = hclge_main.o hclge_cmd.o hclge_mdio.o hclge_tm.o hclge_mbx.o hclge_err.o hclge_debugfs.o +diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3vf/Makefile b/drivers/net/ethernet/hisilicon/hns3/hns3vf/Makefile +index fb93bbd35845..6193f8fa7cf3 100644 +--- a/drivers/net/ethernet/hisilicon/hns3/hns3vf/Makefile ++++ b/drivers/net/ethernet/hisilicon/hns3/hns3vf/Makefile +@@ -3,7 +3,7 @@ + # Makefile for the HISILICON network device drivers. + # + +-ccflags-y := -Idrivers/net/ethernet/hisilicon/hns3 ++ccflags-y := -I $(srctree)/drivers/net/ethernet/hisilicon/hns3 + + obj-$(CONFIG_HNS3_HCLGEVF) += hclgevf.o + hclgevf-objs = hclgevf_main.o hclgevf_cmd.o hclgevf_mbx.o +\ No newline at end of file +diff --git a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c +index a6bc7847346b..5d544e661445 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c +@@ -2378,8 +2378,7 @@ static int i40e_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) + return -EOPNOTSUPP; + + /* only magic packet is supported */ +- if (wol->wolopts && (wol->wolopts != WAKE_MAGIC) +- | (wol->wolopts != WAKE_FILTER)) ++ if (wol->wolopts & ~WAKE_MAGIC) + return -EOPNOTSUPP; + + /* is this a new value? */ +diff --git a/drivers/net/ethernet/intel/i40e/i40e_ptp.c b/drivers/net/ethernet/intel/i40e/i40e_ptp.c +index 5fb4353c742b..31575c0bb884 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_ptp.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_ptp.c +@@ -146,12 +146,13 @@ static int i40e_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb) + static int i40e_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta) + { + struct i40e_pf *pf = container_of(ptp, struct i40e_pf, ptp_caps); +- struct timespec64 now; ++ struct timespec64 now, then; + ++ then = ns_to_timespec64(delta); + mutex_lock(&pf->tmreg_lock); + + i40e_ptp_read(pf, &now, NULL); +- timespec64_add_ns(&now, delta); ++ now = timespec64_add(now, then); + i40e_ptp_write(pf, (const struct timespec64 *)&now); + + mutex_unlock(&pf->tmreg_lock); +diff --git a/drivers/net/ethernet/intel/igb/e1000_defines.h b/drivers/net/ethernet/intel/igb/e1000_defines.h +index 01fcfc6f3415..d2e2c50ce257 100644 +--- a/drivers/net/ethernet/intel/igb/e1000_defines.h ++++ b/drivers/net/ethernet/intel/igb/e1000_defines.h +@@ -194,6 +194,8 @@ + /* enable link status from external LINK_0 and LINK_1 pins */ + #define E1000_CTRL_SWDPIN0 0x00040000 /* SWDPIN 0 value */ + #define E1000_CTRL_SWDPIN1 0x00080000 /* SWDPIN 1 value */ ++#define E1000_CTRL_ADVD3WUC 0x00100000 /* D3 WUC */ ++#define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000 /* PHY PM enable */ + #define E1000_CTRL_SDP0_DIR 0x00400000 /* SDP0 Data direction */ + #define E1000_CTRL_SDP1_DIR 0x00800000 /* SDP1 Data direction */ + #define E1000_CTRL_RST 0x04000000 /* Global reset */ +diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c +index 7137e7f9c7f3..21ccadb720d1 100644 +--- a/drivers/net/ethernet/intel/igb/igb_main.c ++++ b/drivers/net/ethernet/intel/igb/igb_main.c +@@ -8755,9 +8755,7 @@ static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, + struct e1000_hw *hw = &adapter->hw; + u32 ctrl, rctl, status; + u32 wufc = runtime ? E1000_WUFC_LNKC : adapter->wol; +-#ifdef CONFIG_PM +- int retval = 0; +-#endif ++ bool wake; + + rtnl_lock(); + netif_device_detach(netdev); +@@ -8770,14 +8768,6 @@ static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, + igb_clear_interrupt_scheme(adapter); + rtnl_unlock(); + +-#ifdef CONFIG_PM +- if (!runtime) { +- retval = pci_save_state(pdev); +- if (retval) +- return retval; +- } +-#endif +- + status = rd32(E1000_STATUS); + if (status & E1000_STATUS_LU) + wufc &= ~E1000_WUFC_LNKC; +@@ -8794,10 +8784,6 @@ static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, + } + + ctrl = rd32(E1000_CTRL); +- /* advertise wake from D3Cold */ +- #define E1000_CTRL_ADVD3WUC 0x00100000 +- /* phy power management enable */ +- #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000 + ctrl |= E1000_CTRL_ADVD3WUC; + wr32(E1000_CTRL, ctrl); + +@@ -8811,12 +8797,15 @@ static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, + wr32(E1000_WUFC, 0); + } + +- *enable_wake = wufc || adapter->en_mng_pt; +- if (!*enable_wake) ++ wake = wufc || adapter->en_mng_pt; ++ if (!wake) + igb_power_down_link(adapter); + else + igb_power_up_link(adapter); + ++ if (enable_wake) ++ *enable_wake = wake; ++ + /* Release control of h/w to f/w. If f/w is AMT enabled, this + * would have already happened in close and is redundant. + */ +@@ -8859,22 +8848,7 @@ static void igb_deliver_wake_packet(struct net_device *netdev) + + static int __maybe_unused igb_suspend(struct device *dev) + { +- int retval; +- bool wake; +- struct pci_dev *pdev = to_pci_dev(dev); +- +- retval = __igb_shutdown(pdev, &wake, 0); +- if (retval) +- return retval; +- +- if (wake) { +- pci_prepare_to_sleep(pdev); +- } else { +- pci_wake_from_d3(pdev, false); +- pci_set_power_state(pdev, PCI_D3hot); +- } +- +- return 0; ++ return __igb_shutdown(to_pci_dev(dev), NULL, 0); + } + + static int __maybe_unused igb_resume(struct device *dev) +@@ -8945,22 +8919,7 @@ static int __maybe_unused igb_runtime_idle(struct device *dev) + + static int __maybe_unused igb_runtime_suspend(struct device *dev) + { +- struct pci_dev *pdev = to_pci_dev(dev); +- int retval; +- bool wake; +- +- retval = __igb_shutdown(pdev, &wake, 1); +- if (retval) +- return retval; +- +- if (wake) { +- pci_prepare_to_sleep(pdev); +- } else { +- pci_wake_from_d3(pdev, false); +- pci_set_power_state(pdev, PCI_D3hot); +- } +- +- return 0; ++ return __igb_shutdown(to_pci_dev(dev), NULL, 1); + } + + static int __maybe_unused igb_runtime_resume(struct device *dev) +diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.c +index cc4907f9ff02..2fb97967961c 100644 +--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.c ++++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.c +@@ -905,13 +905,12 @@ s32 ixgbe_mii_bus_init(struct ixgbe_hw *hw) + struct pci_dev *pdev = adapter->pdev; + struct device *dev = &adapter->netdev->dev; + struct mii_bus *bus; ++ int err = -ENODEV; + +- adapter->mii_bus = devm_mdiobus_alloc(dev); +- if (!adapter->mii_bus) ++ bus = devm_mdiobus_alloc(dev); ++ if (!bus) + return -ENOMEM; + +- bus = adapter->mii_bus; +- + switch (hw->device_id) { + /* C3000 SoCs */ + case IXGBE_DEV_ID_X550EM_A_KR: +@@ -949,12 +948,15 @@ s32 ixgbe_mii_bus_init(struct ixgbe_hw *hw) + */ + hw->phy.mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_SUPPORTS_C22; + +- return mdiobus_register(bus); ++ err = mdiobus_register(bus); ++ if (!err) { ++ adapter->mii_bus = bus; ++ return 0; ++ } + + ixgbe_no_mii_bus: + devm_mdiobus_free(dev, bus); +- adapter->mii_bus = NULL; +- return -ENODEV; ++ return err; + } + + /** +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/eswitch.c b/drivers/net/ethernet/mellanox/mlx5/core/eswitch.c +index 13c48883ed61..619f96940b65 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/eswitch.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/eswitch.c +@@ -81,8 +81,7 @@ static int arm_vport_context_events_cmd(struct mlx5_core_dev *dev, u16 vport, + opcode, MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT); + MLX5_SET(modify_nic_vport_context_in, in, field_select.change_event, 1); + MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport); +- if (vport) +- MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1); ++ MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1); + nic_vport_ctx = MLX5_ADDR_OF(modify_nic_vport_context_in, + in, nic_vport_context); + +@@ -110,8 +109,7 @@ static int modify_esw_vport_context_cmd(struct mlx5_core_dev *dev, u16 vport, + MLX5_SET(modify_esw_vport_context_in, in, opcode, + MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT); + MLX5_SET(modify_esw_vport_context_in, in, vport_number, vport); +- if (vport) +- MLX5_SET(modify_esw_vport_context_in, in, other_vport, 1); ++ MLX5_SET(modify_esw_vport_context_in, in, other_vport, 1); + return mlx5_cmd_exec(dev, in, inlen, out, sizeof(out)); + } + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c b/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c +index d4e6fe5b9300..ce5766a26baa 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c +@@ -1402,6 +1402,7 @@ int esw_offloads_init(struct mlx5_eswitch *esw, int nvports) + { + int err; + ++ memset(&esw->fdb_table.offloads, 0, sizeof(struct offloads_fdb)); + mutex_init(&esw->fdb_table.offloads.fdb_prio_lock); + + err = esw_create_offloads_fdb_tables(esw, nvports); +diff --git a/drivers/net/ethernet/stmicro/stmmac/descs_com.h b/drivers/net/ethernet/stmicro/stmmac/descs_com.h +index 40d6356a7e73..3dfb07a78952 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/descs_com.h ++++ b/drivers/net/ethernet/stmicro/stmmac/descs_com.h +@@ -29,11 +29,13 @@ + /* Specific functions used for Ring mode */ + + /* Enhanced descriptors */ +-static inline void ehn_desc_rx_set_on_ring(struct dma_desc *p, int end) ++static inline void ehn_desc_rx_set_on_ring(struct dma_desc *p, int end, ++ int bfsize) + { +- p->des1 |= cpu_to_le32((BUF_SIZE_8KiB +- << ERDES1_BUFFER2_SIZE_SHIFT) +- & ERDES1_BUFFER2_SIZE_MASK); ++ if (bfsize == BUF_SIZE_16KiB) ++ p->des1 |= cpu_to_le32((BUF_SIZE_8KiB ++ << ERDES1_BUFFER2_SIZE_SHIFT) ++ & ERDES1_BUFFER2_SIZE_MASK); + + if (end) + p->des1 |= cpu_to_le32(ERDES1_END_RING); +@@ -59,11 +61,15 @@ static inline void enh_set_tx_desc_len_on_ring(struct dma_desc *p, int len) + } + + /* Normal descriptors */ +-static inline void ndesc_rx_set_on_ring(struct dma_desc *p, int end) ++static inline void ndesc_rx_set_on_ring(struct dma_desc *p, int end, int bfsize) + { +- p->des1 |= cpu_to_le32(((BUF_SIZE_2KiB - 1) +- << RDES1_BUFFER2_SIZE_SHIFT) +- & RDES1_BUFFER2_SIZE_MASK); ++ if (bfsize >= BUF_SIZE_2KiB) { ++ int bfsize2; ++ ++ bfsize2 = min(bfsize - BUF_SIZE_2KiB + 1, BUF_SIZE_2KiB - 1); ++ p->des1 |= cpu_to_le32((bfsize2 << RDES1_BUFFER2_SIZE_SHIFT) ++ & RDES1_BUFFER2_SIZE_MASK); ++ } + + if (end) + p->des1 |= cpu_to_le32(RDES1_END_RING); +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.c b/drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.c +index 736e29635b77..313a58b68fee 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.c +@@ -296,7 +296,7 @@ exit: + } + + static void dwmac4_rd_init_rx_desc(struct dma_desc *p, int disable_rx_ic, +- int mode, int end) ++ int mode, int end, int bfsize) + { + dwmac4_set_rx_owner(p, disable_rx_ic); + } +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_descs.c b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_descs.c +index 1d858fdec997..98fa471da7c0 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_descs.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_descs.c +@@ -123,7 +123,7 @@ static int dwxgmac2_get_rx_timestamp_status(void *desc, void *next_desc, + } + + static void dwxgmac2_init_rx_desc(struct dma_desc *p, int disable_rx_ic, +- int mode, int end) ++ int mode, int end, int bfsize) + { + dwxgmac2_set_rx_owner(p, disable_rx_ic); + } +diff --git a/drivers/net/ethernet/stmicro/stmmac/enh_desc.c b/drivers/net/ethernet/stmicro/stmmac/enh_desc.c +index 5ef91a790f9d..5202d6ad7919 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/enh_desc.c ++++ b/drivers/net/ethernet/stmicro/stmmac/enh_desc.c +@@ -201,6 +201,11 @@ static int enh_desc_get_rx_status(void *data, struct stmmac_extra_stats *x, + if (unlikely(rdes0 & RDES0_OWN)) + return dma_own; + ++ if (unlikely(!(rdes0 & RDES0_LAST_DESCRIPTOR))) { ++ stats->rx_length_errors++; ++ return discard_frame; ++ } ++ + if (unlikely(rdes0 & RDES0_ERROR_SUMMARY)) { + if (unlikely(rdes0 & RDES0_DESCRIPTOR_ERROR)) { + x->rx_desc++; +@@ -231,9 +236,10 @@ static int enh_desc_get_rx_status(void *data, struct stmmac_extra_stats *x, + * It doesn't match with the information reported into the databook. + * At any rate, we need to understand if the CSUM hw computation is ok + * and report this info to the upper layers. */ +- ret = enh_desc_coe_rdes0(!!(rdes0 & RDES0_IPC_CSUM_ERROR), +- !!(rdes0 & RDES0_FRAME_TYPE), +- !!(rdes0 & ERDES0_RX_MAC_ADDR)); ++ if (likely(ret == good_frame)) ++ ret = enh_desc_coe_rdes0(!!(rdes0 & RDES0_IPC_CSUM_ERROR), ++ !!(rdes0 & RDES0_FRAME_TYPE), ++ !!(rdes0 & ERDES0_RX_MAC_ADDR)); + + if (unlikely(rdes0 & RDES0_DRIBBLING)) + x->dribbling_bit++; +@@ -259,15 +265,19 @@ static int enh_desc_get_rx_status(void *data, struct stmmac_extra_stats *x, + } + + static void enh_desc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, +- int mode, int end) ++ int mode, int end, int bfsize) + { ++ int bfsize1; ++ + p->des0 |= cpu_to_le32(RDES0_OWN); +- p->des1 |= cpu_to_le32(BUF_SIZE_8KiB & ERDES1_BUFFER1_SIZE_MASK); ++ ++ bfsize1 = min(bfsize, BUF_SIZE_8KiB); ++ p->des1 |= cpu_to_le32(bfsize1 & ERDES1_BUFFER1_SIZE_MASK); + + if (mode == STMMAC_CHAIN_MODE) + ehn_desc_rx_set_on_chain(p); + else +- ehn_desc_rx_set_on_ring(p, end); ++ ehn_desc_rx_set_on_ring(p, end, bfsize); + + if (disable_rx_ic) + p->des1 |= cpu_to_le32(ERDES1_DISABLE_IC); +diff --git a/drivers/net/ethernet/stmicro/stmmac/hwif.h b/drivers/net/ethernet/stmicro/stmmac/hwif.h +index 92b8944f26e3..5bb00234d961 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/hwif.h ++++ b/drivers/net/ethernet/stmicro/stmmac/hwif.h +@@ -33,7 +33,7 @@ struct dma_extended_desc; + struct stmmac_desc_ops { + /* DMA RX descriptor ring initialization */ + void (*init_rx_desc)(struct dma_desc *p, int disable_rx_ic, int mode, +- int end); ++ int end, int bfsize); + /* DMA TX descriptor ring initialization */ + void (*init_tx_desc)(struct dma_desc *p, int mode, int end); + /* Invoked by the xmit function to prepare the tx descriptor */ +diff --git a/drivers/net/ethernet/stmicro/stmmac/norm_desc.c b/drivers/net/ethernet/stmicro/stmmac/norm_desc.c +index de65bb29feba..b7dd4e3c760d 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/norm_desc.c ++++ b/drivers/net/ethernet/stmicro/stmmac/norm_desc.c +@@ -91,8 +91,6 @@ static int ndesc_get_rx_status(void *data, struct stmmac_extra_stats *x, + return dma_own; + + if (unlikely(!(rdes0 & RDES0_LAST_DESCRIPTOR))) { +- pr_warn("%s: Oversized frame spanned multiple buffers\n", +- __func__); + stats->rx_length_errors++; + return discard_frame; + } +@@ -135,15 +133,19 @@ static int ndesc_get_rx_status(void *data, struct stmmac_extra_stats *x, + } + + static void ndesc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, int mode, +- int end) ++ int end, int bfsize) + { ++ int bfsize1; ++ + p->des0 |= cpu_to_le32(RDES0_OWN); +- p->des1 |= cpu_to_le32((BUF_SIZE_2KiB - 1) & RDES1_BUFFER1_SIZE_MASK); ++ ++ bfsize1 = min(bfsize, BUF_SIZE_2KiB - 1); ++ p->des1 |= cpu_to_le32(bfsize & RDES1_BUFFER1_SIZE_MASK); + + if (mode == STMMAC_CHAIN_MODE) + ndesc_rx_set_on_chain(p, end); + else +- ndesc_rx_set_on_ring(p, end); ++ ndesc_rx_set_on_ring(p, end, bfsize); + + if (disable_rx_ic) + p->des1 |= cpu_to_le32(RDES1_DISABLE_IC); +diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +index 0bc3632880b5..f0e0593e54f3 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c ++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +@@ -1114,11 +1114,13 @@ static void stmmac_clear_rx_descriptors(struct stmmac_priv *priv, u32 queue) + if (priv->extend_desc) + stmmac_init_rx_desc(priv, &rx_q->dma_erx[i].basic, + priv->use_riwt, priv->mode, +- (i == DMA_RX_SIZE - 1)); ++ (i == DMA_RX_SIZE - 1), ++ priv->dma_buf_sz); + else + stmmac_init_rx_desc(priv, &rx_q->dma_rx[i], + priv->use_riwt, priv->mode, +- (i == DMA_RX_SIZE - 1)); ++ (i == DMA_RX_SIZE - 1), ++ priv->dma_buf_sz); + } + + /** +@@ -3326,9 +3328,8 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) + { + struct stmmac_rx_queue *rx_q = &priv->rx_queue[queue]; + struct stmmac_channel *ch = &priv->channel[queue]; +- unsigned int entry = rx_q->cur_rx; ++ unsigned int next_entry = rx_q->cur_rx; + int coe = priv->hw->rx_csum; +- unsigned int next_entry; + unsigned int count = 0; + bool xmac; + +@@ -3346,10 +3347,12 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) + stmmac_display_ring(priv, rx_head, DMA_RX_SIZE, true); + } + while (count < limit) { +- int status; ++ int entry, status; + struct dma_desc *p; + struct dma_desc *np; + ++ entry = next_entry; ++ + if (priv->extend_desc) + p = (struct dma_desc *)(rx_q->dma_erx + entry); + else +@@ -3405,11 +3408,12 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) + * ignored + */ + if (frame_len > priv->dma_buf_sz) { +- netdev_err(priv->dev, +- "len %d larger than size (%d)\n", +- frame_len, priv->dma_buf_sz); ++ if (net_ratelimit()) ++ netdev_err(priv->dev, ++ "len %d larger than size (%d)\n", ++ frame_len, priv->dma_buf_sz); + priv->dev->stats.rx_length_errors++; +- break; ++ continue; + } + + /* ACS is set; GMAC core strips PAD/FCS for IEEE 802.3 +@@ -3444,7 +3448,7 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) + dev_warn(priv->device, + "packet dropped\n"); + priv->dev->stats.rx_dropped++; +- break; ++ continue; + } + + dma_sync_single_for_cpu(priv->device, +@@ -3464,11 +3468,12 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) + } else { + skb = rx_q->rx_skbuff[entry]; + if (unlikely(!skb)) { +- netdev_err(priv->dev, +- "%s: Inconsistent Rx chain\n", +- priv->dev->name); ++ if (net_ratelimit()) ++ netdev_err(priv->dev, ++ "%s: Inconsistent Rx chain\n", ++ priv->dev->name); + priv->dev->stats.rx_dropped++; +- break; ++ continue; + } + prefetch(skb->data - NET_IP_ALIGN); + rx_q->rx_skbuff[entry] = NULL; +@@ -3503,7 +3508,6 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) + priv->dev->stats.rx_packets++; + priv->dev->stats.rx_bytes += frame_len; + } +- entry = next_entry; + } + + stmmac_rx_refill(priv, queue); +diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/5000.c b/drivers/net/wireless/intel/iwlwifi/cfg/5000.c +index 575a7022d045..3846064d51a5 100644 +--- a/drivers/net/wireless/intel/iwlwifi/cfg/5000.c ++++ b/drivers/net/wireless/intel/iwlwifi/cfg/5000.c +@@ -1,7 +1,7 @@ + /****************************************************************************** + * + * Copyright(c) 2007 - 2014 Intel Corporation. All rights reserved. +- * Copyright(c) 2018 Intel Corporation ++ * Copyright(c) 2018 - 2019 Intel Corporation + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of version 2 of the GNU General Public License as +@@ -136,6 +136,7 @@ const struct iwl_cfg iwl5350_agn_cfg = { + .ht_params = &iwl5000_ht_params, + .led_mode = IWL_LED_BLINK, + .internal_wimax_coex = true, ++ .csr = &iwl_csr_v1, + }; + + #define IWL_DEVICE_5150 \ +diff --git a/drivers/net/wireless/marvell/mwifiex/sdio.c b/drivers/net/wireless/marvell/mwifiex/sdio.c +index d49fbd58afa7..bfbe3aa058d9 100644 +--- a/drivers/net/wireless/marvell/mwifiex/sdio.c ++++ b/drivers/net/wireless/marvell/mwifiex/sdio.c +@@ -181,7 +181,7 @@ static int mwifiex_sdio_resume(struct device *dev) + + adapter = card->adapter; + +- if (test_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags)) { ++ if (!test_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags)) { + mwifiex_dbg(adapter, WARN, + "device already resumed\n"); + return 0; +diff --git a/drivers/platform/x86/intel_pmc_core.c b/drivers/platform/x86/intel_pmc_core.c +index a9cbe5be277b..e88e183914af 100644 +--- a/drivers/platform/x86/intel_pmc_core.c ++++ b/drivers/platform/x86/intel_pmc_core.c +@@ -205,7 +205,7 @@ static const struct pmc_bit_map cnp_pfear_map[] = { + {"CNVI", BIT(3)}, + {"UFS0", BIT(4)}, + {"EMMC", BIT(5)}, +- {"Res_6", BIT(6)}, ++ {"SPF", BIT(6)}, + {"SBR6", BIT(7)}, + + {"SBR7", BIT(0)}, +@@ -802,7 +802,7 @@ static int __init pmc_core_probe(void) + * Sunrisepoint PCH regmap can't be used. Use Cannonlake PCH regmap + * in this case. + */ +- if (!pci_dev_present(pmc_pci_ids)) ++ if (pmcdev->map == &spt_reg_map && !pci_dev_present(pmc_pci_ids)) + pmcdev->map = &cnp_reg_map; + + if (lpit_read_residency_count_address(&slp_s0_addr)) +diff --git a/drivers/platform/x86/pmc_atom.c b/drivers/platform/x86/pmc_atom.c +index 8f018b3f3cd4..eaec2d306481 100644 +--- a/drivers/platform/x86/pmc_atom.c ++++ b/drivers/platform/x86/pmc_atom.c +@@ -17,6 +17,7 @@ + + #include <linux/debugfs.h> + #include <linux/device.h> ++#include <linux/dmi.h> + #include <linux/init.h> + #include <linux/io.h> + #include <linux/platform_data/x86/clk-pmc-atom.h> +@@ -391,11 +392,27 @@ static int pmc_dbgfs_register(struct pmc_dev *pmc) + } + #endif /* CONFIG_DEBUG_FS */ + ++/* ++ * Some systems need one or more of their pmc_plt_clks to be ++ * marked as critical. ++ */ ++static const struct dmi_system_id critclk_systems[] __initconst = { ++ { ++ .ident = "MPL CEC1x", ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "MPL AG"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "CEC10 Family"), ++ }, ++ }, ++ { /*sentinel*/ } ++}; ++ + static int pmc_setup_clks(struct pci_dev *pdev, void __iomem *pmc_regmap, + const struct pmc_data *pmc_data) + { + struct platform_device *clkdev; + struct pmc_clk_data *clk_data; ++ const struct dmi_system_id *d = dmi_first_match(critclk_systems); + + clk_data = kzalloc(sizeof(*clk_data), GFP_KERNEL); + if (!clk_data) +@@ -403,6 +420,10 @@ static int pmc_setup_clks(struct pci_dev *pdev, void __iomem *pmc_regmap, + + clk_data->base = pmc_regmap; /* offset is added by client */ + clk_data->clks = pmc_data->clks; ++ if (d) { ++ clk_data->critical = true; ++ pr_info("%s critclks quirk enabled\n", d->ident); ++ } + + clkdev = platform_device_register_data(&pdev->dev, "clk-pmc-atom", + PLATFORM_DEVID_NONE, +diff --git a/drivers/reset/reset-meson-audio-arb.c b/drivers/reset/reset-meson-audio-arb.c +index 91751617b37a..c53a2185a039 100644 +--- a/drivers/reset/reset-meson-audio-arb.c ++++ b/drivers/reset/reset-meson-audio-arb.c +@@ -130,6 +130,7 @@ static int meson_audio_arb_probe(struct platform_device *pdev) + arb->rstc.nr_resets = ARRAY_SIZE(axg_audio_arb_reset_bits); + arb->rstc.ops = &meson_audio_arb_rstc_ops; + arb->rstc.of_node = dev->of_node; ++ arb->rstc.owner = THIS_MODULE; + + /* + * Enable general : +diff --git a/drivers/rtc/rtc-cros-ec.c b/drivers/rtc/rtc-cros-ec.c +index e5444296075e..4d6bf9304ceb 100644 +--- a/drivers/rtc/rtc-cros-ec.c ++++ b/drivers/rtc/rtc-cros-ec.c +@@ -298,7 +298,7 @@ static int cros_ec_rtc_suspend(struct device *dev) + struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev); + + if (device_may_wakeup(dev)) +- enable_irq_wake(cros_ec_rtc->cros_ec->irq); ++ return enable_irq_wake(cros_ec_rtc->cros_ec->irq); + + return 0; + } +@@ -309,7 +309,7 @@ static int cros_ec_rtc_resume(struct device *dev) + struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev); + + if (device_may_wakeup(dev)) +- disable_irq_wake(cros_ec_rtc->cros_ec->irq); ++ return disable_irq_wake(cros_ec_rtc->cros_ec->irq); + + return 0; + } +diff --git a/drivers/rtc/rtc-da9063.c b/drivers/rtc/rtc-da9063.c +index b4e054c64bad..69b54e5556c0 100644 +--- a/drivers/rtc/rtc-da9063.c ++++ b/drivers/rtc/rtc-da9063.c +@@ -480,6 +480,13 @@ static int da9063_rtc_probe(struct platform_device *pdev) + da9063_data_to_tm(data, &rtc->alarm_time, rtc); + rtc->rtc_sync = false; + ++ /* ++ * TODO: some models have alarms on a minute boundary but still support ++ * real hardware interrupts. Add this once the core supports it. ++ */ ++ if (config->rtc_data_start != RTC_SEC) ++ rtc->rtc_dev->uie_unsupported = 1; ++ + irq_alarm = platform_get_irq_byname(pdev, "ALARM"); + ret = devm_request_threaded_irq(&pdev->dev, irq_alarm, NULL, + da9063_alarm_event, +diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c +index d417b203cbc5..1d3de2a3d1a4 100644 +--- a/drivers/rtc/rtc-sh.c ++++ b/drivers/rtc/rtc-sh.c +@@ -374,7 +374,7 @@ static int sh_rtc_set_time(struct device *dev, struct rtc_time *tm) + static inline int sh_rtc_read_alarm_value(struct sh_rtc *rtc, int reg_off) + { + unsigned int byte; +- int value = 0xff; /* return 0xff for ignored values */ ++ int value = -1; /* return -1 for ignored values */ + + byte = readb(rtc->regbase + reg_off); + if (byte & AR_ENB) { +diff --git a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c +index e0570fd8466e..45e52dd870c8 100644 +--- a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c ++++ b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c +@@ -1033,8 +1033,8 @@ static void prep_ssp_v3_hw(struct hisi_hba *hisi_hba, + struct sas_ssp_task *ssp_task = &task->ssp_task; + struct scsi_cmnd *scsi_cmnd = ssp_task->cmd; + struct hisi_sas_tmf_task *tmf = slot->tmf; +- unsigned char prot_op = scsi_get_prot_op(scsi_cmnd); + int has_data = 0, priority = !!tmf; ++ unsigned char prot_op; + u8 *buf_cmd; + u32 dw1 = 0, dw2 = 0, len = 0; + +@@ -1049,6 +1049,7 @@ static void prep_ssp_v3_hw(struct hisi_hba *hisi_hba, + dw1 |= 2 << CMD_HDR_FRAME_TYPE_OFF; + dw1 |= DIR_NO_DATA << CMD_HDR_DIR_OFF; + } else { ++ prot_op = scsi_get_prot_op(scsi_cmnd); + dw1 |= 1 << CMD_HDR_FRAME_TYPE_OFF; + switch (scsi_cmnd->sc_data_direction) { + case DMA_TO_DEVICE: +diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c +index c4cbfd07b916..a08ff3bd6310 100644 +--- a/drivers/scsi/scsi_devinfo.c ++++ b/drivers/scsi/scsi_devinfo.c +@@ -238,6 +238,7 @@ static struct { + {"NETAPP", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, + {"LSI", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, + {"ENGENIO", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, ++ {"LENOVO", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, + {"SMSC", "USB 2 HS-CF", NULL, BLIST_SPARSELUN | BLIST_INQUIRY_36}, + {"SONY", "CD-ROM CDU-8001", NULL, BLIST_BORKEN}, + {"SONY", "TSL", NULL, BLIST_FORCELUN}, /* DDS3 & DDS4 autoloaders */ +diff --git a/drivers/scsi/scsi_dh.c b/drivers/scsi/scsi_dh.c +index 5a58cbf3a75d..c14006ac98f9 100644 +--- a/drivers/scsi/scsi_dh.c ++++ b/drivers/scsi/scsi_dh.c +@@ -75,6 +75,7 @@ static const struct scsi_dh_blist scsi_dh_blist[] = { + {"NETAPP", "INF-01-00", "rdac", }, + {"LSI", "INF-01-00", "rdac", }, + {"ENGENIO", "INF-01-00", "rdac", }, ++ {"LENOVO", "DE_Series", "rdac", }, + {NULL, NULL, NULL }, + }; + +diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c +index 84380bae20f1..e186743033f4 100644 +--- a/drivers/scsi/storvsc_drv.c ++++ b/drivers/scsi/storvsc_drv.c +@@ -668,13 +668,22 @@ static void handle_multichannel_storage(struct hv_device *device, int max_chns) + { + struct device *dev = &device->device; + struct storvsc_device *stor_device; +- int num_cpus = num_online_cpus(); + int num_sc; + struct storvsc_cmd_request *request; + struct vstor_packet *vstor_packet; + int ret, t; + +- num_sc = ((max_chns > num_cpus) ? num_cpus : max_chns); ++ /* ++ * If the number of CPUs is artificially restricted, such as ++ * with maxcpus=1 on the kernel boot line, Hyper-V could offer ++ * sub-channels >= the number of CPUs. These sub-channels ++ * should not be created. The primary channel is already created ++ * and assigned to one CPU, so check against # CPUs - 1. ++ */ ++ num_sc = min((int)(num_online_cpus() - 1), max_chns); ++ if (!num_sc) ++ return; ++ + stor_device = get_out_stor_device(device); + if (!stor_device) + return; +diff --git a/drivers/staging/iio/addac/adt7316.c b/drivers/staging/iio/addac/adt7316.c +index 7839d869d25d..ecbb29e2153e 100644 +--- a/drivers/staging/iio/addac/adt7316.c ++++ b/drivers/staging/iio/addac/adt7316.c +@@ -47,6 +47,8 @@ + #define ADT7516_MSB_AIN3 0xA + #define ADT7516_MSB_AIN4 0xB + #define ADT7316_DA_DATA_BASE 0x10 ++#define ADT7316_DA_10_BIT_LSB_SHIFT 6 ++#define ADT7316_DA_12_BIT_LSB_SHIFT 4 + #define ADT7316_DA_MSB_DATA_REGS 4 + #define ADT7316_LSB_DAC_A 0x10 + #define ADT7316_MSB_DAC_A 0x11 +@@ -632,9 +634,7 @@ static ssize_t adt7316_show_da_high_resolution(struct device *dev, + struct adt7316_chip_info *chip = iio_priv(dev_info); + + if (chip->config3 & ADT7316_DA_HIGH_RESOLUTION) { +- if (chip->id == ID_ADT7316 || chip->id == ID_ADT7516) +- return sprintf(buf, "1 (12 bits)\n"); +- if (chip->id == ID_ADT7317 || chip->id == ID_ADT7517) ++ if (chip->id != ID_ADT7318 && chip->id != ID_ADT7519) + return sprintf(buf, "1 (10 bits)\n"); + } + +@@ -651,10 +651,12 @@ static ssize_t adt7316_store_da_high_resolution(struct device *dev, + u8 config3; + int ret; + ++ if (chip->id == ID_ADT7318 || chip->id == ID_ADT7519) ++ return -EPERM; ++ ++ config3 = chip->config3 & (~ADT7316_DA_HIGH_RESOLUTION); + if (buf[0] == '1') +- config3 = chip->config3 | ADT7316_DA_HIGH_RESOLUTION; +- else +- config3 = chip->config3 & (~ADT7316_DA_HIGH_RESOLUTION); ++ config3 |= ADT7316_DA_HIGH_RESOLUTION; + + ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3); + if (ret) +@@ -1079,7 +1081,7 @@ static ssize_t adt7316_store_DAC_internal_Vref(struct device *dev, + ldac_config = chip->ldac_config & (~ADT7516_DAC_IN_VREF_MASK); + if (data & 0x1) + ldac_config |= ADT7516_DAC_AB_IN_VREF; +- else if (data & 0x2) ++ if (data & 0x2) + ldac_config |= ADT7516_DAC_CD_IN_VREF; + } else { + ret = kstrtou8(buf, 16, &data); +@@ -1403,7 +1405,7 @@ static IIO_DEVICE_ATTR(ex_analog_temp_offset, 0644, + static ssize_t adt7316_show_DAC(struct adt7316_chip_info *chip, + int channel, char *buf) + { +- u16 data; ++ u16 data = 0; + u8 msb, lsb, offset; + int ret; + +@@ -1428,7 +1430,11 @@ static ssize_t adt7316_show_DAC(struct adt7316_chip_info *chip, + if (ret) + return -EIO; + +- data = (msb << offset) + (lsb & ((1 << offset) - 1)); ++ if (chip->dac_bits == 12) ++ data = lsb >> ADT7316_DA_12_BIT_LSB_SHIFT; ++ else if (chip->dac_bits == 10) ++ data = lsb >> ADT7316_DA_10_BIT_LSB_SHIFT; ++ data |= msb << offset; + + return sprintf(buf, "%d\n", data); + } +@@ -1436,7 +1442,7 @@ static ssize_t adt7316_show_DAC(struct adt7316_chip_info *chip, + static ssize_t adt7316_store_DAC(struct adt7316_chip_info *chip, + int channel, const char *buf, size_t len) + { +- u8 msb, lsb, offset; ++ u8 msb, lsb, lsb_reg, offset; + u16 data; + int ret; + +@@ -1454,9 +1460,13 @@ static ssize_t adt7316_store_DAC(struct adt7316_chip_info *chip, + return -EINVAL; + + if (chip->dac_bits > 8) { +- lsb = data & (1 << offset); ++ lsb = data & ((1 << offset) - 1); ++ if (chip->dac_bits == 12) ++ lsb_reg = lsb << ADT7316_DA_12_BIT_LSB_SHIFT; ++ else ++ lsb_reg = lsb << ADT7316_DA_10_BIT_LSB_SHIFT; + ret = chip->bus.write(chip->bus.client, +- ADT7316_DA_DATA_BASE + channel * 2, lsb); ++ ADT7316_DA_DATA_BASE + channel * 2, lsb_reg); + if (ret) + return -EIO; + } +diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c +index 8987cec9549d..ebcadaad89d1 100644 +--- a/drivers/usb/core/driver.c ++++ b/drivers/usb/core/driver.c +@@ -473,11 +473,6 @@ static int usb_unbind_interface(struct device *dev) + pm_runtime_disable(dev); + pm_runtime_set_suspended(dev); + +- /* Undo any residual pm_autopm_get_interface_* calls */ +- for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r) +- usb_autopm_put_interface_no_suspend(intf); +- atomic_set(&intf->pm_usage_cnt, 0); +- + if (!error) + usb_autosuspend_device(udev); + +@@ -1633,7 +1628,6 @@ void usb_autopm_put_interface(struct usb_interface *intf) + int status; + + usb_mark_last_busy(udev); +- atomic_dec(&intf->pm_usage_cnt); + status = pm_runtime_put_sync(&intf->dev); + dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", + __func__, atomic_read(&intf->dev.power.usage_count), +@@ -1662,7 +1656,6 @@ void usb_autopm_put_interface_async(struct usb_interface *intf) + int status; + + usb_mark_last_busy(udev); +- atomic_dec(&intf->pm_usage_cnt); + status = pm_runtime_put(&intf->dev); + dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", + __func__, atomic_read(&intf->dev.power.usage_count), +@@ -1684,7 +1677,6 @@ void usb_autopm_put_interface_no_suspend(struct usb_interface *intf) + struct usb_device *udev = interface_to_usbdev(intf); + + usb_mark_last_busy(udev); +- atomic_dec(&intf->pm_usage_cnt); + pm_runtime_put_noidle(&intf->dev); + } + EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend); +@@ -1715,8 +1707,6 @@ int usb_autopm_get_interface(struct usb_interface *intf) + status = pm_runtime_get_sync(&intf->dev); + if (status < 0) + pm_runtime_put_sync(&intf->dev); +- else +- atomic_inc(&intf->pm_usage_cnt); + dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", + __func__, atomic_read(&intf->dev.power.usage_count), + status); +@@ -1750,8 +1740,6 @@ int usb_autopm_get_interface_async(struct usb_interface *intf) + status = pm_runtime_get(&intf->dev); + if (status < 0 && status != -EINPROGRESS) + pm_runtime_put_noidle(&intf->dev); +- else +- atomic_inc(&intf->pm_usage_cnt); + dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", + __func__, atomic_read(&intf->dev.power.usage_count), + status); +@@ -1775,7 +1763,6 @@ void usb_autopm_get_interface_no_resume(struct usb_interface *intf) + struct usb_device *udev = interface_to_usbdev(intf); + + usb_mark_last_busy(udev); +- atomic_inc(&intf->pm_usage_cnt); + pm_runtime_get_noresume(&intf->dev); + } + EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume); +diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c +index 4f33eb632a88..4020ce8db6ce 100644 +--- a/drivers/usb/core/message.c ++++ b/drivers/usb/core/message.c +@@ -820,9 +820,11 @@ int usb_string(struct usb_device *dev, int index, char *buf, size_t size) + + if (dev->state == USB_STATE_SUSPENDED) + return -EHOSTUNREACH; +- if (size <= 0 || !buf || !index) ++ if (size <= 0 || !buf) + return -EINVAL; + buf[0] = 0; ++ if (index <= 0 || index >= 256) ++ return -EINVAL; + tbuf = kmalloc(256, GFP_NOIO); + if (!tbuf) + return -ENOMEM; +diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c +index 8d1dbe36db92..9f941cdb0691 100644 +--- a/drivers/usb/dwc3/gadget.c ++++ b/drivers/usb/dwc3/gadget.c +@@ -1506,6 +1506,8 @@ static void dwc3_gadget_ep_skip_trbs(struct dwc3_ep *dep, struct dwc3_request *r + trb->ctrl &= ~DWC3_TRB_CTRL_HWO; + dwc3_ep_inc_deq(dep); + } ++ ++ req->num_trbs = 0; + } + + static void dwc3_gadget_ep_cleanup_cancelled_requests(struct dwc3_ep *dep) +diff --git a/drivers/usb/gadget/udc/dummy_hcd.c b/drivers/usb/gadget/udc/dummy_hcd.c +index baf72f95f0f1..213b52508621 100644 +--- a/drivers/usb/gadget/udc/dummy_hcd.c ++++ b/drivers/usb/gadget/udc/dummy_hcd.c +@@ -979,8 +979,18 @@ static int dummy_udc_start(struct usb_gadget *g, + struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g); + struct dummy *dum = dum_hcd->dum; + +- if (driver->max_speed == USB_SPEED_UNKNOWN) ++ switch (g->speed) { ++ /* All the speeds we support */ ++ case USB_SPEED_LOW: ++ case USB_SPEED_FULL: ++ case USB_SPEED_HIGH: ++ case USB_SPEED_SUPER: ++ break; ++ default: ++ dev_err(dummy_dev(dum_hcd), "Unsupported driver max speed %d\n", ++ driver->max_speed); + return -EINVAL; ++ } + + /* + * SLAVE side init ... the layer above hardware, which +@@ -1784,9 +1794,10 @@ static void dummy_timer(struct timer_list *t) + /* Bus speed is 500000 bytes/ms, so use a little less */ + total = 490000; + break; +- default: ++ default: /* Can't happen */ + dev_err(dummy_dev(dum_hcd), "bogus device speed\n"); +- return; ++ total = 0; ++ break; + } + + /* FIXME if HZ != 1000 this will probably misbehave ... */ +@@ -1828,7 +1839,7 @@ restart: + + /* Used up this frame's bandwidth? */ + if (total <= 0) +- break; ++ continue; + + /* find the gadget's ep for this request (if configured) */ + address = usb_pipeendpoint (urb->pipe); +diff --git a/drivers/usb/misc/yurex.c b/drivers/usb/misc/yurex.c +index 6d9fd5f64903..7b306aa22d25 100644 +--- a/drivers/usb/misc/yurex.c ++++ b/drivers/usb/misc/yurex.c +@@ -314,6 +314,7 @@ static void yurex_disconnect(struct usb_interface *interface) + usb_deregister_dev(interface, &yurex_class); + + /* prevent more I/O from starting */ ++ usb_poison_urb(dev->urb); + mutex_lock(&dev->io_mutex); + dev->interface = NULL; + mutex_unlock(&dev->io_mutex); +diff --git a/drivers/usb/storage/realtek_cr.c b/drivers/usb/storage/realtek_cr.c +index 31b024441938..cc794e25a0b6 100644 +--- a/drivers/usb/storage/realtek_cr.c ++++ b/drivers/usb/storage/realtek_cr.c +@@ -763,18 +763,16 @@ static void rts51x_suspend_timer_fn(struct timer_list *t) + break; + case RTS51X_STAT_IDLE: + case RTS51X_STAT_SS: +- usb_stor_dbg(us, "RTS51X_STAT_SS, intf->pm_usage_cnt:%d, power.usage:%d\n", +- atomic_read(&us->pusb_intf->pm_usage_cnt), ++ usb_stor_dbg(us, "RTS51X_STAT_SS, power.usage:%d\n", + atomic_read(&us->pusb_intf->dev.power.usage_count)); + +- if (atomic_read(&us->pusb_intf->pm_usage_cnt) > 0) { ++ if (atomic_read(&us->pusb_intf->dev.power.usage_count) > 0) { + usb_stor_dbg(us, "Ready to enter SS state\n"); + rts51x_set_stat(chip, RTS51X_STAT_SS); + /* ignore mass storage interface's children */ + pm_suspend_ignore_children(&us->pusb_intf->dev, true); + usb_autopm_put_interface_async(us->pusb_intf); +- usb_stor_dbg(us, "RTS51X_STAT_SS 01, intf->pm_usage_cnt:%d, power.usage:%d\n", +- atomic_read(&us->pusb_intf->pm_usage_cnt), ++ usb_stor_dbg(us, "RTS51X_STAT_SS 01, power.usage:%d\n", + atomic_read(&us->pusb_intf->dev.power.usage_count)); + } + break; +@@ -807,11 +805,10 @@ static void rts51x_invoke_transport(struct scsi_cmnd *srb, struct us_data *us) + int ret; + + if (working_scsi(srb)) { +- usb_stor_dbg(us, "working scsi, intf->pm_usage_cnt:%d, power.usage:%d\n", +- atomic_read(&us->pusb_intf->pm_usage_cnt), ++ usb_stor_dbg(us, "working scsi, power.usage:%d\n", + atomic_read(&us->pusb_intf->dev.power.usage_count)); + +- if (atomic_read(&us->pusb_intf->pm_usage_cnt) <= 0) { ++ if (atomic_read(&us->pusb_intf->dev.power.usage_count) <= 0) { + ret = usb_autopm_get_interface(us->pusb_intf); + usb_stor_dbg(us, "working scsi, ret=%d\n", ret); + } +diff --git a/drivers/usb/usbip/stub_rx.c b/drivers/usb/usbip/stub_rx.c +index 97b09a42a10c..dbfb2f24d71e 100644 +--- a/drivers/usb/usbip/stub_rx.c ++++ b/drivers/usb/usbip/stub_rx.c +@@ -361,16 +361,10 @@ static int get_pipe(struct stub_device *sdev, struct usbip_header *pdu) + } + + if (usb_endpoint_xfer_isoc(epd)) { +- /* validate packet size and number of packets */ +- unsigned int maxp, packets, bytes; +- +- maxp = usb_endpoint_maxp(epd); +- maxp *= usb_endpoint_maxp_mult(epd); +- bytes = pdu->u.cmd_submit.transfer_buffer_length; +- packets = DIV_ROUND_UP(bytes, maxp); +- ++ /* validate number of packets */ + if (pdu->u.cmd_submit.number_of_packets < 0 || +- pdu->u.cmd_submit.number_of_packets > packets) { ++ pdu->u.cmd_submit.number_of_packets > ++ USBIP_MAX_ISO_PACKETS) { + dev_err(&sdev->udev->dev, + "CMD_SUBMIT: isoc invalid num packets %d\n", + pdu->u.cmd_submit.number_of_packets); +diff --git a/drivers/usb/usbip/usbip_common.h b/drivers/usb/usbip/usbip_common.h +index bf8afe9b5883..8be857a4fa13 100644 +--- a/drivers/usb/usbip/usbip_common.h ++++ b/drivers/usb/usbip/usbip_common.h +@@ -121,6 +121,13 @@ extern struct device_attribute dev_attr_usbip_debug; + #define USBIP_DIR_OUT 0x00 + #define USBIP_DIR_IN 0x01 + ++/* ++ * Arbitrary limit for the maximum number of isochronous packets in an URB, ++ * compare for example the uhci_submit_isochronous function in ++ * drivers/usb/host/uhci-q.c ++ */ ++#define USBIP_MAX_ISO_PACKETS 1024 ++ + /** + * struct usbip_header_basic - data pertinent to every request + * @command: the usbip request type +diff --git a/drivers/vfio/pci/vfio_pci.c b/drivers/vfio/pci/vfio_pci.c +index ff60bd1ea587..eb8fc8ccffc6 100644 +--- a/drivers/vfio/pci/vfio_pci.c ++++ b/drivers/vfio/pci/vfio_pci.c +@@ -1597,11 +1597,11 @@ static void __init vfio_pci_fill_ids(void) + rc = pci_add_dynid(&vfio_pci_driver, vendor, device, + subvendor, subdevice, class, class_mask, 0); + if (rc) +- pr_warn("failed to add dynamic id [%04hx:%04hx[%04hx:%04hx]] class %#08x/%08x (%d)\n", ++ pr_warn("failed to add dynamic id [%04x:%04x[%04x:%04x]] class %#08x/%08x (%d)\n", + vendor, device, subvendor, subdevice, + class, class_mask, rc); + else +- pr_info("add [%04hx:%04hx[%04hx:%04hx]] class %#08x/%08x\n", ++ pr_info("add [%04x:%04x[%04x:%04x]] class %#08x/%08x\n", + vendor, device, subvendor, subdevice, + class, class_mask); + } +diff --git a/drivers/w1/masters/ds2490.c b/drivers/w1/masters/ds2490.c +index 0f4ecfcdb549..a9fb77585272 100644 +--- a/drivers/w1/masters/ds2490.c ++++ b/drivers/w1/masters/ds2490.c +@@ -1016,15 +1016,15 @@ static int ds_probe(struct usb_interface *intf, + /* alternative 3, 1ms interrupt (greatly speeds search), 64 byte bulk */ + alt = 3; + err = usb_set_interface(dev->udev, +- intf->altsetting[alt].desc.bInterfaceNumber, alt); ++ intf->cur_altsetting->desc.bInterfaceNumber, alt); + if (err) { + dev_err(&dev->udev->dev, "Failed to set alternative setting %d " + "for %d interface: err=%d.\n", alt, +- intf->altsetting[alt].desc.bInterfaceNumber, err); ++ intf->cur_altsetting->desc.bInterfaceNumber, err); + goto err_out_clear; + } + +- iface_desc = &intf->altsetting[alt]; ++ iface_desc = intf->cur_altsetting; + if (iface_desc->desc.bNumEndpoints != NUM_EP-1) { + pr_info("Num endpoints=%d. It is not DS9490R.\n", + iface_desc->desc.bNumEndpoints); +diff --git a/drivers/xen/xenbus/xenbus_dev_frontend.c b/drivers/xen/xenbus/xenbus_dev_frontend.c +index c3e201025ef0..0782ff3c2273 100644 +--- a/drivers/xen/xenbus/xenbus_dev_frontend.c ++++ b/drivers/xen/xenbus/xenbus_dev_frontend.c +@@ -622,9 +622,7 @@ static int xenbus_file_open(struct inode *inode, struct file *filp) + if (xen_store_evtchn == 0) + return -ENOENT; + +- nonseekable_open(inode, filp); +- +- filp->f_mode &= ~FMODE_ATOMIC_POS; /* cdev-style semantics */ ++ stream_open(inode, filp); + + u = kzalloc(sizeof(*u), GFP_KERNEL); + if (u == NULL) +diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c +index 29c68c5d44d5..c4a4fc6f1a95 100644 +--- a/fs/debugfs/inode.c ++++ b/fs/debugfs/inode.c +@@ -163,19 +163,24 @@ static int debugfs_show_options(struct seq_file *m, struct dentry *root) + return 0; + } + +-static void debugfs_evict_inode(struct inode *inode) ++static void debugfs_i_callback(struct rcu_head *head) + { +- truncate_inode_pages_final(&inode->i_data); +- clear_inode(inode); ++ struct inode *inode = container_of(head, struct inode, i_rcu); + if (S_ISLNK(inode->i_mode)) + kfree(inode->i_link); ++ free_inode_nonrcu(inode); ++} ++ ++static void debugfs_destroy_inode(struct inode *inode) ++{ ++ call_rcu(&inode->i_rcu, debugfs_i_callback); + } + + static const struct super_operations debugfs_super_operations = { + .statfs = simple_statfs, + .remount_fs = debugfs_remount, + .show_options = debugfs_show_options, +- .evict_inode = debugfs_evict_inode, ++ .destroy_inode = debugfs_destroy_inode, + }; + + static void debugfs_release_dentry(struct dentry *dentry) +diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c +index a7fa037b876b..a3a3d256fb0e 100644 +--- a/fs/hugetlbfs/inode.c ++++ b/fs/hugetlbfs/inode.c +@@ -741,11 +741,17 @@ static struct inode *hugetlbfs_get_inode(struct super_block *sb, + umode_t mode, dev_t dev) + { + struct inode *inode; +- struct resv_map *resv_map; ++ struct resv_map *resv_map = NULL; + +- resv_map = resv_map_alloc(); +- if (!resv_map) +- return NULL; ++ /* ++ * Reserve maps are only needed for inodes that can have associated ++ * page allocations. ++ */ ++ if (S_ISREG(mode) || S_ISLNK(mode)) { ++ resv_map = resv_map_alloc(); ++ if (!resv_map) ++ return NULL; ++ } + + inode = new_inode(sb); + if (inode) { +@@ -780,8 +786,10 @@ static struct inode *hugetlbfs_get_inode(struct super_block *sb, + break; + } + lockdep_annotate_inode_mutex_key(inode); +- } else +- kref_put(&resv_map->refs, resv_map_release); ++ } else { ++ if (resv_map) ++ kref_put(&resv_map->refs, resv_map_release); ++ } + + return inode; + } +diff --git a/fs/jffs2/readinode.c b/fs/jffs2/readinode.c +index 389ea53ea487..bccfc40b3a74 100644 +--- a/fs/jffs2/readinode.c ++++ b/fs/jffs2/readinode.c +@@ -1414,11 +1414,6 @@ void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f) + + jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL); + +- if (f->target) { +- kfree(f->target); +- f->target = NULL; +- } +- + fds = f->dents; + while(fds) { + fd = fds; +diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c +index bb6ae387469f..05d892c79339 100644 +--- a/fs/jffs2/super.c ++++ b/fs/jffs2/super.c +@@ -47,7 +47,10 @@ static struct inode *jffs2_alloc_inode(struct super_block *sb) + static void jffs2_i_callback(struct rcu_head *head) + { + struct inode *inode = container_of(head, struct inode, i_rcu); +- kmem_cache_free(jffs2_inode_cachep, JFFS2_INODE_INFO(inode)); ++ struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); ++ ++ kfree(f->target); ++ kmem_cache_free(jffs2_inode_cachep, f); + } + + static void jffs2_destroy_inode(struct inode *inode) +diff --git a/fs/open.c b/fs/open.c +index f1c2f855fd43..a00350018a47 100644 +--- a/fs/open.c ++++ b/fs/open.c +@@ -1215,3 +1215,21 @@ int nonseekable_open(struct inode *inode, struct file *filp) + } + + EXPORT_SYMBOL(nonseekable_open); ++ ++/* ++ * stream_open is used by subsystems that want stream-like file descriptors. ++ * Such file descriptors are not seekable and don't have notion of position ++ * (file.f_pos is always 0). Contrary to file descriptors of other regular ++ * files, .read() and .write() can run simultaneously. ++ * ++ * stream_open never fails and is marked to return int so that it could be ++ * directly used as file_operations.open . ++ */ ++int stream_open(struct inode *inode, struct file *filp) ++{ ++ filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE | FMODE_ATOMIC_POS); ++ filp->f_mode |= FMODE_STREAM; ++ return 0; ++} ++ ++EXPORT_SYMBOL(stream_open); +diff --git a/fs/read_write.c b/fs/read_write.c +index 27b69b85d49f..3d3194e32201 100644 +--- a/fs/read_write.c ++++ b/fs/read_write.c +@@ -560,12 +560,13 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_ + + static inline loff_t file_pos_read(struct file *file) + { +- return file->f_pos; ++ return file->f_mode & FMODE_STREAM ? 0 : file->f_pos; + } + + static inline void file_pos_write(struct file *file, loff_t pos) + { +- file->f_pos = pos; ++ if ((file->f_mode & FMODE_STREAM) == 0) ++ file->f_pos = pos; + } + + ssize_t ksys_read(unsigned int fd, char __user *buf, size_t count) +diff --git a/include/linux/fs.h b/include/linux/fs.h +index fd423fec8d83..09ce2646c78a 100644 +--- a/include/linux/fs.h ++++ b/include/linux/fs.h +@@ -153,6 +153,9 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset, + #define FMODE_OPENED ((__force fmode_t)0x80000) + #define FMODE_CREATED ((__force fmode_t)0x100000) + ++/* File is stream-like */ ++#define FMODE_STREAM ((__force fmode_t)0x200000) ++ + /* File was opened by fanotify and shouldn't generate fanotify events */ + #define FMODE_NONOTIFY ((__force fmode_t)0x4000000) + +@@ -3074,6 +3077,7 @@ extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t); + extern loff_t no_seek_end_llseek(struct file *, loff_t, int); + extern int generic_file_open(struct inode * inode, struct file * filp); + extern int nonseekable_open(struct inode * inode, struct file * filp); ++extern int stream_open(struct inode * inode, struct file * filp); + + #ifdef CONFIG_BLOCK + typedef void (dio_submit_t)(struct bio *bio, struct inode *inode, +diff --git a/include/linux/platform_data/x86/clk-pmc-atom.h b/include/linux/platform_data/x86/clk-pmc-atom.h +index 3ab892208343..7a37ac27d0fb 100644 +--- a/include/linux/platform_data/x86/clk-pmc-atom.h ++++ b/include/linux/platform_data/x86/clk-pmc-atom.h +@@ -35,10 +35,13 @@ struct pmc_clk { + * + * @base: PMC clock register base offset + * @clks: pointer to set of registered clocks, typically 0..5 ++ * @critical: flag to indicate if firmware enabled pmc_plt_clks ++ * should be marked as critial or not + */ + struct pmc_clk_data { + void __iomem *base; + const struct pmc_clk *clks; ++ bool critical; + }; + + #endif /* __PLATFORM_DATA_X86_CLK_PMC_ATOM_H */ +diff --git a/include/linux/usb.h b/include/linux/usb.h +index 5e49e82c4368..ff010d1fd1c7 100644 +--- a/include/linux/usb.h ++++ b/include/linux/usb.h +@@ -200,7 +200,6 @@ usb_find_last_int_out_endpoint(struct usb_host_interface *alt, + * @dev: driver model's view of this device + * @usb_dev: if an interface is bound to the USB major, this will point + * to the sysfs representation for that device. +- * @pm_usage_cnt: PM usage counter for this interface + * @reset_ws: Used for scheduling resets from atomic context. + * @resetting_device: USB core reset the device, so use alt setting 0 as + * current; needs bandwidth alloc after reset. +@@ -257,7 +256,6 @@ struct usb_interface { + + struct device dev; /* interface specific device info */ + struct device *usb_dev; +- atomic_t pm_usage_cnt; /* usage counter for autosuspend */ + struct work_struct reset_ws; /* for resets in atomic context */ + }; + #define to_usb_interface(d) container_of(d, struct usb_interface, dev) +diff --git a/kernel/bpf/cpumap.c b/kernel/bpf/cpumap.c +index 8974b3755670..3c18260403dd 100644 +--- a/kernel/bpf/cpumap.c ++++ b/kernel/bpf/cpumap.c +@@ -162,10 +162,14 @@ static void cpu_map_kthread_stop(struct work_struct *work) + static struct sk_buff *cpu_map_build_skb(struct bpf_cpu_map_entry *rcpu, + struct xdp_frame *xdpf) + { ++ unsigned int hard_start_headroom; + unsigned int frame_size; + void *pkt_data_start; + struct sk_buff *skb; + ++ /* Part of headroom was reserved to xdpf */ ++ hard_start_headroom = sizeof(struct xdp_frame) + xdpf->headroom; ++ + /* build_skb need to place skb_shared_info after SKB end, and + * also want to know the memory "truesize". Thus, need to + * know the memory frame size backing xdp_buff. +@@ -183,15 +187,15 @@ static struct sk_buff *cpu_map_build_skb(struct bpf_cpu_map_entry *rcpu, + * is not at a fixed memory location, with mixed length + * packets, which is bad for cache-line hotness. + */ +- frame_size = SKB_DATA_ALIGN(xdpf->len + xdpf->headroom) + ++ frame_size = SKB_DATA_ALIGN(xdpf->len + hard_start_headroom) + + SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); + +- pkt_data_start = xdpf->data - xdpf->headroom; ++ pkt_data_start = xdpf->data - hard_start_headroom; + skb = build_skb(pkt_data_start, frame_size); + if (!skb) + return NULL; + +- skb_reserve(skb, xdpf->headroom); ++ skb_reserve(skb, hard_start_headroom); + __skb_put(skb, xdpf->len); + if (xdpf->metasize) + skb_metadata_set(skb, xdpf->metasize); +@@ -205,6 +209,9 @@ static struct sk_buff *cpu_map_build_skb(struct bpf_cpu_map_entry *rcpu, + * - RX ring dev queue index (skb_record_rx_queue) + */ + ++ /* Allow SKB to reuse area used by xdp_frame */ ++ xdp_scrub_frame(xdpf); ++ + return skb; + } + +diff --git a/kernel/seccomp.c b/kernel/seccomp.c +index e815781ed751..181e72718434 100644 +--- a/kernel/seccomp.c ++++ b/kernel/seccomp.c +@@ -500,7 +500,10 @@ out: + * + * Caller must be holding current->sighand->siglock lock. + * +- * Returns 0 on success, -ve on error. ++ * Returns 0 on success, -ve on error, or ++ * - in TSYNC mode: the pid of a thread which was either not in the correct ++ * seccomp mode or did not have an ancestral seccomp filter ++ * - in NEW_LISTENER mode: the fd of the new listener + */ + static long seccomp_attach_filter(unsigned int flags, + struct seccomp_filter *filter) +@@ -1256,6 +1259,16 @@ static long seccomp_set_mode_filter(unsigned int flags, + if (flags & ~SECCOMP_FILTER_FLAG_MASK) + return -EINVAL; + ++ /* ++ * In the successful case, NEW_LISTENER returns the new listener fd. ++ * But in the failure case, TSYNC returns the thread that died. If you ++ * combine these two flags, there's no way to tell whether something ++ * succeeded or failed. So, let's disallow this combination. ++ */ ++ if ((flags & SECCOMP_FILTER_FLAG_TSYNC) && ++ (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER)) ++ return -EINVAL; ++ + /* Prepare the new filter before holding any locks. */ + prepared = seccomp_prepare_user_filter(filter); + if (IS_ERR(prepared)) +@@ -1302,7 +1315,7 @@ out: + mutex_unlock(¤t->signal->cred_guard_mutex); + out_put_fd: + if (flags & SECCOMP_FILTER_FLAG_NEW_LISTENER) { +- if (ret < 0) { ++ if (ret) { + listener_f->private_data = NULL; + fput(listener_f); + put_unused_fd(listener); +diff --git a/mm/kmemleak.c b/mm/kmemleak.c +index 707fa5579f66..2e435b8142e5 100644 +--- a/mm/kmemleak.c ++++ b/mm/kmemleak.c +@@ -1401,6 +1401,7 @@ static void scan_block(void *_start, void *_end, + /* + * Scan a large memory block in MAX_SCAN_SIZE chunks to reduce the latency. + */ ++#ifdef CONFIG_SMP + static void scan_large_block(void *start, void *end) + { + void *next; +@@ -1412,6 +1413,7 @@ static void scan_large_block(void *start, void *end) + cond_resched(); + } + } ++#endif + + /* + * Scan a memory block corresponding to a kmemleak_object. A condition is +@@ -1529,11 +1531,6 @@ static void kmemleak_scan(void) + } + rcu_read_unlock(); + +- /* data/bss scanning */ +- scan_large_block(_sdata, _edata); +- scan_large_block(__bss_start, __bss_stop); +- scan_large_block(__start_ro_after_init, __end_ro_after_init); +- + #ifdef CONFIG_SMP + /* per-cpu sections scanning */ + for_each_possible_cpu(i) +@@ -2071,6 +2068,17 @@ void __init kmemleak_init(void) + } + local_irq_restore(flags); + ++ /* register the data/bss sections */ ++ create_object((unsigned long)_sdata, _edata - _sdata, ++ KMEMLEAK_GREY, GFP_ATOMIC); ++ create_object((unsigned long)__bss_start, __bss_stop - __bss_start, ++ KMEMLEAK_GREY, GFP_ATOMIC); ++ /* only register .data..ro_after_init if not within .data */ ++ if (__start_ro_after_init < _sdata || __end_ro_after_init > _edata) ++ create_object((unsigned long)__start_ro_after_init, ++ __end_ro_after_init - __start_ro_after_init, ++ KMEMLEAK_GREY, GFP_ATOMIC); ++ + /* + * This is the point where tracking allocations is safe. Automatic + * scanning is started during the late initcall. Add the early logged +diff --git a/net/batman-adv/bat_v_elp.c b/net/batman-adv/bat_v_elp.c +index ef0dec20c7d8..5da183b2f4c9 100644 +--- a/net/batman-adv/bat_v_elp.c ++++ b/net/batman-adv/bat_v_elp.c +@@ -104,8 +104,10 @@ static u32 batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node *neigh) + + ret = cfg80211_get_station(real_netdev, neigh->addr, &sinfo); + +- /* free the TID stats immediately */ +- cfg80211_sinfo_release_content(&sinfo); ++ if (!ret) { ++ /* free the TID stats immediately */ ++ cfg80211_sinfo_release_content(&sinfo); ++ } + + dev_put(real_netdev); + if (ret == -ENOENT) { +diff --git a/net/batman-adv/bridge_loop_avoidance.c b/net/batman-adv/bridge_loop_avoidance.c +index 5fdde2947802..cf2bcea7df82 100644 +--- a/net/batman-adv/bridge_loop_avoidance.c ++++ b/net/batman-adv/bridge_loop_avoidance.c +@@ -803,6 +803,8 @@ static void batadv_bla_del_claim(struct batadv_priv *bat_priv, + const u8 *mac, const unsigned short vid) + { + struct batadv_bla_claim search_claim, *claim; ++ struct batadv_bla_claim *claim_removed_entry; ++ struct hlist_node *claim_removed_node; + + ether_addr_copy(search_claim.addr, mac); + search_claim.vid = vid; +@@ -813,10 +815,18 @@ static void batadv_bla_del_claim(struct batadv_priv *bat_priv, + batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): %pM, vid %d\n", __func__, + mac, batadv_print_vid(vid)); + +- batadv_hash_remove(bat_priv->bla.claim_hash, batadv_compare_claim, +- batadv_choose_claim, claim); +- batadv_claim_put(claim); /* reference from the hash is gone */ ++ claim_removed_node = batadv_hash_remove(bat_priv->bla.claim_hash, ++ batadv_compare_claim, ++ batadv_choose_claim, claim); ++ if (!claim_removed_node) ++ goto free_claim; + ++ /* reference from the hash is gone */ ++ claim_removed_entry = hlist_entry(claim_removed_node, ++ struct batadv_bla_claim, hash_entry); ++ batadv_claim_put(claim_removed_entry); ++ ++free_claim: + /* don't need the reference from hash_find() anymore */ + batadv_claim_put(claim); + } +diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c +index 8dcd4968cde7..6ec0e67be560 100644 +--- a/net/batman-adv/translation-table.c ++++ b/net/batman-adv/translation-table.c +@@ -616,14 +616,26 @@ static void batadv_tt_global_free(struct batadv_priv *bat_priv, + struct batadv_tt_global_entry *tt_global, + const char *message) + { ++ struct batadv_tt_global_entry *tt_removed_entry; ++ struct hlist_node *tt_removed_node; ++ + batadv_dbg(BATADV_DBG_TT, bat_priv, + "Deleting global tt entry %pM (vid: %d): %s\n", + tt_global->common.addr, + batadv_print_vid(tt_global->common.vid), message); + +- batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt, +- batadv_choose_tt, &tt_global->common); +- batadv_tt_global_entry_put(tt_global); ++ tt_removed_node = batadv_hash_remove(bat_priv->tt.global_hash, ++ batadv_compare_tt, ++ batadv_choose_tt, ++ &tt_global->common); ++ if (!tt_removed_node) ++ return; ++ ++ /* drop reference of remove hash entry */ ++ tt_removed_entry = hlist_entry(tt_removed_node, ++ struct batadv_tt_global_entry, ++ common.hash_entry); ++ batadv_tt_global_entry_put(tt_removed_entry); + } + + /** +@@ -1337,9 +1349,10 @@ u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr, + unsigned short vid, const char *message, + bool roaming) + { ++ struct batadv_tt_local_entry *tt_removed_entry; + struct batadv_tt_local_entry *tt_local_entry; + u16 flags, curr_flags = BATADV_NO_FLAGS; +- void *tt_entry_exists; ++ struct hlist_node *tt_removed_node; + + tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid); + if (!tt_local_entry) +@@ -1368,15 +1381,18 @@ u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr, + */ + batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL); + +- tt_entry_exists = batadv_hash_remove(bat_priv->tt.local_hash, ++ tt_removed_node = batadv_hash_remove(bat_priv->tt.local_hash, + batadv_compare_tt, + batadv_choose_tt, + &tt_local_entry->common); +- if (!tt_entry_exists) ++ if (!tt_removed_node) + goto out; + +- /* extra call to free the local tt entry */ +- batadv_tt_local_entry_put(tt_local_entry); ++ /* drop reference of remove hash entry */ ++ tt_removed_entry = hlist_entry(tt_removed_node, ++ struct batadv_tt_local_entry, ++ common.hash_entry); ++ batadv_tt_local_entry_put(tt_removed_entry); + + out: + if (tt_local_entry) +diff --git a/net/mac80211/debugfs_netdev.c b/net/mac80211/debugfs_netdev.c +index cff0fb3578c9..deb3faf08337 100644 +--- a/net/mac80211/debugfs_netdev.c ++++ b/net/mac80211/debugfs_netdev.c +@@ -841,7 +841,7 @@ void ieee80211_debugfs_rename_netdev(struct ieee80211_sub_if_data *sdata) + + dir = sdata->vif.debugfs_dir; + +- if (!dir) ++ if (IS_ERR_OR_NULL(dir)) + return; + + sprintf(buf, "netdev:%s", sdata->name); +diff --git a/net/mac80211/key.c b/net/mac80211/key.c +index 4700718e010f..37e372896230 100644 +--- a/net/mac80211/key.c ++++ b/net/mac80211/key.c +@@ -167,8 +167,10 @@ static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key) + * The driver doesn't know anything about VLAN interfaces. + * Hence, don't send GTKs for VLAN interfaces to the driver. + */ +- if (!(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE)) ++ if (!(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE)) { ++ ret = 1; + goto out_unsupported; ++ } + } + + ret = drv_set_key(key->local, SET_KEY, sdata, +@@ -213,11 +215,8 @@ static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key) + /* all of these we can do in software - if driver can */ + if (ret == 1) + return 0; +- if (ieee80211_hw_check(&key->local->hw, SW_CRYPTO_CONTROL)) { +- if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) +- return 0; ++ if (ieee80211_hw_check(&key->local->hw, SW_CRYPTO_CONTROL)) + return -EINVAL; +- } + return 0; + default: + return -EINVAL; +diff --git a/scripts/coccinelle/api/stream_open.cocci b/scripts/coccinelle/api/stream_open.cocci +new file mode 100644 +index 000000000000..350145da7669 +--- /dev/null ++++ b/scripts/coccinelle/api/stream_open.cocci +@@ -0,0 +1,363 @@ ++// SPDX-License-Identifier: GPL-2.0 ++// Author: Kirill Smelkov (kirr@nexedi.com) ++// ++// Search for stream-like files that are using nonseekable_open and convert ++// them to stream_open. A stream-like file is a file that does not use ppos in ++// its read and write. Rationale for the conversion is to avoid deadlock in ++// between read and write. ++ ++virtual report ++virtual patch ++virtual explain // explain decisions in the patch (SPFLAGS="-D explain") ++ ++// stream-like reader & writer - ones that do not depend on f_pos. ++@ stream_reader @ ++identifier readstream, ppos; ++identifier f, buf, len; ++type loff_t; ++@@ ++ ssize_t readstream(struct file *f, char *buf, size_t len, loff_t *ppos) ++ { ++ ... when != ppos ++ } ++ ++@ stream_writer @ ++identifier writestream, ppos; ++identifier f, buf, len; ++type loff_t; ++@@ ++ ssize_t writestream(struct file *f, const char *buf, size_t len, loff_t *ppos) ++ { ++ ... when != ppos ++ } ++ ++ ++// a function that blocks ++@ blocks @ ++identifier block_f; ++identifier wait_event =~ "^wait_event_.*"; ++@@ ++ block_f(...) { ++ ... when exists ++ wait_event(...) ++ ... when exists ++ } ++ ++// stream_reader that can block inside. ++// ++// XXX wait_* can be called not directly from current function (e.g. func -> f -> g -> wait()) ++// XXX currently reader_blocks supports only direct and 1-level indirect cases. ++@ reader_blocks_direct @ ++identifier stream_reader.readstream; ++identifier wait_event =~ "^wait_event_.*"; ++@@ ++ readstream(...) ++ { ++ ... when exists ++ wait_event(...) ++ ... when exists ++ } ++ ++@ reader_blocks_1 @ ++identifier stream_reader.readstream; ++identifier blocks.block_f; ++@@ ++ readstream(...) ++ { ++ ... when exists ++ block_f(...) ++ ... when exists ++ } ++ ++@ reader_blocks depends on reader_blocks_direct || reader_blocks_1 @ ++identifier stream_reader.readstream; ++@@ ++ readstream(...) { ++ ... ++ } ++ ++ ++// file_operations + whether they have _any_ .read, .write, .llseek ... at all. ++// ++// XXX add support for file_operations xxx[N] = ... (sound/core/pcm_native.c) ++@ fops0 @ ++identifier fops; ++@@ ++ struct file_operations fops = { ++ ... ++ }; ++ ++@ has_read @ ++identifier fops0.fops; ++identifier read_f; ++@@ ++ struct file_operations fops = { ++ .read = read_f, ++ }; ++ ++@ has_read_iter @ ++identifier fops0.fops; ++identifier read_iter_f; ++@@ ++ struct file_operations fops = { ++ .read_iter = read_iter_f, ++ }; ++ ++@ has_write @ ++identifier fops0.fops; ++identifier write_f; ++@@ ++ struct file_operations fops = { ++ .write = write_f, ++ }; ++ ++@ has_write_iter @ ++identifier fops0.fops; ++identifier write_iter_f; ++@@ ++ struct file_operations fops = { ++ .write_iter = write_iter_f, ++ }; ++ ++@ has_llseek @ ++identifier fops0.fops; ++identifier llseek_f; ++@@ ++ struct file_operations fops = { ++ .llseek = llseek_f, ++ }; ++ ++@ has_no_llseek @ ++identifier fops0.fops; ++@@ ++ struct file_operations fops = { ++ .llseek = no_llseek, ++ }; ++ ++@ has_mmap @ ++identifier fops0.fops; ++identifier mmap_f; ++@@ ++ struct file_operations fops = { ++ .mmap = mmap_f, ++ }; ++ ++@ has_copy_file_range @ ++identifier fops0.fops; ++identifier copy_file_range_f; ++@@ ++ struct file_operations fops = { ++ .copy_file_range = copy_file_range_f, ++ }; ++ ++@ has_remap_file_range @ ++identifier fops0.fops; ++identifier remap_file_range_f; ++@@ ++ struct file_operations fops = { ++ .remap_file_range = remap_file_range_f, ++ }; ++ ++@ has_splice_read @ ++identifier fops0.fops; ++identifier splice_read_f; ++@@ ++ struct file_operations fops = { ++ .splice_read = splice_read_f, ++ }; ++ ++@ has_splice_write @ ++identifier fops0.fops; ++identifier splice_write_f; ++@@ ++ struct file_operations fops = { ++ .splice_write = splice_write_f, ++ }; ++ ++ ++// file_operations that is candidate for stream_open conversion - it does not ++// use mmap and other methods that assume @offset access to file. ++// ++// XXX for simplicity require no .{read/write}_iter and no .splice_{read/write} for now. ++// XXX maybe_steam.fops cannot be used in other rules - it gives "bad rule maybe_stream or bad variable fops". ++@ maybe_stream depends on (!has_llseek || has_no_llseek) && !has_mmap && !has_copy_file_range && !has_remap_file_range && !has_read_iter && !has_write_iter && !has_splice_read && !has_splice_write @ ++identifier fops0.fops; ++@@ ++ struct file_operations fops = { ++ }; ++ ++ ++// ---- conversions ---- ++ ++// XXX .open = nonseekable_open -> .open = stream_open ++// XXX .open = func -> openfunc -> nonseekable_open ++ ++// read & write ++// ++// if both are used in the same file_operations together with an opener - ++// under that conditions we can use stream_open instead of nonseekable_open. ++@ fops_rw depends on maybe_stream @ ++identifier fops0.fops, openfunc; ++identifier stream_reader.readstream; ++identifier stream_writer.writestream; ++@@ ++ struct file_operations fops = { ++ .open = openfunc, ++ .read = readstream, ++ .write = writestream, ++ }; ++ ++@ report_rw depends on report @ ++identifier fops_rw.openfunc; ++position p1; ++@@ ++ openfunc(...) { ++ <... ++ nonseekable_open@p1 ++ ...> ++ } ++ ++@ script:python depends on report && reader_blocks @ ++fops << fops0.fops; ++p << report_rw.p1; ++@@ ++coccilib.report.print_report(p[0], ++ "ERROR: %s: .read() can deadlock .write(); change nonseekable_open -> stream_open to fix." % (fops,)) ++ ++@ script:python depends on report && !reader_blocks @ ++fops << fops0.fops; ++p << report_rw.p1; ++@@ ++coccilib.report.print_report(p[0], ++ "WARNING: %s: .read() and .write() have stream semantic; safe to change nonseekable_open -> stream_open." % (fops,)) ++ ++ ++@ explain_rw_deadlocked depends on explain && reader_blocks @ ++identifier fops_rw.openfunc; ++@@ ++ openfunc(...) { ++ <... ++- nonseekable_open +++ nonseekable_open /* read & write (was deadlock) */ ++ ...> ++ } ++ ++ ++@ explain_rw_nodeadlock depends on explain && !reader_blocks @ ++identifier fops_rw.openfunc; ++@@ ++ openfunc(...) { ++ <... ++- nonseekable_open +++ nonseekable_open /* read & write (no direct deadlock) */ ++ ...> ++ } ++ ++@ patch_rw depends on patch @ ++identifier fops_rw.openfunc; ++@@ ++ openfunc(...) { ++ <... ++- nonseekable_open +++ stream_open ++ ...> ++ } ++ ++ ++// read, but not write ++@ fops_r depends on maybe_stream && !has_write @ ++identifier fops0.fops, openfunc; ++identifier stream_reader.readstream; ++@@ ++ struct file_operations fops = { ++ .open = openfunc, ++ .read = readstream, ++ }; ++ ++@ report_r depends on report @ ++identifier fops_r.openfunc; ++position p1; ++@@ ++ openfunc(...) { ++ <... ++ nonseekable_open@p1 ++ ...> ++ } ++ ++@ script:python depends on report @ ++fops << fops0.fops; ++p << report_r.p1; ++@@ ++coccilib.report.print_report(p[0], ++ "WARNING: %s: .read() has stream semantic; safe to change nonseekable_open -> stream_open." % (fops,)) ++ ++@ explain_r depends on explain @ ++identifier fops_r.openfunc; ++@@ ++ openfunc(...) { ++ <... ++- nonseekable_open +++ nonseekable_open /* read only */ ++ ...> ++ } ++ ++@ patch_r depends on patch @ ++identifier fops_r.openfunc; ++@@ ++ openfunc(...) { ++ <... ++- nonseekable_open +++ stream_open ++ ...> ++ } ++ ++ ++// write, but not read ++@ fops_w depends on maybe_stream && !has_read @ ++identifier fops0.fops, openfunc; ++identifier stream_writer.writestream; ++@@ ++ struct file_operations fops = { ++ .open = openfunc, ++ .write = writestream, ++ }; ++ ++@ report_w depends on report @ ++identifier fops_w.openfunc; ++position p1; ++@@ ++ openfunc(...) { ++ <... ++ nonseekable_open@p1 ++ ...> ++ } ++ ++@ script:python depends on report @ ++fops << fops0.fops; ++p << report_w.p1; ++@@ ++coccilib.report.print_report(p[0], ++ "WARNING: %s: .write() has stream semantic; safe to change nonseekable_open -> stream_open." % (fops,)) ++ ++@ explain_w depends on explain @ ++identifier fops_w.openfunc; ++@@ ++ openfunc(...) { ++ <... ++- nonseekable_open +++ nonseekable_open /* write only */ ++ ...> ++ } ++ ++@ patch_w depends on patch @ ++identifier fops_w.openfunc; ++@@ ++ openfunc(...) { ++ <... ++- nonseekable_open +++ stream_open ++ ...> ++ } ++ ++ ++// no read, no write - don't change anything +diff --git a/security/selinux/avc.c b/security/selinux/avc.c +index 635e5c1e3e48..5de18a6d5c3f 100644 +--- a/security/selinux/avc.c ++++ b/security/selinux/avc.c +@@ -838,6 +838,7 @@ out: + * @ssid,@tsid,@tclass : identifier of an AVC entry + * @seqno : sequence number when decision was made + * @xpd: extended_perms_decision to be added to the node ++ * @flags: the AVC_* flags, e.g. AVC_NONBLOCKING, AVC_EXTENDED_PERMS, or 0. + * + * if a valid AVC entry doesn't exist,this function returns -ENOENT. + * if kmalloc() called internal returns NULL, this function returns -ENOMEM. +@@ -856,6 +857,23 @@ static int avc_update_node(struct selinux_avc *avc, + struct hlist_head *head; + spinlock_t *lock; + ++ /* ++ * If we are in a non-blocking code path, e.g. VFS RCU walk, ++ * then we must not add permissions to a cache entry ++ * because we cannot safely audit the denial. Otherwise, ++ * during the subsequent blocking retry (e.g. VFS ref walk), we ++ * will find the permissions already granted in the cache entry ++ * and won't audit anything at all, leading to silent denials in ++ * permissive mode that only appear when in enforcing mode. ++ * ++ * See the corresponding handling in slow_avc_audit(), and the ++ * logic in selinux_inode_follow_link and selinux_inode_permission ++ * for the VFS MAY_NOT_BLOCK flag, which is transliterated into ++ * AVC_NONBLOCKING for avc_has_perm_noaudit(). ++ */ ++ if (flags & AVC_NONBLOCKING) ++ return 0; ++ + node = avc_alloc_node(avc); + if (!node) { + rc = -ENOMEM; +@@ -1115,7 +1133,7 @@ decision: + * @tsid: target security identifier + * @tclass: target security class + * @requested: requested permissions, interpreted based on @tclass +- * @flags: AVC_STRICT or 0 ++ * @flags: AVC_STRICT, AVC_NONBLOCKING, or 0 + * @avd: access vector decisions + * + * Check the AVC to determine whether the @requested permissions are granted +@@ -1199,7 +1217,8 @@ int avc_has_perm_flags(struct selinux_state *state, + struct av_decision avd; + int rc, rc2; + +- rc = avc_has_perm_noaudit(state, ssid, tsid, tclass, requested, 0, ++ rc = avc_has_perm_noaudit(state, ssid, tsid, tclass, requested, ++ (flags & MAY_NOT_BLOCK) ? AVC_NONBLOCKING : 0, + &avd); + + rc2 = avc_audit(state, ssid, tsid, tclass, requested, &avd, rc, +diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c +index 07b11b5aaf1f..b005283f0090 100644 +--- a/security/selinux/hooks.c ++++ b/security/selinux/hooks.c +@@ -534,16 +534,10 @@ static int may_context_mount_inode_relabel(u32 sid, + return rc; + } + +-static int selinux_is_sblabel_mnt(struct super_block *sb) ++static int selinux_is_genfs_special_handling(struct super_block *sb) + { +- struct superblock_security_struct *sbsec = sb->s_security; +- +- return sbsec->behavior == SECURITY_FS_USE_XATTR || +- sbsec->behavior == SECURITY_FS_USE_TRANS || +- sbsec->behavior == SECURITY_FS_USE_TASK || +- sbsec->behavior == SECURITY_FS_USE_NATIVE || +- /* Special handling. Genfs but also in-core setxattr handler */ +- !strcmp(sb->s_type->name, "sysfs") || ++ /* Special handling. Genfs but also in-core setxattr handler */ ++ return !strcmp(sb->s_type->name, "sysfs") || + !strcmp(sb->s_type->name, "pstore") || + !strcmp(sb->s_type->name, "debugfs") || + !strcmp(sb->s_type->name, "tracefs") || +@@ -553,6 +547,34 @@ static int selinux_is_sblabel_mnt(struct super_block *sb) + !strcmp(sb->s_type->name, "cgroup2"))); + } + ++static int selinux_is_sblabel_mnt(struct super_block *sb) ++{ ++ struct superblock_security_struct *sbsec = sb->s_security; ++ ++ /* ++ * IMPORTANT: Double-check logic in this function when adding a new ++ * SECURITY_FS_USE_* definition! ++ */ ++ BUILD_BUG_ON(SECURITY_FS_USE_MAX != 7); ++ ++ switch (sbsec->behavior) { ++ case SECURITY_FS_USE_XATTR: ++ case SECURITY_FS_USE_TRANS: ++ case SECURITY_FS_USE_TASK: ++ case SECURITY_FS_USE_NATIVE: ++ return 1; ++ ++ case SECURITY_FS_USE_GENFS: ++ return selinux_is_genfs_special_handling(sb); ++ ++ /* Never allow relabeling on context mounts */ ++ case SECURITY_FS_USE_MNTPOINT: ++ case SECURITY_FS_USE_NONE: ++ default: ++ return 0; ++ } ++} ++ + static int sb_finish_set_opts(struct super_block *sb) + { + struct superblock_security_struct *sbsec = sb->s_security; +@@ -2985,7 +3007,9 @@ static int selinux_inode_permission(struct inode *inode, int mask) + return PTR_ERR(isec); + + rc = avc_has_perm_noaudit(&selinux_state, +- sid, isec->sid, isec->sclass, perms, 0, &avd); ++ sid, isec->sid, isec->sclass, perms, ++ (flags & MAY_NOT_BLOCK) ? AVC_NONBLOCKING : 0, ++ &avd); + audited = avc_audit_required(perms, &avd, rc, + from_access ? FILE__AUDIT_ACCESS : 0, + &denied); +diff --git a/security/selinux/include/avc.h b/security/selinux/include/avc.h +index ef899bcfd2cb..74ea50977c20 100644 +--- a/security/selinux/include/avc.h ++++ b/security/selinux/include/avc.h +@@ -142,6 +142,7 @@ static inline int avc_audit(struct selinux_state *state, + + #define AVC_STRICT 1 /* Ignore permissive mode. */ + #define AVC_EXTENDED_PERMS 2 /* update extended permissions */ ++#define AVC_NONBLOCKING 4 /* non blocking */ + int avc_has_perm_noaudit(struct selinux_state *state, + u32 ssid, u32 tsid, + u16 tclass, u32 requested, +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index a9f69c3a3e0b..5ce28b4f0218 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -5448,6 +5448,8 @@ static void alc274_fixup_bind_dacs(struct hda_codec *codec, + return; + + spec->gen.preferred_dacs = preferred_pairs; ++ spec->gen.auto_mute_via_amp = 1; ++ codec->power_save_node = 0; + } + + /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */ +@@ -7266,6 +7268,10 @@ static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { + {0x21, 0x02211020}), + SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, + {0x21, 0x02211020}), ++ SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, ++ {0x12, 0x40000000}, ++ {0x14, 0x90170110}, ++ {0x21, 0x02211020}), + SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, + {0x14, 0x90170110}, + {0x21, 0x02211020}), +@@ -7539,6 +7545,13 @@ static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { + {0x12, 0x90a60130}, + {0x17, 0x90170110}, + {0x21, 0x04211020}), ++ SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, ++ {0x12, 0x90a60130}, ++ {0x17, 0x90170110}, ++ {0x21, 0x03211020}), ++ SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, ++ {0x14, 0x90170110}, ++ {0x21, 0x04211020}), + SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, + ALC295_STANDARD_PINS, + {0x17, 0x21014020}, +diff --git a/sound/soc/codecs/wm_adsp.c b/sound/soc/codecs/wm_adsp.c +index 1dd291cebe67..0600e4404f90 100644 +--- a/sound/soc/codecs/wm_adsp.c ++++ b/sound/soc/codecs/wm_adsp.c +@@ -3443,8 +3443,6 @@ int wm_adsp_compr_trigger(struct snd_compr_stream *stream, int cmd) + } + } + +- wm_adsp_buffer_clear(compr->buf); +- + /* Trigger the IRQ at one fragment of data */ + ret = wm_adsp_buffer_write(compr->buf, + HOST_BUFFER_FIELD(high_water_mark), +@@ -3456,6 +3454,8 @@ int wm_adsp_compr_trigger(struct snd_compr_stream *stream, int cmd) + } + break; + case SNDRV_PCM_TRIGGER_STOP: ++ if (wm_adsp_compr_attached(compr)) ++ wm_adsp_buffer_clear(compr->buf); + break; + default: + ret = -EINVAL; +diff --git a/sound/soc/intel/boards/bytcr_rt5651.c b/sound/soc/intel/boards/bytcr_rt5651.c +index e528995668b7..0ed844f2ad01 100644 +--- a/sound/soc/intel/boards/bytcr_rt5651.c ++++ b/sound/soc/intel/boards/bytcr_rt5651.c +@@ -266,7 +266,7 @@ static const struct snd_soc_dapm_route byt_rt5651_audio_map[] = { + static const struct snd_soc_dapm_route byt_rt5651_intmic_dmic_map[] = { + {"DMIC L1", NULL, "Internal Mic"}, + {"DMIC R1", NULL, "Internal Mic"}, +- {"IN3P", NULL, "Headset Mic"}, ++ {"IN2P", NULL, "Headset Mic"}, + }; + + static const struct snd_soc_dapm_route byt_rt5651_intmic_in1_map[] = { +diff --git a/sound/soc/sh/rcar/gen.c b/sound/soc/sh/rcar/gen.c +index 7cda60188f41..af19010b9d88 100644 +--- a/sound/soc/sh/rcar/gen.c ++++ b/sound/soc/sh/rcar/gen.c +@@ -255,6 +255,30 @@ static int rsnd_gen2_probe(struct rsnd_priv *priv) + RSND_GEN_M_REG(SSI_MODE, 0xc, 0x80), + RSND_GEN_M_REG(SSI_CTRL, 0x10, 0x80), + RSND_GEN_M_REG(SSI_INT_ENABLE, 0x18, 0x80), ++ RSND_GEN_S_REG(SSI9_BUSIF0_MODE, 0x48c), ++ RSND_GEN_S_REG(SSI9_BUSIF0_ADINR, 0x484), ++ RSND_GEN_S_REG(SSI9_BUSIF0_DALIGN, 0x488), ++ RSND_GEN_S_REG(SSI9_BUSIF1_MODE, 0x4a0), ++ RSND_GEN_S_REG(SSI9_BUSIF1_ADINR, 0x4a4), ++ RSND_GEN_S_REG(SSI9_BUSIF1_DALIGN, 0x4a8), ++ RSND_GEN_S_REG(SSI9_BUSIF2_MODE, 0x4c0), ++ RSND_GEN_S_REG(SSI9_BUSIF2_ADINR, 0x4c4), ++ RSND_GEN_S_REG(SSI9_BUSIF2_DALIGN, 0x4c8), ++ RSND_GEN_S_REG(SSI9_BUSIF3_MODE, 0x4e0), ++ RSND_GEN_S_REG(SSI9_BUSIF3_ADINR, 0x4e4), ++ RSND_GEN_S_REG(SSI9_BUSIF3_DALIGN, 0x4e8), ++ RSND_GEN_S_REG(SSI9_BUSIF4_MODE, 0xd80), ++ RSND_GEN_S_REG(SSI9_BUSIF4_ADINR, 0xd84), ++ RSND_GEN_S_REG(SSI9_BUSIF4_DALIGN, 0xd88), ++ RSND_GEN_S_REG(SSI9_BUSIF5_MODE, 0xda0), ++ RSND_GEN_S_REG(SSI9_BUSIF5_ADINR, 0xda4), ++ RSND_GEN_S_REG(SSI9_BUSIF5_DALIGN, 0xda8), ++ RSND_GEN_S_REG(SSI9_BUSIF6_MODE, 0xdc0), ++ RSND_GEN_S_REG(SSI9_BUSIF6_ADINR, 0xdc4), ++ RSND_GEN_S_REG(SSI9_BUSIF6_DALIGN, 0xdc8), ++ RSND_GEN_S_REG(SSI9_BUSIF7_MODE, 0xde0), ++ RSND_GEN_S_REG(SSI9_BUSIF7_ADINR, 0xde4), ++ RSND_GEN_S_REG(SSI9_BUSIF7_DALIGN, 0xde8), + }; + + static const struct rsnd_regmap_field_conf conf_scu[] = { +diff --git a/sound/soc/sh/rcar/rsnd.h b/sound/soc/sh/rcar/rsnd.h +index 605e4b934982..90625c57847b 100644 +--- a/sound/soc/sh/rcar/rsnd.h ++++ b/sound/soc/sh/rcar/rsnd.h +@@ -191,6 +191,30 @@ enum rsnd_reg { + SSI_SYS_STATUS7, + HDMI0_SEL, + HDMI1_SEL, ++ SSI9_BUSIF0_MODE, ++ SSI9_BUSIF1_MODE, ++ SSI9_BUSIF2_MODE, ++ SSI9_BUSIF3_MODE, ++ SSI9_BUSIF4_MODE, ++ SSI9_BUSIF5_MODE, ++ SSI9_BUSIF6_MODE, ++ SSI9_BUSIF7_MODE, ++ SSI9_BUSIF0_ADINR, ++ SSI9_BUSIF1_ADINR, ++ SSI9_BUSIF2_ADINR, ++ SSI9_BUSIF3_ADINR, ++ SSI9_BUSIF4_ADINR, ++ SSI9_BUSIF5_ADINR, ++ SSI9_BUSIF6_ADINR, ++ SSI9_BUSIF7_ADINR, ++ SSI9_BUSIF0_DALIGN, ++ SSI9_BUSIF1_DALIGN, ++ SSI9_BUSIF2_DALIGN, ++ SSI9_BUSIF3_DALIGN, ++ SSI9_BUSIF4_DALIGN, ++ SSI9_BUSIF5_DALIGN, ++ SSI9_BUSIF6_DALIGN, ++ SSI9_BUSIF7_DALIGN, + + /* SSI */ + SSICR, +@@ -209,6 +233,9 @@ enum rsnd_reg { + #define SSI_BUSIF_MODE(i) (SSI_BUSIF0_MODE + (i)) + #define SSI_BUSIF_ADINR(i) (SSI_BUSIF0_ADINR + (i)) + #define SSI_BUSIF_DALIGN(i) (SSI_BUSIF0_DALIGN + (i)) ++#define SSI9_BUSIF_MODE(i) (SSI9_BUSIF0_MODE + (i)) ++#define SSI9_BUSIF_ADINR(i) (SSI9_BUSIF0_ADINR + (i)) ++#define SSI9_BUSIF_DALIGN(i) (SSI9_BUSIF0_DALIGN + (i)) + #define SSI_SYS_STATUS(i) (SSI_SYS_STATUS0 + (i)) + + +diff --git a/sound/soc/sh/rcar/ssiu.c b/sound/soc/sh/rcar/ssiu.c +index c74991dd18ab..2347f3404c06 100644 +--- a/sound/soc/sh/rcar/ssiu.c ++++ b/sound/soc/sh/rcar/ssiu.c +@@ -181,28 +181,26 @@ static int rsnd_ssiu_init_gen2(struct rsnd_mod *mod, + if (rsnd_ssi_use_busif(io)) { + int id = rsnd_mod_id(mod); + int busif = rsnd_mod_id_sub(mod); ++ enum rsnd_reg adinr_reg, mode_reg, dalign_reg; + +- /* +- * FIXME +- * +- * We can't support SSI9-4/5/6/7, because its address is +- * out of calculation rule +- */ + if ((id == 9) && (busif >= 4)) { +- struct device *dev = rsnd_priv_to_dev(priv); +- +- dev_err(dev, "This driver doesn't support SSI%d-%d, so far", +- id, busif); ++ adinr_reg = SSI9_BUSIF_ADINR(busif); ++ mode_reg = SSI9_BUSIF_MODE(busif); ++ dalign_reg = SSI9_BUSIF_DALIGN(busif); ++ } else { ++ adinr_reg = SSI_BUSIF_ADINR(busif); ++ mode_reg = SSI_BUSIF_MODE(busif); ++ dalign_reg = SSI_BUSIF_DALIGN(busif); + } + +- rsnd_mod_write(mod, SSI_BUSIF_ADINR(busif), ++ rsnd_mod_write(mod, adinr_reg, + rsnd_get_adinr_bit(mod, io) | + (rsnd_io_is_play(io) ? + rsnd_runtime_channel_after_ctu(io) : + rsnd_runtime_channel_original(io))); +- rsnd_mod_write(mod, SSI_BUSIF_MODE(busif), ++ rsnd_mod_write(mod, mode_reg, + rsnd_get_busif_shift(io, mod) | 1); +- rsnd_mod_write(mod, SSI_BUSIF_DALIGN(busif), ++ rsnd_mod_write(mod, dalign_reg, + rsnd_get_dalign(mod, io)); + } + +diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c +index 03f36e534050..0c1dd6bd67ab 100644 +--- a/sound/soc/soc-pcm.c ++++ b/sound/soc/soc-pcm.c +@@ -1895,10 +1895,15 @@ static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream, + struct snd_soc_pcm_runtime *be = dpcm->be; + struct snd_pcm_substream *be_substream = + snd_soc_dpcm_get_substream(be, stream); +- struct snd_soc_pcm_runtime *rtd = be_substream->private_data; ++ struct snd_soc_pcm_runtime *rtd; + struct snd_soc_dai *codec_dai; + int i; + ++ /* A backend may not have the requested substream */ ++ if (!be_substream) ++ continue; ++ ++ rtd = be_substream->private_data; + if (rtd->dai_link->be_hw_params_fixup) + continue; + +diff --git a/sound/soc/stm/stm32_sai_sub.c b/sound/soc/stm/stm32_sai_sub.c +index d4825700b63f..29a131e0569e 100644 +--- a/sound/soc/stm/stm32_sai_sub.c ++++ b/sound/soc/stm/stm32_sai_sub.c +@@ -1394,7 +1394,6 @@ static int stm32_sai_sub_dais_init(struct platform_device *pdev, + if (!sai->cpu_dai_drv) + return -ENOMEM; + +- sai->cpu_dai_drv->name = dev_name(&pdev->dev); + if (STM_SAI_IS_PLAYBACK(sai)) { + memcpy(sai->cpu_dai_drv, &stm32_sai_playback_dai, + sizeof(stm32_sai_playback_dai)); +@@ -1404,6 +1403,7 @@ static int stm32_sai_sub_dais_init(struct platform_device *pdev, + sizeof(stm32_sai_capture_dai)); + sai->cpu_dai_drv->capture.stream_name = sai->cpu_dai_drv->name; + } ++ sai->cpu_dai_drv->name = dev_name(&pdev->dev); + + return 0; + } +diff --git a/sound/soc/sunxi/sun50i-codec-analog.c b/sound/soc/sunxi/sun50i-codec-analog.c +index df1fed0aa001..d105c90c3706 100644 +--- a/sound/soc/sunxi/sun50i-codec-analog.c ++++ b/sound/soc/sunxi/sun50i-codec-analog.c +@@ -274,7 +274,7 @@ static const struct snd_soc_dapm_widget sun50i_a64_codec_widgets[] = { + * stream widgets at the card level. + */ + +- SND_SOC_DAPM_REGULATOR_SUPPLY("hpvcc", 0, 0), ++ SND_SOC_DAPM_REGULATOR_SUPPLY("cpvdd", 0, 0), + SND_SOC_DAPM_MUX("Headphone Source Playback Route", + SND_SOC_NOPM, 0, 0, sun50i_codec_hp_src), + SND_SOC_DAPM_OUT_DRV("Headphone Amp", SUN50I_ADDA_HP_CTRL, +@@ -362,7 +362,7 @@ static const struct snd_soc_dapm_route sun50i_a64_codec_routes[] = { + { "Headphone Source Playback Route", "Mixer", "Left Mixer" }, + { "Headphone Source Playback Route", "Mixer", "Right Mixer" }, + { "Headphone Amp", NULL, "Headphone Source Playback Route" }, +- { "Headphone Amp", NULL, "hpvcc" }, ++ { "Headphone Amp", NULL, "cpvdd" }, + { "HP", NULL, "Headphone Amp" }, + + /* Microphone Routes */ +diff --git a/tools/testing/selftests/seccomp/seccomp_bpf.c b/tools/testing/selftests/seccomp/seccomp_bpf.c +index 6d7a81306f8a..1c2509104924 100644 +--- a/tools/testing/selftests/seccomp/seccomp_bpf.c ++++ b/tools/testing/selftests/seccomp/seccomp_bpf.c +@@ -2166,11 +2166,14 @@ TEST(detect_seccomp_filter_flags) + SECCOMP_FILTER_FLAG_LOG, + SECCOMP_FILTER_FLAG_SPEC_ALLOW, + SECCOMP_FILTER_FLAG_NEW_LISTENER }; +- unsigned int flag, all_flags; ++ unsigned int exclusive[] = { ++ SECCOMP_FILTER_FLAG_TSYNC, ++ SECCOMP_FILTER_FLAG_NEW_LISTENER }; ++ unsigned int flag, all_flags, exclusive_mask; + int i; + long ret; + +- /* Test detection of known-good filter flags */ ++ /* Test detection of individual known-good filter flags */ + for (i = 0, all_flags = 0; i < ARRAY_SIZE(flags); i++) { + int bits = 0; + +@@ -2197,16 +2200,29 @@ TEST(detect_seccomp_filter_flags) + all_flags |= flag; + } + +- /* Test detection of all known-good filter flags */ +- ret = seccomp(SECCOMP_SET_MODE_FILTER, all_flags, NULL); +- EXPECT_EQ(-1, ret); +- EXPECT_EQ(EFAULT, errno) { +- TH_LOG("Failed to detect that all known-good filter flags (0x%X) are supported!", +- all_flags); ++ /* ++ * Test detection of all known-good filter flags combined. But ++ * for the exclusive flags we need to mask them out and try them ++ * individually for the "all flags" testing. ++ */ ++ exclusive_mask = 0; ++ for (i = 0; i < ARRAY_SIZE(exclusive); i++) ++ exclusive_mask |= exclusive[i]; ++ for (i = 0; i < ARRAY_SIZE(exclusive); i++) { ++ flag = all_flags & ~exclusive_mask; ++ flag |= exclusive[i]; ++ ++ ret = seccomp(SECCOMP_SET_MODE_FILTER, flag, NULL); ++ EXPECT_EQ(-1, ret); ++ EXPECT_EQ(EFAULT, errno) { ++ TH_LOG("Failed to detect that all known-good filter flags (0x%X) are supported!", ++ flag); ++ } + } + +- /* Test detection of an unknown filter flag */ ++ /* Test detection of an unknown filter flags, without exclusives. */ + flag = -1; ++ flag &= ~exclusive_mask; + ret = seccomp(SECCOMP_SET_MODE_FILTER, flag, NULL); + EXPECT_EQ(-1, ret); + EXPECT_EQ(EINVAL, errno) { |