diff options
| author |   Mike Pagano <mpagano@gentoo.org> | 2021-03-07 10:17:56 -0500 |
|---|---|---|
| committer | Mike Pagano <mpagano@gentoo.org> | 2021-03-07 10:17:56 -0500 |
| commit | 11bd1905e900544a217bfe395c2fbed5df9cccd9 (patch) | |
| tree | b588dd4f95782b11c1bdba20e4329dc85b7c1809 | |
| parent | Add cpu opt patch for gcc v9 (diff) | |
| download | linux-patches-11bd1905e900544a217bfe395c2fbed5df9cccd9.tar.gz linux-patches-11bd1905e900544a217bfe395c2fbed5df9cccd9.tar.bz2 linux-patches-11bd1905e900544a217bfe395c2fbed5df9cccd9.zip | |
Linux patch 5.11.45.11-5
Signed-off-by: Mike Pagano <mpagano@gentoo.org>
| -rw-r--r-- | 0000_README | 4 | ||||
| -rw-r--r-- | 1003_linux-5.11.4.patch | 5114 |
2 files changed, 5118 insertions, 0 deletions
diff --git a/0000_README b/0000_README index 7799ef6b..196569bf 100644 --- a/0000_README +++ b/0000_README @@ -55,6 +55,10 @@ Patch: 1002_linux-5.11.3.patch From: http://www.kernel.org Desc: Linux 5.11.3 +Patch: 1003_linux-5.11.4.patch +From: http://www.kernel.org +Desc: Linux 5.11.4 + 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/1003_linux-5.11.4.patch b/1003_linux-5.11.4.patch new file mode 100644 index 00000000..babf7098 --- /dev/null +++ b/1003_linux-5.11.4.patch @@ -0,0 +1,5114 @@ +diff --git a/Documentation/devicetree/bindings/net/btusb.txt b/Documentation/devicetree/bindings/net/btusb.txt +index b1ad6ee68e909..c51dd99dc0d3c 100644 +--- a/Documentation/devicetree/bindings/net/btusb.txt ++++ b/Documentation/devicetree/bindings/net/btusb.txt +@@ -38,7 +38,7 @@ Following example uses irq pin number 3 of gpio0 for out of band wake-on-bt: + compatible = "usb1286,204e"; + reg = <1>; + interrupt-parent = <&gpio0>; +- interrupt-name = "wakeup"; ++ interrupt-names = "wakeup"; + interrupts = <3 IRQ_TYPE_LEVEL_LOW>; + }; + }; +diff --git a/Documentation/devicetree/bindings/net/ethernet-controller.yaml b/Documentation/devicetree/bindings/net/ethernet-controller.yaml +index dac4aadb6e2e7..880e55f7a4b13 100644 +--- a/Documentation/devicetree/bindings/net/ethernet-controller.yaml ++++ b/Documentation/devicetree/bindings/net/ethernet-controller.yaml +@@ -205,6 +205,11 @@ properties: + Indicates that full-duplex is used. When absent, half + duplex is assumed. + ++ pause: ++ $ref: /schemas/types.yaml#definitions/flag ++ description: ++ Indicates that pause should be enabled. ++ + asym-pause: + $ref: /schemas/types.yaml#/definitions/flag + description: +diff --git a/Documentation/networking/ip-sysctl.rst b/Documentation/networking/ip-sysctl.rst +index fa544e9037b99..1b7f8debada6a 100644 +--- a/Documentation/networking/ip-sysctl.rst ++++ b/Documentation/networking/ip-sysctl.rst +@@ -630,16 +630,15 @@ tcp_rmem - vector of 3 INTEGERs: min, default, max + + default: initial size of receive buffer used by TCP sockets. + This value overrides net.core.rmem_default used by other protocols. +- Default: 87380 bytes. This value results in window of 65535 with +- default setting of tcp_adv_win_scale and tcp_app_win:0 and a bit +- less for default tcp_app_win. See below about these variables. ++ Default: 131072 bytes. ++ This value results in initial window of 65535. + + max: maximal size of receive buffer allowed for automatically + selected receiver buffers for TCP socket. This value does not override + net.core.rmem_max. Calling setsockopt() with SO_RCVBUF disables + automatic tuning of that socket's receive buffer size, in which + case this value is ignored. +- Default: between 87380B and 6MB, depending on RAM size. ++ Default: between 131072 and 6MB, depending on RAM size. + + tcp_sack - BOOLEAN + Enable select acknowledgments (SACKS). +diff --git a/Makefile b/Makefile +index a8c1162de3a0b..cb9a8e8239511 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 11 +-SUBLEVEL = 3 ++SUBLEVEL = 4 + EXTRAVERSION = + NAME = 💕 Valentine's Day Edition 💕 + +diff --git a/arch/arm/xen/p2m.c b/arch/arm/xen/p2m.c +index fd6e3aafe2724..acb464547a54f 100644 +--- a/arch/arm/xen/p2m.c ++++ b/arch/arm/xen/p2m.c +@@ -93,12 +93,39 @@ int set_foreign_p2m_mapping(struct gnttab_map_grant_ref *map_ops, + int i; + + for (i = 0; i < count; i++) { ++ struct gnttab_unmap_grant_ref unmap; ++ int rc; ++ + if (map_ops[i].status) + continue; +- if (unlikely(!set_phys_to_machine(map_ops[i].host_addr >> XEN_PAGE_SHIFT, +- map_ops[i].dev_bus_addr >> XEN_PAGE_SHIFT))) { +- return -ENOMEM; +- } ++ if (likely(set_phys_to_machine(map_ops[i].host_addr >> XEN_PAGE_SHIFT, ++ map_ops[i].dev_bus_addr >> XEN_PAGE_SHIFT))) ++ continue; ++ ++ /* ++ * Signal an error for this slot. This in turn requires ++ * immediate unmapping. ++ */ ++ map_ops[i].status = GNTST_general_error; ++ unmap.host_addr = map_ops[i].host_addr, ++ unmap.handle = map_ops[i].handle; ++ map_ops[i].handle = ~0; ++ if (map_ops[i].flags & GNTMAP_device_map) ++ unmap.dev_bus_addr = map_ops[i].dev_bus_addr; ++ else ++ unmap.dev_bus_addr = 0; ++ ++ /* ++ * Pre-populate the status field, to be recognizable in ++ * the log message below. ++ */ ++ unmap.status = 1; ++ ++ rc = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, ++ &unmap, 1); ++ if (rc || unmap.status != GNTST_okay) ++ pr_err_once("gnttab unmap failed: rc=%d st=%d\n", ++ rc, unmap.status); + } + + return 0; +diff --git a/arch/parisc/kernel/irq.c b/arch/parisc/kernel/irq.c +index 49cd6d2caefb7..1dfb439b06928 100644 +--- a/arch/parisc/kernel/irq.c ++++ b/arch/parisc/kernel/irq.c +@@ -373,7 +373,11 @@ static inline int eirr_to_irq(unsigned long eirr) + /* + * IRQ STACK - used for irq handler + */ ++#ifdef CONFIG_64BIT ++#define IRQ_STACK_SIZE (4096 << 4) /* 64k irq stack size */ ++#else + #define IRQ_STACK_SIZE (4096 << 3) /* 32k irq stack size */ ++#endif + + union irq_stack_union { + unsigned long stack[IRQ_STACK_SIZE/sizeof(unsigned long)]; +diff --git a/arch/riscv/mm/init.c b/arch/riscv/mm/init.c +index f9f9568d689ef..f81f813b96031 100644 +--- a/arch/riscv/mm/init.c ++++ b/arch/riscv/mm/init.c +@@ -226,8 +226,6 @@ pgd_t swapper_pg_dir[PTRS_PER_PGD] __page_aligned_bss; + pgd_t trampoline_pg_dir[PTRS_PER_PGD] __page_aligned_bss; + pte_t fixmap_pte[PTRS_PER_PTE] __page_aligned_bss; + +-#define MAX_EARLY_MAPPING_SIZE SZ_128M +- + pgd_t early_pg_dir[PTRS_PER_PGD] __initdata __aligned(PAGE_SIZE); + + void __set_fixmap(enum fixed_addresses idx, phys_addr_t phys, pgprot_t prot) +@@ -302,13 +300,7 @@ static void __init create_pte_mapping(pte_t *ptep, + + pmd_t trampoline_pmd[PTRS_PER_PMD] __page_aligned_bss; + pmd_t fixmap_pmd[PTRS_PER_PMD] __page_aligned_bss; +- +-#if MAX_EARLY_MAPPING_SIZE < PGDIR_SIZE +-#define NUM_EARLY_PMDS 1UL +-#else +-#define NUM_EARLY_PMDS (1UL + MAX_EARLY_MAPPING_SIZE / PGDIR_SIZE) +-#endif +-pmd_t early_pmd[PTRS_PER_PMD * NUM_EARLY_PMDS] __initdata __aligned(PAGE_SIZE); ++pmd_t early_pmd[PTRS_PER_PMD] __initdata __aligned(PAGE_SIZE); + pmd_t early_dtb_pmd[PTRS_PER_PMD] __initdata __aligned(PAGE_SIZE); + + static pmd_t *__init get_pmd_virt_early(phys_addr_t pa) +@@ -330,11 +322,9 @@ static pmd_t *get_pmd_virt_late(phys_addr_t pa) + + static phys_addr_t __init alloc_pmd_early(uintptr_t va) + { +- uintptr_t pmd_num; ++ BUG_ON((va - PAGE_OFFSET) >> PGDIR_SHIFT); + +- pmd_num = (va - PAGE_OFFSET) >> PGDIR_SHIFT; +- BUG_ON(pmd_num >= NUM_EARLY_PMDS); +- return (uintptr_t)&early_pmd[pmd_num * PTRS_PER_PMD]; ++ return (uintptr_t)early_pmd; + } + + static phys_addr_t __init alloc_pmd_fixmap(uintptr_t va) +@@ -452,7 +442,7 @@ asmlinkage void __init setup_vm(uintptr_t dtb_pa) + uintptr_t va, pa, end_va; + uintptr_t load_pa = (uintptr_t)(&_start); + uintptr_t load_sz = (uintptr_t)(&_end) - load_pa; +- uintptr_t map_size = best_map_size(load_pa, MAX_EARLY_MAPPING_SIZE); ++ uintptr_t map_size; + #ifndef __PAGETABLE_PMD_FOLDED + pmd_t fix_bmap_spmd, fix_bmap_epmd; + #endif +@@ -464,12 +454,11 @@ asmlinkage void __init setup_vm(uintptr_t dtb_pa) + * Enforce boot alignment requirements of RV32 and + * RV64 by only allowing PMD or PGD mappings. + */ +- BUG_ON(map_size == PAGE_SIZE); ++ map_size = PMD_SIZE; + + /* Sanity check alignment and size */ + BUG_ON((PAGE_OFFSET % PGDIR_SIZE) != 0); + BUG_ON((load_pa % map_size) != 0); +- BUG_ON(load_sz > MAX_EARLY_MAPPING_SIZE); + + pt_ops.alloc_pte = alloc_pte_early; + pt_ops.get_pte_virt = get_pte_virt_early; +diff --git a/arch/x86/events/intel/core.c b/arch/x86/events/intel/core.c +index d4569bfa83e30..4faaef3a8f6c4 100644 +--- a/arch/x86/events/intel/core.c ++++ b/arch/x86/events/intel/core.c +@@ -4397,6 +4397,9 @@ static const struct x86_cpu_desc isolation_ucodes[] = { + INTEL_CPU_DESC(INTEL_FAM6_BROADWELL_X, 2, 0x0b000014), + INTEL_CPU_DESC(INTEL_FAM6_SKYLAKE_X, 3, 0x00000021), + INTEL_CPU_DESC(INTEL_FAM6_SKYLAKE_X, 4, 0x00000000), ++ INTEL_CPU_DESC(INTEL_FAM6_SKYLAKE_X, 5, 0x00000000), ++ INTEL_CPU_DESC(INTEL_FAM6_SKYLAKE_X, 6, 0x00000000), ++ INTEL_CPU_DESC(INTEL_FAM6_SKYLAKE_X, 7, 0x00000000), + INTEL_CPU_DESC(INTEL_FAM6_SKYLAKE_L, 3, 0x0000007c), + INTEL_CPU_DESC(INTEL_FAM6_SKYLAKE, 3, 0x0000007c), + INTEL_CPU_DESC(INTEL_FAM6_KABYLAKE, 9, 0x0000004e), +diff --git a/arch/x86/include/asm/xen/page.h b/arch/x86/include/asm/xen/page.h +index 1a162e559753b..7068e4bb057d9 100644 +--- a/arch/x86/include/asm/xen/page.h ++++ b/arch/x86/include/asm/xen/page.h +@@ -86,6 +86,18 @@ clear_foreign_p2m_mapping(struct gnttab_unmap_grant_ref *unmap_ops, + } + #endif + ++/* ++ * The maximum amount of extra memory compared to the base size. The ++ * main scaling factor is the size of struct page. At extreme ratios ++ * of base:extra, all the base memory can be filled with page ++ * structures for the extra memory, leaving no space for anything ++ * else. ++ * ++ * 10x seems like a reasonable balance between scaling flexibility and ++ * leaving a practically usable system. ++ */ ++#define XEN_EXTRA_MEM_RATIO (10) ++ + /* + * Helper functions to write or read unsigned long values to/from + * memory, when the access may fault. +diff --git a/arch/x86/kernel/module.c b/arch/x86/kernel/module.c +index 34b153cbd4acb..5e9a34b5bd741 100644 +--- a/arch/x86/kernel/module.c ++++ b/arch/x86/kernel/module.c +@@ -114,6 +114,7 @@ int apply_relocate(Elf32_Shdr *sechdrs, + *location += sym->st_value; + break; + case R_386_PC32: ++ case R_386_PLT32: + /* Add the value, subtract its position */ + *location += sym->st_value - (uint32_t)location; + break; +diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c +index efbaef8b4de98..b29657b76e3fa 100644 +--- a/arch/x86/kernel/reboot.c ++++ b/arch/x86/kernel/reboot.c +@@ -477,6 +477,15 @@ static const struct dmi_system_id reboot_dmi_table[] __initconst = { + }, + }, + ++ { /* PCIe Wifi card isn't detected after reboot otherwise */ ++ .callback = set_pci_reboot, ++ .ident = "Zotac ZBOX CI327 nano", ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "NA"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "ZBOX-CI327NANO-GS-01"), ++ }, ++ }, ++ + /* Sony */ + { /* Handle problems with rebooting on Sony VGN-Z540N */ + .callback = set_bios_reboot, +diff --git a/arch/x86/tools/relocs.c b/arch/x86/tools/relocs.c +index ce7188cbdae58..1c3a1962cade6 100644 +--- a/arch/x86/tools/relocs.c ++++ b/arch/x86/tools/relocs.c +@@ -867,9 +867,11 @@ static int do_reloc32(struct section *sec, Elf_Rel *rel, Elf_Sym *sym, + case R_386_PC32: + case R_386_PC16: + case R_386_PC8: ++ case R_386_PLT32: + /* +- * NONE can be ignored and PC relative relocations don't +- * need to be adjusted. ++ * NONE can be ignored and PC relative relocations don't need ++ * to be adjusted. Because sym must be defined, R_386_PLT32 can ++ * be treated the same way as R_386_PC32. + */ + break; + +@@ -910,9 +912,11 @@ static int do_reloc_real(struct section *sec, Elf_Rel *rel, Elf_Sym *sym, + case R_386_PC32: + case R_386_PC16: + case R_386_PC8: ++ case R_386_PLT32: + /* +- * NONE can be ignored and PC relative relocations don't +- * need to be adjusted. ++ * NONE can be ignored and PC relative relocations don't need ++ * to be adjusted. Because sym must be defined, R_386_PLT32 can ++ * be treated the same way as R_386_PC32. + */ + break; + +diff --git a/arch/x86/xen/p2m.c b/arch/x86/xen/p2m.c +index b5949e5a83ec8..a3cc33091f46c 100644 +--- a/arch/x86/xen/p2m.c ++++ b/arch/x86/xen/p2m.c +@@ -416,6 +416,9 @@ void __init xen_vmalloc_p2m_tree(void) + xen_p2m_last_pfn = xen_max_p2m_pfn; + + p2m_limit = (phys_addr_t)P2M_LIMIT * 1024 * 1024 * 1024 / PAGE_SIZE; ++ if (!p2m_limit && IS_ENABLED(CONFIG_XEN_UNPOPULATED_ALLOC)) ++ p2m_limit = xen_start_info->nr_pages * XEN_EXTRA_MEM_RATIO; ++ + vm.flags = VM_ALLOC; + vm.size = ALIGN(sizeof(unsigned long) * max(xen_max_p2m_pfn, p2m_limit), + PMD_SIZE * PMDS_PER_MID_PAGE); +@@ -652,10 +655,9 @@ bool __set_phys_to_machine(unsigned long pfn, unsigned long mfn) + pte_t *ptep; + unsigned int level; + +- if (unlikely(pfn >= xen_p2m_size)) { +- BUG_ON(mfn != INVALID_P2M_ENTRY); +- return true; +- } ++ /* Only invalid entries allowed above the highest p2m covered frame. */ ++ if (unlikely(pfn >= xen_p2m_size)) ++ return mfn == INVALID_P2M_ENTRY; + + /* + * The interface requires atomic updates on p2m elements. +@@ -710,6 +712,8 @@ int set_foreign_p2m_mapping(struct gnttab_map_grant_ref *map_ops, + + for (i = 0; i < count; i++) { + unsigned long mfn, pfn; ++ struct gnttab_unmap_grant_ref unmap[2]; ++ int rc; + + /* Do not add to override if the map failed. */ + if (map_ops[i].status != GNTST_okay || +@@ -727,10 +731,46 @@ int set_foreign_p2m_mapping(struct gnttab_map_grant_ref *map_ops, + + WARN(pfn_to_mfn(pfn) != INVALID_P2M_ENTRY, "page must be ballooned"); + +- if (unlikely(!set_phys_to_machine(pfn, FOREIGN_FRAME(mfn)))) { +- ret = -ENOMEM; +- goto out; ++ if (likely(set_phys_to_machine(pfn, FOREIGN_FRAME(mfn)))) ++ continue; ++ ++ /* ++ * Signal an error for this slot. This in turn requires ++ * immediate unmapping. ++ */ ++ map_ops[i].status = GNTST_general_error; ++ unmap[0].host_addr = map_ops[i].host_addr, ++ unmap[0].handle = map_ops[i].handle; ++ map_ops[i].handle = ~0; ++ if (map_ops[i].flags & GNTMAP_device_map) ++ unmap[0].dev_bus_addr = map_ops[i].dev_bus_addr; ++ else ++ unmap[0].dev_bus_addr = 0; ++ ++ if (kmap_ops) { ++ kmap_ops[i].status = GNTST_general_error; ++ unmap[1].host_addr = kmap_ops[i].host_addr, ++ unmap[1].handle = kmap_ops[i].handle; ++ kmap_ops[i].handle = ~0; ++ if (kmap_ops[i].flags & GNTMAP_device_map) ++ unmap[1].dev_bus_addr = kmap_ops[i].dev_bus_addr; ++ else ++ unmap[1].dev_bus_addr = 0; + } ++ ++ /* ++ * Pre-populate both status fields, to be recognizable in ++ * the log message below. ++ */ ++ unmap[0].status = 1; ++ unmap[1].status = 1; ++ ++ rc = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, ++ unmap, 1 + !!kmap_ops); ++ if (rc || unmap[0].status != GNTST_okay || ++ unmap[1].status != GNTST_okay) ++ pr_err_once("gnttab unmap failed: rc=%d st0=%d st1=%d\n", ++ rc, unmap[0].status, unmap[1].status); + } + + out: +diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c +index 7eab14d56369d..1a3b75652fa4f 100644 +--- a/arch/x86/xen/setup.c ++++ b/arch/x86/xen/setup.c +@@ -59,18 +59,6 @@ static struct { + } xen_remap_buf __initdata __aligned(PAGE_SIZE); + static unsigned long xen_remap_mfn __initdata = INVALID_P2M_ENTRY; + +-/* +- * The maximum amount of extra memory compared to the base size. The +- * main scaling factor is the size of struct page. At extreme ratios +- * of base:extra, all the base memory can be filled with page +- * structures for the extra memory, leaving no space for anything +- * else. +- * +- * 10x seems like a reasonable balance between scaling flexibility and +- * leaving a practically usable system. +- */ +-#define EXTRA_MEM_RATIO (10) +- + static bool xen_512gb_limit __initdata = IS_ENABLED(CONFIG_XEN_512GB); + + static void __init xen_parse_512gb(void) +@@ -790,20 +778,13 @@ char * __init xen_memory_setup(void) + extra_pages += max_pages - max_pfn; + + /* +- * Clamp the amount of extra memory to a EXTRA_MEM_RATIO +- * factor the base size. On non-highmem systems, the base +- * size is the full initial memory allocation; on highmem it +- * is limited to the max size of lowmem, so that it doesn't +- * get completely filled. ++ * Clamp the amount of extra memory to a XEN_EXTRA_MEM_RATIO ++ * factor the base size. + * + * Make sure we have no memory above max_pages, as this area + * isn't handled by the p2m management. +- * +- * In principle there could be a problem in lowmem systems if +- * the initial memory is also very large with respect to +- * lowmem, but we won't try to deal with that here. + */ +- extra_pages = min3(EXTRA_MEM_RATIO * min(max_pfn, PFN_DOWN(MAXMEM)), ++ extra_pages = min3(XEN_EXTRA_MEM_RATIO * min(max_pfn, PFN_DOWN(MAXMEM)), + extra_pages, max_pages - max_pfn); + i = 0; + addr = xen_e820_table.entries[0].addr; +diff --git a/crypto/tcrypt.c b/crypto/tcrypt.c +index a647bb298fbce..a4a11d2b57bd8 100644 +--- a/crypto/tcrypt.c ++++ b/crypto/tcrypt.c +@@ -199,8 +199,8 @@ static int test_mb_aead_jiffies(struct test_mb_aead_data *data, int enc, + goto out; + } + +- pr_cont("%d operations in %d seconds (%ld bytes)\n", +- bcount * num_mb, secs, (long)bcount * blen * num_mb); ++ pr_cont("%d operations in %d seconds (%llu bytes)\n", ++ bcount * num_mb, secs, (u64)bcount * blen * num_mb); + + out: + kfree(rc); +@@ -471,8 +471,8 @@ static int test_aead_jiffies(struct aead_request *req, int enc, + return ret; + } + +- printk("%d operations in %d seconds (%ld bytes)\n", +- bcount, secs, (long)bcount * blen); ++ pr_cont("%d operations in %d seconds (%llu bytes)\n", ++ bcount, secs, (u64)bcount * blen); + return 0; + } + +@@ -764,8 +764,8 @@ static int test_mb_ahash_jiffies(struct test_mb_ahash_data *data, int blen, + goto out; + } + +- pr_cont("%d operations in %d seconds (%ld bytes)\n", +- bcount * num_mb, secs, (long)bcount * blen * num_mb); ++ pr_cont("%d operations in %d seconds (%llu bytes)\n", ++ bcount * num_mb, secs, (u64)bcount * blen * num_mb); + + out: + kfree(rc); +@@ -1201,8 +1201,8 @@ static int test_mb_acipher_jiffies(struct test_mb_skcipher_data *data, int enc, + goto out; + } + +- pr_cont("%d operations in %d seconds (%ld bytes)\n", +- bcount * num_mb, secs, (long)bcount * blen * num_mb); ++ pr_cont("%d operations in %d seconds (%llu bytes)\n", ++ bcount * num_mb, secs, (u64)bcount * blen * num_mb); + + out: + kfree(rc); +@@ -1441,8 +1441,8 @@ static int test_acipher_jiffies(struct skcipher_request *req, int enc, + return ret; + } + +- pr_cont("%d operations in %d seconds (%ld bytes)\n", +- bcount, secs, (long)bcount * blen); ++ pr_cont("%d operations in %d seconds (%llu bytes)\n", ++ bcount, secs, (u64)bcount * blen); + return 0; + } + +diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c +index e6ea5d344f87b..0f3bab47c0d6c 100644 +--- a/drivers/block/nbd.c ++++ b/drivers/block/nbd.c +@@ -78,8 +78,7 @@ struct link_dead_args { + #define NBD_RT_HAS_PID_FILE 3 + #define NBD_RT_HAS_CONFIG_REF 4 + #define NBD_RT_BOUND 5 +-#define NBD_RT_DESTROY_ON_DISCONNECT 6 +-#define NBD_RT_DISCONNECT_ON_CLOSE 7 ++#define NBD_RT_DISCONNECT_ON_CLOSE 6 + + #define NBD_DESTROY_ON_DISCONNECT 0 + #define NBD_DISCONNECT_REQUESTED 1 +@@ -1924,12 +1923,21 @@ again: + if (info->attrs[NBD_ATTR_CLIENT_FLAGS]) { + u64 flags = nla_get_u64(info->attrs[NBD_ATTR_CLIENT_FLAGS]); + if (flags & NBD_CFLAG_DESTROY_ON_DISCONNECT) { +- set_bit(NBD_RT_DESTROY_ON_DISCONNECT, +- &config->runtime_flags); +- set_bit(NBD_DESTROY_ON_DISCONNECT, &nbd->flags); +- put_dev = true; ++ /* ++ * We have 1 ref to keep the device around, and then 1 ++ * ref for our current operation here, which will be ++ * inherited by the config. If we already have ++ * DESTROY_ON_DISCONNECT set then we know we don't have ++ * that extra ref already held so we don't need the ++ * put_dev. ++ */ ++ if (!test_and_set_bit(NBD_DESTROY_ON_DISCONNECT, ++ &nbd->flags)) ++ put_dev = true; + } else { +- clear_bit(NBD_DESTROY_ON_DISCONNECT, &nbd->flags); ++ if (test_and_clear_bit(NBD_DESTROY_ON_DISCONNECT, ++ &nbd->flags)) ++ refcount_inc(&nbd->refs); + } + if (flags & NBD_CFLAG_DISCONNECT_ON_CLOSE) { + set_bit(NBD_RT_DISCONNECT_ON_CLOSE, +@@ -2100,15 +2108,13 @@ static int nbd_genl_reconfigure(struct sk_buff *skb, struct genl_info *info) + if (info->attrs[NBD_ATTR_CLIENT_FLAGS]) { + u64 flags = nla_get_u64(info->attrs[NBD_ATTR_CLIENT_FLAGS]); + if (flags & NBD_CFLAG_DESTROY_ON_DISCONNECT) { +- if (!test_and_set_bit(NBD_RT_DESTROY_ON_DISCONNECT, +- &config->runtime_flags)) ++ if (!test_and_set_bit(NBD_DESTROY_ON_DISCONNECT, ++ &nbd->flags)) + put_dev = true; +- set_bit(NBD_DESTROY_ON_DISCONNECT, &nbd->flags); + } else { +- if (test_and_clear_bit(NBD_RT_DESTROY_ON_DISCONNECT, +- &config->runtime_flags)) ++ if (test_and_clear_bit(NBD_DESTROY_ON_DISCONNECT, ++ &nbd->flags)) + refcount_inc(&nbd->refs); +- clear_bit(NBD_DESTROY_ON_DISCONNECT, &nbd->flags); + } + + if (flags & NBD_CFLAG_DISCONNECT_ON_CLOSE) { +diff --git a/drivers/bluetooth/hci_h5.c b/drivers/bluetooth/hci_h5.c +index 7be16a7f653bd..95ecd30e6619e 100644 +--- a/drivers/bluetooth/hci_h5.c ++++ b/drivers/bluetooth/hci_h5.c +@@ -906,6 +906,11 @@ static int h5_btrtl_setup(struct h5 *h5) + /* Give the device some time before the hci-core sends it a reset */ + usleep_range(10000, 20000); + ++ /* Enable controller to do both LE scan and BR/EDR inquiry ++ * simultaneously. ++ */ ++ set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &h5->hu->hdev->quirks); ++ + out_free: + btrtl_free(btrtl_dev); + +diff --git a/drivers/edac/amd64_edac.c b/drivers/edac/amd64_edac.c +index f7087ddddb902..5754f429a8d2d 100644 +--- a/drivers/edac/amd64_edac.c ++++ b/drivers/edac/amd64_edac.c +@@ -3342,10 +3342,13 @@ static struct amd64_family_type *per_family_init(struct amd64_pvt *pvt) + fam_type = &family_types[F15_M60H_CPUS]; + pvt->ops = &family_types[F15_M60H_CPUS].ops; + break; ++ /* Richland is only client */ ++ } else if (pvt->model == 0x13) { ++ return NULL; ++ } else { ++ fam_type = &family_types[F15_CPUS]; ++ pvt->ops = &family_types[F15_CPUS].ops; + } +- +- fam_type = &family_types[F15_CPUS]; +- pvt->ops = &family_types[F15_CPUS].ops; + break; + + case 0x16: +@@ -3539,6 +3542,7 @@ static int probe_one_instance(unsigned int nid) + pvt->mc_node_id = nid; + pvt->F3 = F3; + ++ ret = -ENODEV; + fam_type = per_family_init(pvt); + if (!fam_type) + goto err_enable; +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_virt.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_virt.c +index 2d51b7694d1fd..572153d08ad11 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_virt.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_virt.c +@@ -560,10 +560,14 @@ static int amdgpu_virt_write_vf2pf_data(struct amdgpu_device *adev) + static void amdgpu_virt_update_vf2pf_work_item(struct work_struct *work) + { + struct amdgpu_device *adev = container_of(work, struct amdgpu_device, virt.vf2pf_work.work); ++ int ret; + +- amdgpu_virt_read_pf2vf_data(adev); ++ ret = amdgpu_virt_read_pf2vf_data(adev); ++ if (ret) ++ goto out; + amdgpu_virt_write_vf2pf_data(adev); + ++out: + schedule_delayed_work(&(adev->virt.vf2pf_work), adev->virt.vf2pf_update_interval_ms); + } + +diff --git a/drivers/gpu/drm/amd/amdgpu/cz_ih.c b/drivers/gpu/drm/amd/amdgpu/cz_ih.c +index da37f8a900afb..307c01301c87a 100644 +--- a/drivers/gpu/drm/amd/amdgpu/cz_ih.c ++++ b/drivers/gpu/drm/amd/amdgpu/cz_ih.c +@@ -194,19 +194,30 @@ static u32 cz_ih_get_wptr(struct amdgpu_device *adev, + + wptr = le32_to_cpu(*ih->wptr_cpu); + +- if (REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) { +- wptr = REG_SET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW, 0); +- /* When a ring buffer overflow happen start parsing interrupt +- * from the last not overwritten vector (wptr + 16). Hopefully +- * this should allow us to catchup. +- */ +- dev_warn(adev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n", +- wptr, ih->rptr, (wptr + 16) & ih->ptr_mask); +- ih->rptr = (wptr + 16) & ih->ptr_mask; +- tmp = RREG32(mmIH_RB_CNTL); +- tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, WPTR_OVERFLOW_CLEAR, 1); +- WREG32(mmIH_RB_CNTL, tmp); +- } ++ if (!REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) ++ goto out; ++ ++ /* Double check that the overflow wasn't already cleared. */ ++ wptr = RREG32(mmIH_RB_WPTR); ++ ++ if (!REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) ++ goto out; ++ ++ wptr = REG_SET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW, 0); ++ ++ /* When a ring buffer overflow happen start parsing interrupt ++ * from the last not overwritten vector (wptr + 16). Hopefully ++ * this should allow us to catchup. ++ */ ++ dev_warn(adev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n", ++ wptr, ih->rptr, (wptr + 16) & ih->ptr_mask); ++ ih->rptr = (wptr + 16) & ih->ptr_mask; ++ tmp = RREG32(mmIH_RB_CNTL); ++ tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, WPTR_OVERFLOW_CLEAR, 1); ++ WREG32(mmIH_RB_CNTL, tmp); ++ ++ ++out: + return (wptr & ih->ptr_mask); + } + +diff --git a/drivers/gpu/drm/amd/amdgpu/iceland_ih.c b/drivers/gpu/drm/amd/amdgpu/iceland_ih.c +index 37d8b6ca4dab8..cc957471f31ea 100644 +--- a/drivers/gpu/drm/amd/amdgpu/iceland_ih.c ++++ b/drivers/gpu/drm/amd/amdgpu/iceland_ih.c +@@ -194,19 +194,29 @@ static u32 iceland_ih_get_wptr(struct amdgpu_device *adev, + + wptr = le32_to_cpu(*ih->wptr_cpu); + +- if (REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) { +- wptr = REG_SET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW, 0); +- /* When a ring buffer overflow happen start parsing interrupt +- * from the last not overwritten vector (wptr + 16). Hopefully +- * this should allow us to catchup. +- */ +- dev_warn(adev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n", +- wptr, ih->rptr, (wptr + 16) & ih->ptr_mask); +- ih->rptr = (wptr + 16) & ih->ptr_mask; +- tmp = RREG32(mmIH_RB_CNTL); +- tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, WPTR_OVERFLOW_CLEAR, 1); +- WREG32(mmIH_RB_CNTL, tmp); +- } ++ if (!REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) ++ goto out; ++ ++ /* Double check that the overflow wasn't already cleared. */ ++ wptr = RREG32(mmIH_RB_WPTR); ++ ++ if (!REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) ++ goto out; ++ ++ wptr = REG_SET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW, 0); ++ /* When a ring buffer overflow happen start parsing interrupt ++ * from the last not overwritten vector (wptr + 16). Hopefully ++ * this should allow us to catchup. ++ */ ++ dev_warn(adev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n", ++ wptr, ih->rptr, (wptr + 16) & ih->ptr_mask); ++ ih->rptr = (wptr + 16) & ih->ptr_mask; ++ tmp = RREG32(mmIH_RB_CNTL); ++ tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, WPTR_OVERFLOW_CLEAR, 1); ++ WREG32(mmIH_RB_CNTL, tmp); ++ ++ ++out: + return (wptr & ih->ptr_mask); + } + +diff --git a/drivers/gpu/drm/amd/amdgpu/tonga_ih.c b/drivers/gpu/drm/amd/amdgpu/tonga_ih.c +index ce3319993b4bd..249fcbee7871c 100644 +--- a/drivers/gpu/drm/amd/amdgpu/tonga_ih.c ++++ b/drivers/gpu/drm/amd/amdgpu/tonga_ih.c +@@ -196,19 +196,30 @@ static u32 tonga_ih_get_wptr(struct amdgpu_device *adev, + + wptr = le32_to_cpu(*ih->wptr_cpu); + +- if (REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) { +- wptr = REG_SET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW, 0); +- /* When a ring buffer overflow happen start parsing interrupt +- * from the last not overwritten vector (wptr + 16). Hopefully +- * this should allow us to catchup. +- */ +- dev_warn(adev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n", +- wptr, ih->rptr, (wptr + 16) & ih->ptr_mask); +- ih->rptr = (wptr + 16) & ih->ptr_mask; +- tmp = RREG32(mmIH_RB_CNTL); +- tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, WPTR_OVERFLOW_CLEAR, 1); +- WREG32(mmIH_RB_CNTL, tmp); +- } ++ if (!REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) ++ goto out; ++ ++ /* Double check that the overflow wasn't already cleared. */ ++ wptr = RREG32(mmIH_RB_WPTR); ++ ++ if (!REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) ++ goto out; ++ ++ wptr = REG_SET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW, 0); ++ ++ /* When a ring buffer overflow happen start parsing interrupt ++ * from the last not overwritten vector (wptr + 16). Hopefully ++ * this should allow us to catchup. ++ */ ++ ++ dev_warn(adev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n", ++ wptr, ih->rptr, (wptr + 16) & ih->ptr_mask); ++ ih->rptr = (wptr + 16) & ih->ptr_mask; ++ tmp = RREG32(mmIH_RB_CNTL); ++ tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, WPTR_OVERFLOW_CLEAR, 1); ++ WREG32(mmIH_RB_CNTL, tmp); ++ ++out: + return (wptr & ih->ptr_mask); + } + +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_link.c b/drivers/gpu/drm/amd/display/dc/core/dc_link.c +index f4a2088ab1792..278ade3a90ccf 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc_link.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc_link.c +@@ -1470,6 +1470,11 @@ static bool dc_link_construct(struct dc_link *link, + goto ddc_create_fail; + } + ++ if (!link->ddc->ddc_pin) { ++ DC_ERROR("Failed to get I2C info for connector!\n"); ++ goto ddc_create_fail; ++ } ++ + link->ddc_hw_inst = + dal_ddc_get_line(dal_ddc_service_get_ddc_pin(link->ddc)); + +diff --git a/drivers/gpu/drm/hisilicon/hibmc/hibmc_drm_drv.c b/drivers/gpu/drm/hisilicon/hibmc/hibmc_drm_drv.c +index d845657fd99cc..426f5fb20fadc 100644 +--- a/drivers/gpu/drm/hisilicon/hibmc/hibmc_drm_drv.c ++++ b/drivers/gpu/drm/hisilicon/hibmc/hibmc_drm_drv.c +@@ -366,7 +366,6 @@ static void hibmc_pci_remove(struct pci_dev *pdev) + + drm_dev_unregister(dev); + hibmc_unload(dev); +- drm_dev_put(dev); + } + + static const struct pci_device_id hibmc_pci_table[] = { +diff --git a/drivers/infiniband/ulp/rtrs/rtrs-clt.c b/drivers/infiniband/ulp/rtrs/rtrs-clt.c +index 785cd1cf2a402..394c1f6822b90 100644 +--- a/drivers/infiniband/ulp/rtrs/rtrs-clt.c ++++ b/drivers/infiniband/ulp/rtrs/rtrs-clt.c +@@ -496,7 +496,7 @@ static void rtrs_clt_recv_done(struct rtrs_clt_con *con, struct ib_wc *wc) + int err; + struct rtrs_clt_sess *sess = to_clt_sess(con->c.sess); + +- WARN_ON(sess->flags != RTRS_MSG_NEW_RKEY_F); ++ WARN_ON((sess->flags & RTRS_MSG_NEW_RKEY_F) == 0); + iu = container_of(wc->wr_cqe, struct rtrs_iu, + cqe); + err = rtrs_iu_post_recv(&con->c, iu); +@@ -516,7 +516,7 @@ static void rtrs_clt_rkey_rsp_done(struct rtrs_clt_con *con, struct ib_wc *wc) + u32 buf_id; + int err; + +- WARN_ON(sess->flags != RTRS_MSG_NEW_RKEY_F); ++ WARN_ON((sess->flags & RTRS_MSG_NEW_RKEY_F) == 0); + + iu = container_of(wc->wr_cqe, struct rtrs_iu, cqe); + +@@ -623,12 +623,12 @@ static void rtrs_clt_rdma_done(struct ib_cq *cq, struct ib_wc *wc) + } else if (imm_type == RTRS_HB_MSG_IMM) { + WARN_ON(con->c.cid); + rtrs_send_hb_ack(&sess->s); +- if (sess->flags == RTRS_MSG_NEW_RKEY_F) ++ if (sess->flags & RTRS_MSG_NEW_RKEY_F) + return rtrs_clt_recv_done(con, wc); + } else if (imm_type == RTRS_HB_ACK_IMM) { + WARN_ON(con->c.cid); + sess->s.hb_missed_cnt = 0; +- if (sess->flags == RTRS_MSG_NEW_RKEY_F) ++ if (sess->flags & RTRS_MSG_NEW_RKEY_F) + return rtrs_clt_recv_done(con, wc); + } else { + rtrs_wrn(con->c.sess, "Unknown IMM type %u\n", +@@ -656,7 +656,7 @@ static void rtrs_clt_rdma_done(struct ib_cq *cq, struct ib_wc *wc) + WARN_ON(!(wc->wc_flags & IB_WC_WITH_INVALIDATE || + wc->wc_flags & IB_WC_WITH_IMM)); + WARN_ON(wc->wr_cqe->done != rtrs_clt_rdma_done); +- if (sess->flags == RTRS_MSG_NEW_RKEY_F) { ++ if (sess->flags & RTRS_MSG_NEW_RKEY_F) { + if (wc->wc_flags & IB_WC_WITH_INVALIDATE) + return rtrs_clt_recv_done(con, wc); + +@@ -666,7 +666,6 @@ static void rtrs_clt_rdma_done(struct ib_cq *cq, struct ib_wc *wc) + case IB_WC_RDMA_WRITE: + /* + * post_send() RDMA write completions of IO reqs (read/write) +- * and hb + */ + break; + +@@ -682,7 +681,7 @@ static int post_recv_io(struct rtrs_clt_con *con, size_t q_size) + struct rtrs_clt_sess *sess = to_clt_sess(con->c.sess); + + for (i = 0; i < q_size; i++) { +- if (sess->flags == RTRS_MSG_NEW_RKEY_F) { ++ if (sess->flags & RTRS_MSG_NEW_RKEY_F) { + struct rtrs_iu *iu = &con->rsp_ius[i]; + + err = rtrs_iu_post_recv(&con->c, iu); +@@ -1567,7 +1566,7 @@ static int create_con_cq_qp(struct rtrs_clt_con *con) + sess->queue_depth * 3 + 1); + } + /* alloc iu to recv new rkey reply when server reports flags set */ +- if (sess->flags == RTRS_MSG_NEW_RKEY_F || con->c.cid == 0) { ++ if (sess->flags & RTRS_MSG_NEW_RKEY_F || con->c.cid == 0) { + con->rsp_ius = rtrs_iu_alloc(max_recv_wr, sizeof(*rsp), + GFP_KERNEL, sess->s.dev->ib_dev, + DMA_FROM_DEVICE, +diff --git a/drivers/infiniband/ulp/rtrs/rtrs-srv.c b/drivers/infiniband/ulp/rtrs/rtrs-srv.c +index 3850d2a938f8e..d071809e3ed2f 100644 +--- a/drivers/infiniband/ulp/rtrs/rtrs-srv.c ++++ b/drivers/infiniband/ulp/rtrs/rtrs-srv.c +@@ -820,7 +820,7 @@ static int process_info_req(struct rtrs_srv_con *con, + rwr[mri].wr.opcode = IB_WR_REG_MR; + rwr[mri].wr.wr_cqe = &local_reg_cqe; + rwr[mri].wr.num_sge = 0; +- rwr[mri].wr.send_flags = mri ? 0 : IB_SEND_SIGNALED; ++ rwr[mri].wr.send_flags = 0; + rwr[mri].mr = mr; + rwr[mri].key = mr->rkey; + rwr[mri].access = (IB_ACCESS_LOCAL_WRITE | +@@ -1244,7 +1244,6 @@ static void rtrs_srv_rdma_done(struct ib_cq *cq, struct ib_wc *wc) + case IB_WC_SEND: + /* + * post_send() RDMA write completions of IO reqs (read/write) +- * and hb + */ + atomic_add(srv->queue_depth, &con->sq_wr_avail); + +diff --git a/drivers/infiniband/ulp/rtrs/rtrs.c b/drivers/infiniband/ulp/rtrs/rtrs.c +index da4ff764dd3f0..d13aff0aa8165 100644 +--- a/drivers/infiniband/ulp/rtrs/rtrs.c ++++ b/drivers/infiniband/ulp/rtrs/rtrs.c +@@ -310,7 +310,7 @@ void rtrs_send_hb_ack(struct rtrs_sess *sess) + + imm = rtrs_to_imm(RTRS_HB_ACK_IMM, 0); + err = rtrs_post_rdma_write_imm_empty(usr_con, sess->hb_cqe, imm, +- IB_SEND_SIGNALED, NULL); ++ 0, NULL); + if (err) { + sess->hb_err_handler(usr_con); + return; +@@ -339,7 +339,7 @@ static void hb_work(struct work_struct *work) + } + imm = rtrs_to_imm(RTRS_HB_MSG_IMM, 0); + err = rtrs_post_rdma_write_imm_empty(usr_con, sess->hb_cqe, imm, +- IB_SEND_SIGNALED, NULL); ++ 0, NULL); + if (err) { + sess->hb_err_handler(usr_con); + return; +diff --git a/drivers/media/rc/mceusb.c b/drivers/media/rc/mceusb.c +index c8d63673e131d..5642595a057ec 100644 +--- a/drivers/media/rc/mceusb.c ++++ b/drivers/media/rc/mceusb.c +@@ -701,11 +701,18 @@ static void mceusb_dev_printdata(struct mceusb_dev *ir, u8 *buf, int buf_len, + data[0], data[1]); + break; + case MCE_RSP_EQIRCFS: ++ if (!data[0] && !data[1]) { ++ dev_dbg(dev, "%s: no carrier", inout); ++ break; ++ } ++ // prescaler should make sense ++ if (data[0] > 8) ++ break; + period = DIV_ROUND_CLOSEST((1U << data[0] * 2) * + (data[1] + 1), 10); + if (!period) + break; +- carrier = (1000 * 1000) / period; ++ carrier = USEC_PER_SEC / period; + dev_dbg(dev, "%s carrier of %u Hz (period %uus)", + inout, carrier, period); + break; +diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c +index ddb9eaa11be71..5ad5282641350 100644 +--- a/drivers/media/usb/uvc/uvc_driver.c ++++ b/drivers/media/usb/uvc/uvc_driver.c +@@ -1028,7 +1028,10 @@ static struct uvc_entity *uvc_alloc_entity(u16 type, u8 id, + unsigned int i; + + extra_size = roundup(extra_size, sizeof(*entity->pads)); +- num_inputs = (type & UVC_TERM_OUTPUT) ? num_pads : num_pads - 1; ++ if (num_pads) ++ num_inputs = type & UVC_TERM_OUTPUT ? num_pads : num_pads - 1; ++ else ++ num_inputs = 0; + size = sizeof(*entity) + extra_size + sizeof(*entity->pads) * num_pads + + num_inputs; + entity = kzalloc(size, GFP_KERNEL); +@@ -1044,7 +1047,7 @@ static struct uvc_entity *uvc_alloc_entity(u16 type, u8 id, + + for (i = 0; i < num_inputs; ++i) + entity->pads[i].flags = MEDIA_PAD_FL_SINK; +- if (!UVC_ENTITY_IS_OTERM(entity)) ++ if (!UVC_ENTITY_IS_OTERM(entity) && num_pads) + entity->pads[num_pads-1].flags = MEDIA_PAD_FL_SOURCE; + + entity->bNrInPins = num_inputs; +diff --git a/drivers/media/usb/zr364xx/zr364xx.c b/drivers/media/usb/zr364xx/zr364xx.c +index 1e1c6b4d1874b..d29b861367ea7 100644 +--- a/drivers/media/usb/zr364xx/zr364xx.c ++++ b/drivers/media/usb/zr364xx/zr364xx.c +@@ -1181,15 +1181,11 @@ out: + return err; + } + +-static void zr364xx_release(struct v4l2_device *v4l2_dev) ++static void zr364xx_board_uninit(struct zr364xx_camera *cam) + { +- struct zr364xx_camera *cam = +- container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev); + unsigned long i; + +- v4l2_device_unregister(&cam->v4l2_dev); +- +- videobuf_mmap_free(&cam->vb_vidq); ++ zr364xx_stop_readpipe(cam); + + /* release sys buffers */ + for (i = 0; i < FRAMES; i++) { +@@ -1200,9 +1196,19 @@ static void zr364xx_release(struct v4l2_device *v4l2_dev) + cam->buffer.frame[i].lpvbits = NULL; + } + +- v4l2_ctrl_handler_free(&cam->ctrl_handler); + /* release transfer buffer */ + kfree(cam->pipe->transfer_buffer); ++} ++ ++static void zr364xx_release(struct v4l2_device *v4l2_dev) ++{ ++ struct zr364xx_camera *cam = ++ container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev); ++ ++ videobuf_mmap_free(&cam->vb_vidq); ++ v4l2_ctrl_handler_free(&cam->ctrl_handler); ++ zr364xx_board_uninit(cam); ++ v4l2_device_unregister(&cam->v4l2_dev); + kfree(cam); + } + +@@ -1376,11 +1382,14 @@ static int zr364xx_board_init(struct zr364xx_camera *cam) + /* start read pipe */ + err = zr364xx_start_readpipe(cam); + if (err) +- goto err_free; ++ goto err_free_frames; + + DBG(": board initialized\n"); + return 0; + ++err_free_frames: ++ for (i = 0; i < FRAMES; i++) ++ vfree(cam->buffer.frame[i].lpvbits); + err_free: + kfree(cam->pipe->transfer_buffer); + cam->pipe->transfer_buffer = NULL; +@@ -1409,12 +1418,10 @@ static int zr364xx_probe(struct usb_interface *intf, + if (!cam) + return -ENOMEM; + +- cam->v4l2_dev.release = zr364xx_release; + err = v4l2_device_register(&intf->dev, &cam->v4l2_dev); + if (err < 0) { + dev_err(&udev->dev, "couldn't register v4l2_device\n"); +- kfree(cam); +- return err; ++ goto free_cam; + } + hdl = &cam->ctrl_handler; + v4l2_ctrl_handler_init(hdl, 1); +@@ -1423,7 +1430,7 @@ static int zr364xx_probe(struct usb_interface *intf, + if (hdl->error) { + err = hdl->error; + dev_err(&udev->dev, "couldn't register control\n"); +- goto fail; ++ goto unregister; + } + /* save the init method used by this camera */ + cam->method = id->driver_info; +@@ -1496,7 +1503,7 @@ static int zr364xx_probe(struct usb_interface *intf, + if (!cam->read_endpoint) { + err = -ENOMEM; + dev_err(&intf->dev, "Could not find bulk-in endpoint\n"); +- goto fail; ++ goto unregister; + } + + /* v4l */ +@@ -1507,10 +1514,11 @@ static int zr364xx_probe(struct usb_interface *intf, + + /* load zr364xx board specific */ + err = zr364xx_board_init(cam); +- if (!err) +- err = v4l2_ctrl_handler_setup(hdl); + if (err) +- goto fail; ++ goto unregister; ++ err = v4l2_ctrl_handler_setup(hdl); ++ if (err) ++ goto board_uninit; + + spin_lock_init(&cam->slock); + +@@ -1525,16 +1533,21 @@ static int zr364xx_probe(struct usb_interface *intf, + err = video_register_device(&cam->vdev, VFL_TYPE_VIDEO, -1); + if (err) { + dev_err(&udev->dev, "video_register_device failed\n"); +- goto fail; ++ goto free_handler; + } ++ cam->v4l2_dev.release = zr364xx_release; + + dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n", + video_device_node_name(&cam->vdev)); + return 0; + +-fail: ++free_handler: + v4l2_ctrl_handler_free(hdl); ++board_uninit: ++ zr364xx_board_uninit(cam); ++unregister: + v4l2_device_unregister(&cam->v4l2_dev); ++free_cam: + kfree(cam); + return err; + } +diff --git a/drivers/media/v4l2-core/v4l2-ctrls.c b/drivers/media/v4l2-core/v4l2-ctrls.c +index 5cbe0ffbf501f..9dc151431a5c6 100644 +--- a/drivers/media/v4l2-core/v4l2-ctrls.c ++++ b/drivers/media/v4l2-core/v4l2-ctrls.c +@@ -2165,7 +2165,8 @@ static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx, + case V4L2_CTRL_TYPE_INTEGER_MENU: + if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum) + return -ERANGE; +- if (ctrl->menu_skip_mask & (1ULL << ptr.p_s32[idx])) ++ if (ptr.p_s32[idx] < BITS_PER_LONG_LONG && ++ (ctrl->menu_skip_mask & BIT_ULL(ptr.p_s32[idx]))) + return -EINVAL; + if (ctrl->type == V4L2_CTRL_TYPE_MENU && + ctrl->qmenu[ptr.p_s32[idx]][0] == '\0') +diff --git a/drivers/net/can/flexcan.c b/drivers/net/can/flexcan.c +index 038fe1036df23..7ab20a6b0d1db 100644 +--- a/drivers/net/can/flexcan.c ++++ b/drivers/net/can/flexcan.c +@@ -9,6 +9,7 @@ + // + // Based on code originally by Andrey Volkov <avolkov@varma-el.com> + ++#include <dt-bindings/firmware/imx/rsrc.h> + #include <linux/bitfield.h> + #include <linux/can.h> + #include <linux/can/dev.h> +@@ -17,6 +18,7 @@ + #include <linux/can/rx-offload.h> + #include <linux/clk.h> + #include <linux/delay.h> ++#include <linux/firmware/imx/sci.h> + #include <linux/interrupt.h> + #include <linux/io.h> + #include <linux/mfd/syscon.h> +@@ -242,6 +244,8 @@ + #define FLEXCAN_QUIRK_SUPPORT_FD BIT(9) + /* support memory detection and correction */ + #define FLEXCAN_QUIRK_SUPPORT_ECC BIT(10) ++/* Setup stop mode with SCU firmware to support wakeup */ ++#define FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW BIT(11) + + /* Structure of the message buffer */ + struct flexcan_mb { +@@ -347,6 +351,7 @@ struct flexcan_priv { + u8 mb_count; + u8 mb_size; + u8 clk_src; /* clock source of CAN Protocol Engine */ ++ u8 scu_idx; + + u64 rx_mask; + u64 tx_mask; +@@ -358,6 +363,9 @@ struct flexcan_priv { + struct regulator *reg_xceiver; + struct flexcan_stop_mode stm; + ++ /* IPC handle when setup stop mode by System Controller firmware(scfw) */ ++ struct imx_sc_ipc *sc_ipc_handle; ++ + /* Read and Write APIs */ + u32 (*read)(void __iomem *addr); + void (*write)(u32 val, void __iomem *addr); +@@ -387,7 +395,7 @@ static const struct flexcan_devtype_data fsl_imx6q_devtype_data = { + static const struct flexcan_devtype_data fsl_imx8qm_devtype_data = { + .quirks = FLEXCAN_QUIRK_DISABLE_RXFG | FLEXCAN_QUIRK_ENABLE_EACEN_RRS | + FLEXCAN_QUIRK_USE_OFF_TIMESTAMP | FLEXCAN_QUIRK_BROKEN_PERR_STATE | +- FLEXCAN_QUIRK_SUPPORT_FD, ++ FLEXCAN_QUIRK_SUPPORT_FD | FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW, + }; + + static struct flexcan_devtype_data fsl_imx8mp_devtype_data = { +@@ -546,18 +554,42 @@ static void flexcan_enable_wakeup_irq(struct flexcan_priv *priv, bool enable) + priv->write(reg_mcr, ®s->mcr); + } + ++static int flexcan_stop_mode_enable_scfw(struct flexcan_priv *priv, bool enabled) ++{ ++ u8 idx = priv->scu_idx; ++ u32 rsrc_id, val; ++ ++ rsrc_id = IMX_SC_R_CAN(idx); ++ ++ if (enabled) ++ val = 1; ++ else ++ val = 0; ++ ++ /* stop mode request via scu firmware */ ++ return imx_sc_misc_set_control(priv->sc_ipc_handle, rsrc_id, ++ IMX_SC_C_IPG_STOP, val); ++} ++ + static inline int flexcan_enter_stop_mode(struct flexcan_priv *priv) + { + struct flexcan_regs __iomem *regs = priv->regs; + u32 reg_mcr; ++ int ret; + + reg_mcr = priv->read(®s->mcr); + reg_mcr |= FLEXCAN_MCR_SLF_WAK; + priv->write(reg_mcr, ®s->mcr); + + /* enable stop request */ +- regmap_update_bits(priv->stm.gpr, priv->stm.req_gpr, +- 1 << priv->stm.req_bit, 1 << priv->stm.req_bit); ++ if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW) { ++ ret = flexcan_stop_mode_enable_scfw(priv, true); ++ if (ret < 0) ++ return ret; ++ } else { ++ regmap_update_bits(priv->stm.gpr, priv->stm.req_gpr, ++ 1 << priv->stm.req_bit, 1 << priv->stm.req_bit); ++ } + + return flexcan_low_power_enter_ack(priv); + } +@@ -566,10 +598,17 @@ static inline int flexcan_exit_stop_mode(struct flexcan_priv *priv) + { + struct flexcan_regs __iomem *regs = priv->regs; + u32 reg_mcr; ++ int ret; + + /* remove stop request */ +- regmap_update_bits(priv->stm.gpr, priv->stm.req_gpr, +- 1 << priv->stm.req_bit, 0); ++ if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW) { ++ ret = flexcan_stop_mode_enable_scfw(priv, false); ++ if (ret < 0) ++ return ret; ++ } else { ++ regmap_update_bits(priv->stm.gpr, priv->stm.req_gpr, ++ 1 << priv->stm.req_bit, 0); ++ } + + reg_mcr = priv->read(®s->mcr); + reg_mcr &= ~FLEXCAN_MCR_SLF_WAK; +@@ -1867,7 +1906,7 @@ static void unregister_flexcandev(struct net_device *dev) + unregister_candev(dev); + } + +-static int flexcan_setup_stop_mode(struct platform_device *pdev) ++static int flexcan_setup_stop_mode_gpr(struct platform_device *pdev) + { + struct net_device *dev = platform_get_drvdata(pdev); + struct device_node *np = pdev->dev.of_node; +@@ -1912,11 +1951,6 @@ static int flexcan_setup_stop_mode(struct platform_device *pdev) + "gpr %s req_gpr=0x02%x req_bit=%u\n", + gpr_np->full_name, priv->stm.req_gpr, priv->stm.req_bit); + +- device_set_wakeup_capable(&pdev->dev, true); +- +- if (of_property_read_bool(np, "wakeup-source")) +- device_set_wakeup_enable(&pdev->dev, true); +- + return 0; + + out_put_node: +@@ -1924,6 +1958,58 @@ out_put_node: + return ret; + } + ++static int flexcan_setup_stop_mode_scfw(struct platform_device *pdev) ++{ ++ struct net_device *dev = platform_get_drvdata(pdev); ++ struct flexcan_priv *priv; ++ u8 scu_idx; ++ int ret; ++ ++ ret = of_property_read_u8(pdev->dev.of_node, "fsl,scu-index", &scu_idx); ++ if (ret < 0) { ++ dev_dbg(&pdev->dev, "failed to get scu index\n"); ++ return ret; ++ } ++ ++ priv = netdev_priv(dev); ++ priv->scu_idx = scu_idx; ++ ++ /* this function could be defered probe, return -EPROBE_DEFER */ ++ return imx_scu_get_handle(&priv->sc_ipc_handle); ++} ++ ++/* flexcan_setup_stop_mode - Setup stop mode for wakeup ++ * ++ * Return: = 0 setup stop mode successfully or doesn't support this feature ++ * < 0 fail to setup stop mode (could be defered probe) ++ */ ++static int flexcan_setup_stop_mode(struct platform_device *pdev) ++{ ++ struct net_device *dev = platform_get_drvdata(pdev); ++ struct flexcan_priv *priv; ++ int ret; ++ ++ priv = netdev_priv(dev); ++ ++ if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW) ++ ret = flexcan_setup_stop_mode_scfw(pdev); ++ else if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_GPR) ++ ret = flexcan_setup_stop_mode_gpr(pdev); ++ else ++ /* return 0 directly if doesn't support stop mode feature */ ++ return 0; ++ ++ if (ret) ++ return ret; ++ ++ device_set_wakeup_capable(&pdev->dev, true); ++ ++ if (of_property_read_bool(pdev->dev.of_node, "wakeup-source")) ++ device_set_wakeup_enable(&pdev->dev, true); ++ ++ return 0; ++} ++ + static const struct of_device_id flexcan_of_match[] = { + { .compatible = "fsl,imx8qm-flexcan", .data = &fsl_imx8qm_devtype_data, }, + { .compatible = "fsl,imx8mp-flexcan", .data = &fsl_imx8mp_devtype_data, }, +@@ -2054,17 +2140,20 @@ static int flexcan_probe(struct platform_device *pdev) + goto failed_register; + } + ++ err = flexcan_setup_stop_mode(pdev); ++ if (err < 0) { ++ if (err != -EPROBE_DEFER) ++ dev_err(&pdev->dev, "setup stop mode failed\n"); ++ goto failed_setup_stop_mode; ++ } ++ + of_can_transceiver(dev); + devm_can_led_init(dev); + +- if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_GPR) { +- err = flexcan_setup_stop_mode(pdev); +- if (err) +- dev_dbg(&pdev->dev, "failed to setup stop-mode\n"); +- } +- + return 0; + ++ failed_setup_stop_mode: ++ unregister_flexcandev(dev); + failed_register: + pm_runtime_put_noidle(&pdev->dev); + pm_runtime_disable(&pdev->dev); +diff --git a/drivers/net/ethernet/atheros/ag71xx.c b/drivers/net/ethernet/atheros/ag71xx.c +index dd5c8a9038bb7..a60ce90305819 100644 +--- a/drivers/net/ethernet/atheros/ag71xx.c ++++ b/drivers/net/ethernet/atheros/ag71xx.c +@@ -223,8 +223,6 @@ + #define AG71XX_REG_RX_SM 0x01b0 + #define AG71XX_REG_TX_SM 0x01b4 + +-#define ETH_SWITCH_HEADER_LEN 2 +- + #define AG71XX_DEFAULT_MSG_ENABLE \ + (NETIF_MSG_DRV \ + | NETIF_MSG_PROBE \ +@@ -933,7 +931,7 @@ static void ag71xx_hw_setup(struct ag71xx *ag) + + static unsigned int ag71xx_max_frame_len(unsigned int mtu) + { +- return ETH_SWITCH_HEADER_LEN + ETH_HLEN + VLAN_HLEN + mtu + ETH_FCS_LEN; ++ return ETH_HLEN + VLAN_HLEN + mtu + ETH_FCS_LEN; + } + + static void ag71xx_hw_set_macaddr(struct ag71xx *ag, unsigned char *mac) +diff --git a/drivers/net/ipa/ipa_reg.h b/drivers/net/ipa/ipa_reg.h +index e6b0827a244ec..732e691e9aa62 100644 +--- a/drivers/net/ipa/ipa_reg.h ++++ b/drivers/net/ipa/ipa_reg.h +@@ -408,15 +408,18 @@ enum ipa_cs_offload_en { + static inline u32 ipa_header_size_encoded(enum ipa_version version, + u32 header_size) + { ++ u32 size = header_size & field_mask(HDR_LEN_FMASK); + u32 val; + +- val = u32_encode_bits(header_size, HDR_LEN_FMASK); +- if (version < IPA_VERSION_4_5) ++ val = u32_encode_bits(size, HDR_LEN_FMASK); ++ if (version < IPA_VERSION_4_5) { ++ /* ipa_assert(header_size == size); */ + return val; ++ } + + /* IPA v4.5 adds a few more most-significant bits */ +- header_size >>= hweight32(HDR_LEN_FMASK); +- val |= u32_encode_bits(header_size, HDR_LEN_MSB_FMASK); ++ size = header_size >> hweight32(HDR_LEN_FMASK); ++ val |= u32_encode_bits(size, HDR_LEN_MSB_FMASK); + + return val; + } +@@ -425,15 +428,18 @@ static inline u32 ipa_header_size_encoded(enum ipa_version version, + static inline u32 ipa_metadata_offset_encoded(enum ipa_version version, + u32 offset) + { ++ u32 off = offset & field_mask(HDR_OFST_METADATA_FMASK); + u32 val; + +- val = u32_encode_bits(offset, HDR_OFST_METADATA_FMASK); +- if (version < IPA_VERSION_4_5) ++ val = u32_encode_bits(off, HDR_OFST_METADATA_FMASK); ++ if (version < IPA_VERSION_4_5) { ++ /* ipa_assert(offset == off); */ + return val; ++ } + + /* IPA v4.5 adds a few more most-significant bits */ +- offset >>= hweight32(HDR_OFST_METADATA_FMASK); +- val |= u32_encode_bits(offset, HDR_OFST_METADATA_MSB_FMASK); ++ off = offset >> hweight32(HDR_OFST_METADATA_FMASK); ++ val |= u32_encode_bits(off, HDR_OFST_METADATA_MSB_FMASK); + + return val; + } +diff --git a/drivers/net/phy/sfp-bus.c b/drivers/net/phy/sfp-bus.c +index 20b91f5dfc6ed..4cf874fb5c5b4 100644 +--- a/drivers/net/phy/sfp-bus.c ++++ b/drivers/net/phy/sfp-bus.c +@@ -44,6 +44,17 @@ static void sfp_quirk_2500basex(const struct sfp_eeprom_id *id, + phylink_set(modes, 2500baseX_Full); + } + ++static void sfp_quirk_ubnt_uf_instant(const struct sfp_eeprom_id *id, ++ unsigned long *modes) ++{ ++ /* Ubiquiti U-Fiber Instant module claims that support all transceiver ++ * types including 10G Ethernet which is not truth. So clear all claimed ++ * modes and set only one mode which module supports: 1000baseX_Full. ++ */ ++ phylink_zero(modes); ++ phylink_set(modes, 1000baseX_Full); ++} ++ + static const struct sfp_quirk sfp_quirks[] = { + { + // Alcatel Lucent G-010S-P can operate at 2500base-X, but +@@ -63,6 +74,10 @@ static const struct sfp_quirk sfp_quirks[] = { + .vendor = "HUAWEI", + .part = "MA5671A", + .modes = sfp_quirk_2500basex, ++ }, { ++ .vendor = "UBNT", ++ .part = "UF-INSTANT", ++ .modes = sfp_quirk_ubnt_uf_instant, + }, + }; + +diff --git a/drivers/net/phy/sfp.c b/drivers/net/phy/sfp.c +index f2b5e467a8001..7a680b5177f5e 100644 +--- a/drivers/net/phy/sfp.c ++++ b/drivers/net/phy/sfp.c +@@ -273,8 +273,21 @@ static const struct sff_data sff_data = { + + static bool sfp_module_supported(const struct sfp_eeprom_id *id) + { +- return id->base.phys_id == SFF8024_ID_SFP && +- id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP; ++ if (id->base.phys_id == SFF8024_ID_SFP && ++ id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP) ++ return true; ++ ++ /* SFP GPON module Ubiquiti U-Fiber Instant has in its EEPROM stored ++ * phys id SFF instead of SFP. Therefore mark this module explicitly ++ * as supported based on vendor name and pn match. ++ */ ++ if (id->base.phys_id == SFF8024_ID_SFF_8472 && ++ id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP && ++ !memcmp(id->base.vendor_name, "UBNT ", 16) && ++ !memcmp(id->base.vendor_pn, "UF-INSTANT ", 16)) ++ return true; ++ ++ return false; + } + + static const struct sff_data sfp_data = { +diff --git a/drivers/net/tap.c b/drivers/net/tap.c +index 1f4bdd94407a9..f549d3a8e59c0 100644 +--- a/drivers/net/tap.c ++++ b/drivers/net/tap.c +@@ -1093,10 +1093,9 @@ static long tap_ioctl(struct file *file, unsigned int cmd, + return -ENOLINK; + } + ret = 0; +- u = tap->dev->type; ++ dev_get_mac_address(&sa, dev_net(tap->dev), tap->dev->name); + if (copy_to_user(&ifr->ifr_name, tap->dev->name, IFNAMSIZ) || +- copy_to_user(&ifr->ifr_hwaddr.sa_data, tap->dev->dev_addr, ETH_ALEN) || +- put_user(u, &ifr->ifr_hwaddr.sa_family)) ++ copy_to_user(&ifr->ifr_hwaddr, &sa, sizeof(sa))) + ret = -EFAULT; + tap_put_tap_dev(tap); + rtnl_unlock(); +@@ -1111,7 +1110,7 @@ static long tap_ioctl(struct file *file, unsigned int cmd, + rtnl_unlock(); + return -ENOLINK; + } +- ret = dev_set_mac_address(tap->dev, &sa, NULL); ++ ret = dev_set_mac_address_user(tap->dev, &sa, NULL); + tap_put_tap_dev(tap); + rtnl_unlock(); + return ret; +diff --git a/drivers/net/tun.c b/drivers/net/tun.c +index 978ac0981d160..5512418b7be0a 100644 +--- a/drivers/net/tun.c ++++ b/drivers/net/tun.c +@@ -3113,15 +3113,14 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd, + + case SIOCGIFHWADDR: + /* Get hw address */ +- memcpy(ifr.ifr_hwaddr.sa_data, tun->dev->dev_addr, ETH_ALEN); +- ifr.ifr_hwaddr.sa_family = tun->dev->type; ++ dev_get_mac_address(&ifr.ifr_hwaddr, net, tun->dev->name); + if (copy_to_user(argp, &ifr, ifreq_len)) + ret = -EFAULT; + break; + + case SIOCSIFHWADDR: + /* Set hw address */ +- ret = dev_set_mac_address(tun->dev, &ifr.ifr_hwaddr, NULL); ++ ret = dev_set_mac_address_user(tun->dev, &ifr.ifr_hwaddr, NULL); + break; + + case TUNGETSNDBUF: +diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c +index 5a05add9b4e69..7410215e2a2e9 100644 +--- a/drivers/net/usb/qmi_wwan.c ++++ b/drivers/net/usb/qmi_wwan.c +@@ -1235,6 +1235,7 @@ static const struct usb_device_id products[] = { + {QMI_FIXED_INTF(0x19d2, 0x1255, 4)}, + {QMI_FIXED_INTF(0x19d2, 0x1256, 4)}, + {QMI_FIXED_INTF(0x19d2, 0x1270, 5)}, /* ZTE MF667 */ ++ {QMI_FIXED_INTF(0x19d2, 0x1275, 3)}, /* ZTE P685M */ + {QMI_FIXED_INTF(0x19d2, 0x1401, 2)}, + {QMI_FIXED_INTF(0x19d2, 0x1402, 2)}, /* ZTE MF60 */ + {QMI_FIXED_INTF(0x19d2, 0x1424, 2)}, +diff --git a/drivers/net/wireless/ath/ath10k/ahb.c b/drivers/net/wireless/ath/ath10k/ahb.c +index 05a61975c83f4..869524852fbaa 100644 +--- a/drivers/net/wireless/ath/ath10k/ahb.c ++++ b/drivers/net/wireless/ath/ath10k/ahb.c +@@ -626,7 +626,7 @@ static int ath10k_ahb_hif_start(struct ath10k *ar) + { + ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot ahb hif start\n"); + +- napi_enable(&ar->napi); ++ ath10k_core_napi_enable(ar); + ath10k_ce_enable_interrupts(ar); + ath10k_pci_enable_legacy_irq(ar); + +@@ -644,8 +644,7 @@ static void ath10k_ahb_hif_stop(struct ath10k *ar) + ath10k_ahb_irq_disable(ar); + synchronize_irq(ar_ahb->irq); + +- napi_synchronize(&ar->napi); +- napi_disable(&ar->napi); ++ ath10k_core_napi_sync_disable(ar); + + ath10k_pci_flush(ar); + } +diff --git a/drivers/net/wireless/ath/ath10k/core.c b/drivers/net/wireless/ath/ath10k/core.c +index eeb6ff6aa2e1e..a419ec7130f97 100644 +--- a/drivers/net/wireless/ath/ath10k/core.c ++++ b/drivers/net/wireless/ath/ath10k/core.c +@@ -2305,6 +2305,31 @@ void ath10k_core_start_recovery(struct ath10k *ar) + } + EXPORT_SYMBOL(ath10k_core_start_recovery); + ++void ath10k_core_napi_enable(struct ath10k *ar) ++{ ++ lockdep_assert_held(&ar->conf_mutex); ++ ++ if (test_bit(ATH10K_FLAG_NAPI_ENABLED, &ar->dev_flags)) ++ return; ++ ++ napi_enable(&ar->napi); ++ set_bit(ATH10K_FLAG_NAPI_ENABLED, &ar->dev_flags); ++} ++EXPORT_SYMBOL(ath10k_core_napi_enable); ++ ++void ath10k_core_napi_sync_disable(struct ath10k *ar) ++{ ++ lockdep_assert_held(&ar->conf_mutex); ++ ++ if (!test_bit(ATH10K_FLAG_NAPI_ENABLED, &ar->dev_flags)) ++ return; ++ ++ napi_synchronize(&ar->napi); ++ napi_disable(&ar->napi); ++ clear_bit(ATH10K_FLAG_NAPI_ENABLED, &ar->dev_flags); ++} ++EXPORT_SYMBOL(ath10k_core_napi_sync_disable); ++ + static void ath10k_core_restart(struct work_struct *work) + { + struct ath10k *ar = container_of(work, struct ath10k, restart_work); +diff --git a/drivers/net/wireless/ath/ath10k/core.h b/drivers/net/wireless/ath/ath10k/core.h +index 51f7e960e2977..f4be6bfb25392 100644 +--- a/drivers/net/wireless/ath/ath10k/core.h ++++ b/drivers/net/wireless/ath/ath10k/core.h +@@ -868,6 +868,9 @@ enum ath10k_dev_flags { + + /* Indicates that ath10k device is during recovery process and not complete */ + ATH10K_FLAG_RESTARTING, ++ ++ /* protected by conf_mutex */ ++ ATH10K_FLAG_NAPI_ENABLED, + }; + + enum ath10k_cal_mode { +@@ -1308,6 +1311,8 @@ static inline bool ath10k_peer_stats_enabled(struct ath10k *ar) + + extern unsigned long ath10k_coredump_mask; + ++void ath10k_core_napi_sync_disable(struct ath10k *ar); ++void ath10k_core_napi_enable(struct ath10k *ar); + struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev, + enum ath10k_bus bus, + enum ath10k_hw_rev hw_rev, +diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c +index e815aab412d7a..9a56a0a5f85da 100644 +--- a/drivers/net/wireless/ath/ath10k/mac.c ++++ b/drivers/net/wireless/ath/ath10k/mac.c +@@ -3763,23 +3763,16 @@ bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar) + static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb) + { + struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue; +- int ret = 0; +- +- spin_lock_bh(&ar->data_lock); + +- if (skb_queue_len(q) == ATH10K_MAX_NUM_MGMT_PENDING) { ++ if (skb_queue_len_lockless(q) >= ATH10K_MAX_NUM_MGMT_PENDING) { + ath10k_warn(ar, "wmi mgmt tx queue is full\n"); +- ret = -ENOSPC; +- goto unlock; ++ return -ENOSPC; + } + +- __skb_queue_tail(q, skb); ++ skb_queue_tail(q, skb); + ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work); + +-unlock: +- spin_unlock_bh(&ar->data_lock); +- +- return ret; ++ return 0; + } + + static enum ath10k_mac_tx_path +diff --git a/drivers/net/wireless/ath/ath10k/pci.c b/drivers/net/wireless/ath/ath10k/pci.c +index 2328df09875ce..e7fde635e0eef 100644 +--- a/drivers/net/wireless/ath/ath10k/pci.c ++++ b/drivers/net/wireless/ath/ath10k/pci.c +@@ -1958,7 +1958,7 @@ static int ath10k_pci_hif_start(struct ath10k *ar) + + ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif start\n"); + +- napi_enable(&ar->napi); ++ ath10k_core_napi_enable(ar); + + ath10k_pci_irq_enable(ar); + ath10k_pci_rx_post(ar); +@@ -2075,8 +2075,9 @@ static void ath10k_pci_hif_stop(struct ath10k *ar) + + ath10k_pci_irq_disable(ar); + ath10k_pci_irq_sync(ar); +- napi_synchronize(&ar->napi); +- napi_disable(&ar->napi); ++ ++ ath10k_core_napi_sync_disable(ar); ++ + cancel_work_sync(&ar_pci->dump_work); + + /* Most likely the device has HTT Rx ring configured. The only way to +diff --git a/drivers/net/wireless/ath/ath10k/sdio.c b/drivers/net/wireless/ath/ath10k/sdio.c +index c415090d1f37c..b746052737e0b 100644 +--- a/drivers/net/wireless/ath/ath10k/sdio.c ++++ b/drivers/net/wireless/ath/ath10k/sdio.c +@@ -1859,7 +1859,7 @@ static int ath10k_sdio_hif_start(struct ath10k *ar) + struct ath10k_sdio *ar_sdio = ath10k_sdio_priv(ar); + int ret; + +- napi_enable(&ar->napi); ++ ath10k_core_napi_enable(ar); + + /* Sleep 20 ms before HIF interrupts are disabled. + * This will give target plenty of time to process the BMI done +@@ -1992,8 +1992,7 @@ static void ath10k_sdio_hif_stop(struct ath10k *ar) + + spin_unlock_bh(&ar_sdio->wr_async_lock); + +- napi_synchronize(&ar->napi); +- napi_disable(&ar->napi); ++ ath10k_core_napi_sync_disable(ar); + } + + #ifdef CONFIG_PM +diff --git a/drivers/net/wireless/ath/ath10k/snoc.c b/drivers/net/wireless/ath/ath10k/snoc.c +index 1c3307e3b1085..af7ecef6bcde9 100644 +--- a/drivers/net/wireless/ath/ath10k/snoc.c ++++ b/drivers/net/wireless/ath/ath10k/snoc.c +@@ -915,8 +915,7 @@ static void ath10k_snoc_hif_stop(struct ath10k *ar) + if (!test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags)) + ath10k_snoc_irq_disable(ar); + +- napi_synchronize(&ar->napi); +- napi_disable(&ar->napi); ++ ath10k_core_napi_sync_disable(ar); + ath10k_snoc_buffer_cleanup(ar); + ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif stop\n"); + } +@@ -926,7 +925,8 @@ static int ath10k_snoc_hif_start(struct ath10k *ar) + struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); + + bitmap_clear(ar_snoc->pending_ce_irqs, 0, CE_COUNT_MAX); +- napi_enable(&ar->napi); ++ ++ ath10k_core_napi_enable(ar); + ath10k_snoc_irq_enable(ar); + ath10k_snoc_rx_post(ar); + +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/dmi.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/dmi.c +index 4aa2561934d77..6d5188b78f2de 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/dmi.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/dmi.c +@@ -40,6 +40,18 @@ static const struct brcmf_dmi_data pov_tab_p1006w_data = { + BRCM_CC_43340_CHIP_ID, 2, "pov-tab-p1006w-data" + }; + ++static const struct brcmf_dmi_data predia_basic_data = { ++ BRCM_CC_43341_CHIP_ID, 2, "predia-basic" ++}; ++ ++/* Note the Voyo winpad A15 tablet uses the same Ampak AP6330 module, with the ++ * exact same nvram file as the Prowise-PT301 tablet. Since the nvram for the ++ * Prowise-PT301 is already in linux-firmware we just point to that here. ++ */ ++static const struct brcmf_dmi_data voyo_winpad_a15_data = { ++ BRCM_CC_4330_CHIP_ID, 4, "Prowise-PT301" ++}; ++ + static const struct dmi_system_id dmi_platform_data[] = { + { + /* ACEPC T8 Cherry Trail Z8350 mini PC */ +@@ -111,6 +123,26 @@ static const struct dmi_system_id dmi_platform_data[] = { + }, + .driver_data = (void *)&pov_tab_p1006w_data, + }, ++ { ++ /* Predia Basic tablet (+ with keyboard dock) */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Insyde"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "CherryTrail"), ++ /* Mx.WT107.KUBNGEA02 with the version-nr dropped */ ++ DMI_MATCH(DMI_BIOS_VERSION, "Mx.WT107.KUBNGEA"), ++ }, ++ .driver_data = (void *)&predia_basic_data, ++ }, ++ { ++ /* Voyo winpad A15 tablet */ ++ .matches = { ++ DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"), ++ DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"), ++ /* Above strings are too generic, also match on BIOS date */ ++ DMI_MATCH(DMI_BIOS_DATE, "11/20/2014"), ++ }, ++ .driver_data = (void *)&voyo_winpad_a15_data, ++ }, + {} + }; + +diff --git a/drivers/net/wireless/intel/iwlwifi/cfg/22000.c b/drivers/net/wireless/intel/iwlwifi/cfg/22000.c +index 8280092066e77..503d0feb6bbc6 100644 +--- a/drivers/net/wireless/intel/iwlwifi/cfg/22000.c ++++ b/drivers/net/wireless/intel/iwlwifi/cfg/22000.c +@@ -635,6 +635,24 @@ const struct iwl_cfg iwl_cfg_snj_a0_mr_a0 = { + .num_rbds = IWL_NUM_RBDS_AX210_HE, + }; + ++const struct iwl_cfg iwl_cfg_so_a0_hr_a0 = { ++ .fw_name_pre = IWL_SO_A_HR_B_FW_PRE, ++ IWL_DEVICE_AX210, ++ .num_rbds = IWL_NUM_RBDS_AX210_HE, ++}; ++ ++const struct iwl_cfg iwl_cfg_quz_a0_hr_b0 = { ++ .fw_name_pre = IWL_QUZ_A_HR_B_FW_PRE, ++ IWL_DEVICE_22500, ++ /* ++ * This device doesn't support receiving BlockAck with a large bitmap ++ * so we need to restrict the size of transmitted aggregation to the ++ * HT size; mac80211 would otherwise pick the HE max (256) by default. ++ */ ++ .max_tx_agg_size = IEEE80211_MAX_AMPDU_BUF_HT, ++ .num_rbds = IWL_NUM_RBDS_22000_HE, ++}; ++ + MODULE_FIRMWARE(IWL_QU_B_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL_QNJ_B_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); + MODULE_FIRMWARE(IWL_QU_C_HR_B_MODULE_FIRMWARE(IWL_22000_UCODE_API_MAX)); +diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-config.h b/drivers/net/wireless/intel/iwlwifi/iwl-config.h +index 86e1d57df65ed..c72d23d54d909 100644 +--- a/drivers/net/wireless/intel/iwlwifi/iwl-config.h ++++ b/drivers/net/wireless/intel/iwlwifi/iwl-config.h +@@ -418,6 +418,7 @@ struct iwl_cfg { + #define IWL_CFG_MAC_TYPE_QU 0x33 + #define IWL_CFG_MAC_TYPE_QUZ 0x35 + #define IWL_CFG_MAC_TYPE_QNJ 0x36 ++#define IWL_CFG_MAC_TYPE_SO 0x37 + #define IWL_CFG_MAC_TYPE_SNJ 0x42 + #define IWL_CFG_MAC_TYPE_MA 0x44 + +@@ -604,6 +605,8 @@ extern const struct iwl_cfg iwlax201_cfg_snj_hr_b0; + extern const struct iwl_cfg iwl_cfg_ma_a0_gf_a0; + extern const struct iwl_cfg iwl_cfg_ma_a0_mr_a0; + extern const struct iwl_cfg iwl_cfg_snj_a0_mr_a0; ++extern const struct iwl_cfg iwl_cfg_so_a0_hr_a0; ++extern const struct iwl_cfg iwl_cfg_quz_a0_hr_b0; + #endif /* CONFIG_IWLMVM */ + + #endif /* __IWL_CONFIG_H__ */ +diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c +index ed3f5b7aa71e9..c55faa388948e 100644 +--- a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c ++++ b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c +@@ -934,6 +934,11 @@ static const struct iwl_dev_info iwl_dev_info_table[] = { + IWL_CFG_RF_TYPE_HR1, IWL_CFG_ANY, + IWL_CFG_ANY, IWL_CFG_ANY, + iwl_quz_a0_hr1_b0, iwl_ax101_name), ++ _IWL_DEV_INFO(IWL_CFG_ANY, IWL_CFG_ANY, ++ IWL_CFG_MAC_TYPE_QUZ, SILICON_B_STEP, ++ IWL_CFG_RF_TYPE_HR2, IWL_CFG_ANY, ++ IWL_CFG_NO_160, IWL_CFG_ANY, ++ iwl_cfg_quz_a0_hr_b0, iwl_ax203_name), + + /* Ma */ + _IWL_DEV_INFO(IWL_CFG_ANY, IWL_CFG_ANY, +@@ -952,6 +957,27 @@ static const struct iwl_dev_info iwl_dev_info_table[] = { + IWL_CFG_ANY, IWL_CFG_ANY, + iwl_cfg_snj_a0_mr_a0, iwl_ma_name), + ++/* So with Hr */ ++ _IWL_DEV_INFO(IWL_CFG_ANY, IWL_CFG_ANY, ++ IWL_CFG_MAC_TYPE_SO, IWL_CFG_ANY, ++ IWL_CFG_RF_TYPE_HR2, IWL_CFG_ANY, ++ IWL_CFG_NO_160, IWL_CFG_ANY, ++ iwl_cfg_so_a0_hr_a0, iwl_ax203_name), ++ _IWL_DEV_INFO(IWL_CFG_ANY, IWL_CFG_ANY, ++ IWL_CFG_MAC_TYPE_SO, IWL_CFG_ANY, ++ IWL_CFG_RF_TYPE_HR2, IWL_CFG_ANY, ++ IWL_CFG_NO_160, IWL_CFG_ANY, ++ iwl_cfg_so_a0_hr_a0, iwl_ax203_name), ++ _IWL_DEV_INFO(IWL_CFG_ANY, IWL_CFG_ANY, ++ IWL_CFG_MAC_TYPE_SO, IWL_CFG_ANY, ++ IWL_CFG_RF_TYPE_HR1, IWL_CFG_ANY, ++ IWL_CFG_160, IWL_CFG_ANY, ++ iwl_cfg_so_a0_hr_a0, iwl_ax101_name), ++ _IWL_DEV_INFO(IWL_CFG_ANY, IWL_CFG_ANY, ++ IWL_CFG_MAC_TYPE_SO, IWL_CFG_ANY, ++ IWL_CFG_RF_TYPE_HR2, IWL_CFG_ANY, ++ IWL_CFG_160, IWL_CFG_ANY, ++ iwl_cfg_so_a0_hr_a0, iwl_ax201_name) + + #endif /* CONFIG_IWLMVM */ + }; +diff --git a/drivers/net/wireless/mediatek/mt76/mt7615/mac.c b/drivers/net/wireless/mediatek/mt76/mt7615/mac.c +index 0f360be0b8851..fb10a6497ed05 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7615/mac.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7615/mac.c +@@ -2058,6 +2058,23 @@ void mt7615_dma_reset(struct mt7615_dev *dev) + } + EXPORT_SYMBOL_GPL(mt7615_dma_reset); + ++void mt7615_tx_token_put(struct mt7615_dev *dev) ++{ ++ struct mt76_txwi_cache *txwi; ++ int id; ++ ++ spin_lock_bh(&dev->token_lock); ++ idr_for_each_entry(&dev->token, txwi, id) { ++ mt7615_txp_skb_unmap(&dev->mt76, txwi); ++ if (txwi->skb) ++ dev_kfree_skb_any(txwi->skb); ++ mt76_put_txwi(&dev->mt76, txwi); ++ } ++ spin_unlock_bh(&dev->token_lock); ++ idr_destroy(&dev->token); ++} ++EXPORT_SYMBOL_GPL(mt7615_tx_token_put); ++ + void mt7615_mac_reset_work(struct work_struct *work) + { + struct mt7615_phy *phy2; +@@ -2101,6 +2118,9 @@ void mt7615_mac_reset_work(struct work_struct *work) + + mt76_wr(dev, MT_MCU_INT_EVENT, MT_MCU_INT_EVENT_PDMA_STOPPED); + ++ mt7615_tx_token_put(dev); ++ idr_init(&dev->token); ++ + if (mt7615_wait_reset_state(dev, MT_MCU_CMD_RESET_DONE)) { + mt7615_dma_reset(dev); + +diff --git a/drivers/net/wireless/mediatek/mt76/mt7615/mt7615.h b/drivers/net/wireless/mediatek/mt76/mt7615/mt7615.h +index 99b8abdbb08f7..d697ff2ea56e8 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7615/mt7615.h ++++ b/drivers/net/wireless/mediatek/mt76/mt7615/mt7615.h +@@ -583,7 +583,7 @@ int mt7615_tx_prepare_skb(struct mt76_dev *mdev, void *txwi_ptr, + struct mt76_tx_info *tx_info); + + void mt7615_tx_complete_skb(struct mt76_dev *mdev, struct mt76_queue_entry *e); +- ++void mt7615_tx_token_put(struct mt7615_dev *dev); + void mt7615_queue_rx_skb(struct mt76_dev *mdev, enum mt76_rxq_id q, + struct sk_buff *skb); + void mt7615_sta_ps(struct mt76_dev *mdev, struct ieee80211_sta *sta, bool ps); +diff --git a/drivers/net/wireless/mediatek/mt76/mt7615/pci_init.c b/drivers/net/wireless/mediatek/mt76/mt7615/pci_init.c +index 27fcb1374685b..58a0ec1bf8d7b 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7615/pci_init.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7615/pci_init.c +@@ -160,9 +160,7 @@ int mt7615_register_device(struct mt7615_dev *dev) + + void mt7615_unregister_device(struct mt7615_dev *dev) + { +- struct mt76_txwi_cache *txwi; + bool mcu_running; +- int id; + + mcu_running = mt7615_wait_for_mcu_init(dev); + +@@ -172,15 +170,7 @@ void mt7615_unregister_device(struct mt7615_dev *dev) + mt7615_mcu_exit(dev); + mt7615_dma_cleanup(dev); + +- spin_lock_bh(&dev->token_lock); +- idr_for_each_entry(&dev->token, txwi, id) { +- mt7615_txp_skb_unmap(&dev->mt76, txwi); +- if (txwi->skb) +- dev_kfree_skb_any(txwi->skb); +- mt76_put_txwi(&dev->mt76, txwi); +- } +- spin_unlock_bh(&dev->token_lock); +- idr_destroy(&dev->token); ++ mt7615_tx_token_put(dev); + + tasklet_disable(&dev->irq_tasklet); + +diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/init.c b/drivers/net/wireless/mediatek/mt76/mt7915/init.c +index 102a8f14c22d4..2ec18aaa82807 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7915/init.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7915/init.c +@@ -672,28 +672,12 @@ int mt7915_register_device(struct mt7915_dev *dev) + + void mt7915_unregister_device(struct mt7915_dev *dev) + { +- struct mt76_txwi_cache *txwi; +- int id; +- + mt7915_unregister_ext_phy(dev); + mt76_unregister_device(&dev->mt76); + mt7915_mcu_exit(dev); + mt7915_dma_cleanup(dev); + +- spin_lock_bh(&dev->token_lock); +- idr_for_each_entry(&dev->token, txwi, id) { +- mt7915_txp_skb_unmap(&dev->mt76, txwi); +- if (txwi->skb) { +- struct ieee80211_hw *hw; +- +- hw = mt76_tx_status_get_hw(&dev->mt76, txwi->skb); +- ieee80211_free_txskb(hw, txwi->skb); +- } +- mt76_put_txwi(&dev->mt76, txwi); +- dev->token_count--; +- } +- spin_unlock_bh(&dev->token_lock); +- idr_destroy(&dev->token); ++ mt7915_tx_token_put(dev); + + mt76_free_device(&dev->mt76); + } +diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/mac.c b/drivers/net/wireless/mediatek/mt76/mt7915/mac.c +index f504eeb221f95..1b4d65310b887 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7915/mac.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7915/mac.c +@@ -1485,6 +1485,27 @@ mt7915_dma_reset(struct mt7915_phy *phy) + MT_WFDMA1_GLO_CFG_TX_DMA_EN | MT_WFDMA1_GLO_CFG_RX_DMA_EN); + } + ++void mt7915_tx_token_put(struct mt7915_dev *dev) ++{ ++ struct mt76_txwi_cache *txwi; ++ int id; ++ ++ spin_lock_bh(&dev->token_lock); ++ idr_for_each_entry(&dev->token, txwi, id) { ++ mt7915_txp_skb_unmap(&dev->mt76, txwi); ++ if (txwi->skb) { ++ struct ieee80211_hw *hw; ++ ++ hw = mt76_tx_status_get_hw(&dev->mt76, txwi->skb); ++ ieee80211_free_txskb(hw, txwi->skb); ++ } ++ mt76_put_txwi(&dev->mt76, txwi); ++ dev->token_count--; ++ } ++ spin_unlock_bh(&dev->token_lock); ++ idr_destroy(&dev->token); ++} ++ + /* system error recovery */ + void mt7915_mac_reset_work(struct work_struct *work) + { +@@ -1525,6 +1546,9 @@ void mt7915_mac_reset_work(struct work_struct *work) + + mt76_wr(dev, MT_MCU_INT_EVENT, MT_MCU_INT_EVENT_DMA_STOPPED); + ++ mt7915_tx_token_put(dev); ++ idr_init(&dev->token); ++ + if (mt7915_wait_reset_state(dev, MT_MCU_CMD_RESET_DONE)) { + mt7915_dma_reset(&dev->phy); + +diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h b/drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h +index 0339abf360d3f..94bed8a3a050a 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h ++++ b/drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h +@@ -463,6 +463,7 @@ int mt7915_tx_prepare_skb(struct mt76_dev *mdev, void *txwi_ptr, + struct ieee80211_sta *sta, + struct mt76_tx_info *tx_info); + void mt7915_tx_complete_skb(struct mt76_dev *mdev, struct mt76_queue_entry *e); ++void mt7915_tx_token_put(struct mt7915_dev *dev); + int mt7915_init_tx_queues(struct mt7915_phy *phy, int idx, int n_desc); + void mt7915_queue_rx_skb(struct mt76_dev *mdev, enum mt76_rxq_id q, + struct sk_buff *skb); +diff --git a/drivers/net/wireless/microchip/wilc1000/netdev.c b/drivers/net/wireless/microchip/wilc1000/netdev.c +index 2a1fbbdd6a4bd..0c188310919e1 100644 +--- a/drivers/net/wireless/microchip/wilc1000/netdev.c ++++ b/drivers/net/wireless/microchip/wilc1000/netdev.c +@@ -737,7 +737,7 @@ netdev_tx_t wilc_mac_xmit(struct sk_buff *skb, struct net_device *ndev) + + vif->netstats.tx_packets++; + vif->netstats.tx_bytes += tx_data->size; +- queue_count = wilc_wlan_txq_add_net_pkt(ndev, (void *)tx_data, ++ queue_count = wilc_wlan_txq_add_net_pkt(ndev, tx_data, + tx_data->buff, tx_data->size, + wilc_tx_complete); + +diff --git a/drivers/net/wireless/microchip/wilc1000/wlan.c b/drivers/net/wireless/microchip/wilc1000/wlan.c +index c12f27be9f790..31d51385ba934 100644 +--- a/drivers/net/wireless/microchip/wilc1000/wlan.c ++++ b/drivers/net/wireless/microchip/wilc1000/wlan.c +@@ -408,7 +408,8 @@ static inline u8 ac_change(struct wilc *wilc, u8 *ac) + return 1; + } + +-int wilc_wlan_txq_add_net_pkt(struct net_device *dev, void *priv, u8 *buffer, ++int wilc_wlan_txq_add_net_pkt(struct net_device *dev, ++ struct tx_complete_data *tx_data, u8 *buffer, + u32 buffer_size, + void (*tx_complete_fn)(void *, int)) + { +@@ -420,27 +421,27 @@ int wilc_wlan_txq_add_net_pkt(struct net_device *dev, void *priv, u8 *buffer, + wilc = vif->wilc; + + if (wilc->quit) { +- tx_complete_fn(priv, 0); ++ tx_complete_fn(tx_data, 0); + return 0; + } + + tqe = kmalloc(sizeof(*tqe), GFP_ATOMIC); + + if (!tqe) { +- tx_complete_fn(priv, 0); ++ tx_complete_fn(tx_data, 0); + return 0; + } + tqe->type = WILC_NET_PKT; + tqe->buffer = buffer; + tqe->buffer_size = buffer_size; + tqe->tx_complete_func = tx_complete_fn; +- tqe->priv = priv; ++ tqe->priv = tx_data; + tqe->vif = vif; + +- q_num = ac_classify(wilc, priv); ++ q_num = ac_classify(wilc, tx_data->skb); + tqe->q_num = q_num; + if (ac_change(wilc, &q_num)) { +- tx_complete_fn(priv, 0); ++ tx_complete_fn(tx_data, 0); + kfree(tqe); + return 0; + } +@@ -451,7 +452,7 @@ int wilc_wlan_txq_add_net_pkt(struct net_device *dev, void *priv, u8 *buffer, + tcp_process(dev, tqe); + wilc_wlan_txq_add_to_tail(dev, q_num, tqe); + } else { +- tx_complete_fn(priv, 0); ++ tx_complete_fn(tx_data, 0); + kfree(tqe); + } + +diff --git a/drivers/net/wireless/microchip/wilc1000/wlan.h b/drivers/net/wireless/microchip/wilc1000/wlan.h +index 3d2104f198192..d55eb6b3a12a9 100644 +--- a/drivers/net/wireless/microchip/wilc1000/wlan.h ++++ b/drivers/net/wireless/microchip/wilc1000/wlan.h +@@ -399,7 +399,8 @@ int wilc_wlan_firmware_download(struct wilc *wilc, const u8 *buffer, + u32 buffer_size); + int wilc_wlan_start(struct wilc *wilc); + int wilc_wlan_stop(struct wilc *wilc, struct wilc_vif *vif); +-int wilc_wlan_txq_add_net_pkt(struct net_device *dev, void *priv, u8 *buffer, ++int wilc_wlan_txq_add_net_pkt(struct net_device *dev, ++ struct tx_complete_data *tx_data, u8 *buffer, + u32 buffer_size, + void (*tx_complete_fn)(void *, int)); + int wilc_wlan_handle_txq(struct wilc *wl, u32 *txq_count); +diff --git a/drivers/net/wireless/ti/wl12xx/main.c b/drivers/net/wireless/ti/wl12xx/main.c +index 3c9c623bb4283..9d7dbfe7fe0c3 100644 +--- a/drivers/net/wireless/ti/wl12xx/main.c ++++ b/drivers/net/wireless/ti/wl12xx/main.c +@@ -635,7 +635,6 @@ static int wl12xx_identify_chip(struct wl1271 *wl) + wl->quirks |= WLCORE_QUIRK_LEGACY_NVS | + WLCORE_QUIRK_DUAL_PROBE_TMPL | + WLCORE_QUIRK_TKIP_HEADER_SPACE | +- WLCORE_QUIRK_START_STA_FAILS | + WLCORE_QUIRK_AP_ZERO_SESSION_ID; + wl->sr_fw_name = WL127X_FW_NAME_SINGLE; + wl->mr_fw_name = WL127X_FW_NAME_MULTI; +@@ -659,7 +658,6 @@ static int wl12xx_identify_chip(struct wl1271 *wl) + wl->quirks |= WLCORE_QUIRK_LEGACY_NVS | + WLCORE_QUIRK_DUAL_PROBE_TMPL | + WLCORE_QUIRK_TKIP_HEADER_SPACE | +- WLCORE_QUIRK_START_STA_FAILS | + WLCORE_QUIRK_AP_ZERO_SESSION_ID; + wl->plt_fw_name = WL127X_PLT_FW_NAME; + wl->sr_fw_name = WL127X_FW_NAME_SINGLE; +@@ -688,7 +686,6 @@ static int wl12xx_identify_chip(struct wl1271 *wl) + wl->quirks |= WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN | + WLCORE_QUIRK_DUAL_PROBE_TMPL | + WLCORE_QUIRK_TKIP_HEADER_SPACE | +- WLCORE_QUIRK_START_STA_FAILS | + WLCORE_QUIRK_AP_ZERO_SESSION_ID; + + wlcore_set_min_fw_ver(wl, WL128X_CHIP_VER, +diff --git a/drivers/net/wireless/ti/wlcore/main.c b/drivers/net/wireless/ti/wlcore/main.c +index 122c7a4b374f1..0f9cc3de6aebc 100644 +--- a/drivers/net/wireless/ti/wlcore/main.c ++++ b/drivers/net/wireless/ti/wlcore/main.c +@@ -2872,21 +2872,8 @@ static int wlcore_join(struct wl1271 *wl, struct wl12xx_vif *wlvif) + + if (is_ibss) + ret = wl12xx_cmd_role_start_ibss(wl, wlvif); +- else { +- if (wl->quirks & WLCORE_QUIRK_START_STA_FAILS) { +- /* +- * TODO: this is an ugly workaround for wl12xx fw +- * bug - we are not able to tx/rx after the first +- * start_sta, so make dummy start+stop calls, +- * and then call start_sta again. +- * this should be fixed in the fw. +- */ +- wl12xx_cmd_role_start_sta(wl, wlvif); +- wl12xx_cmd_role_stop_sta(wl, wlvif); +- } +- ++ else + ret = wl12xx_cmd_role_start_sta(wl, wlvif); +- } + + return ret; + } +diff --git a/drivers/net/wireless/ti/wlcore/wlcore.h b/drivers/net/wireless/ti/wlcore/wlcore.h +index b7821311ac75b..81c94d390623b 100644 +--- a/drivers/net/wireless/ti/wlcore/wlcore.h ++++ b/drivers/net/wireless/ti/wlcore/wlcore.h +@@ -547,9 +547,6 @@ wlcore_set_min_fw_ver(struct wl1271 *wl, unsigned int chip, + /* Each RX/TX transaction requires an end-of-transaction transfer */ + #define WLCORE_QUIRK_END_OF_TRANSACTION BIT(0) + +-/* the first start_role(sta) sometimes doesn't work on wl12xx */ +-#define WLCORE_QUIRK_START_STA_FAILS BIT(1) +- + /* wl127x and SPI don't support SDIO block size alignment */ + #define WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN BIT(2) + +diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c +index 423667b837510..986b569709616 100644 +--- a/drivers/net/xen-netback/netback.c ++++ b/drivers/net/xen-netback/netback.c +@@ -1342,11 +1342,21 @@ int xenvif_tx_action(struct xenvif_queue *queue, int budget) + return 0; + + gnttab_batch_copy(queue->tx_copy_ops, nr_cops); +- if (nr_mops != 0) ++ if (nr_mops != 0) { + ret = gnttab_map_refs(queue->tx_map_ops, + NULL, + queue->pages_to_map, + nr_mops); ++ if (ret) { ++ unsigned int i; ++ ++ netdev_err(queue->vif->dev, "Map fail: nr %u ret %d\n", ++ nr_mops, ret); ++ for (i = 0; i < nr_mops; ++i) ++ WARN_ON_ONCE(queue->tx_map_ops[i].status == ++ GNTST_okay); ++ } ++ } + + work_done = xenvif_tx_submit(queue); + +diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c +index f13eb4ded95fa..129e2b6bd6d3f 100644 +--- a/drivers/nvme/host/core.c ++++ b/drivers/nvme/host/core.c +@@ -371,6 +371,26 @@ bool nvme_cancel_request(struct request *req, void *data, bool reserved) + } + EXPORT_SYMBOL_GPL(nvme_cancel_request); + ++void nvme_cancel_tagset(struct nvme_ctrl *ctrl) ++{ ++ if (ctrl->tagset) { ++ blk_mq_tagset_busy_iter(ctrl->tagset, ++ nvme_cancel_request, ctrl); ++ blk_mq_tagset_wait_completed_request(ctrl->tagset); ++ } ++} ++EXPORT_SYMBOL_GPL(nvme_cancel_tagset); ++ ++void nvme_cancel_admin_tagset(struct nvme_ctrl *ctrl) ++{ ++ if (ctrl->admin_tagset) { ++ blk_mq_tagset_busy_iter(ctrl->admin_tagset, ++ nvme_cancel_request, ctrl); ++ blk_mq_tagset_wait_completed_request(ctrl->admin_tagset); ++ } ++} ++EXPORT_SYMBOL_GPL(nvme_cancel_admin_tagset); ++ + bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl, + enum nvme_ctrl_state new_state) + { +diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h +index 88a6b97247f50..a72f071810910 100644 +--- a/drivers/nvme/host/nvme.h ++++ b/drivers/nvme/host/nvme.h +@@ -576,6 +576,8 @@ static inline bool nvme_is_aen_req(u16 qid, __u16 command_id) + + void nvme_complete_rq(struct request *req); + bool nvme_cancel_request(struct request *req, void *data, bool reserved); ++void nvme_cancel_tagset(struct nvme_ctrl *ctrl); ++void nvme_cancel_admin_tagset(struct nvme_ctrl *ctrl); + bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl, + enum nvme_ctrl_state new_state); + bool nvme_wait_reset(struct nvme_ctrl *ctrl); +diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c +index b7ce4f221d990..746392eade455 100644 +--- a/drivers/nvme/host/rdma.c ++++ b/drivers/nvme/host/rdma.c +@@ -919,12 +919,16 @@ static int nvme_rdma_configure_admin_queue(struct nvme_rdma_ctrl *ctrl, + + error = nvme_init_identify(&ctrl->ctrl); + if (error) +- goto out_stop_queue; ++ goto out_quiesce_queue; + + return 0; + ++out_quiesce_queue: ++ blk_mq_quiesce_queue(ctrl->ctrl.admin_q); ++ blk_sync_queue(ctrl->ctrl.admin_q); + out_stop_queue: + nvme_rdma_stop_queue(&ctrl->queues[0]); ++ nvme_cancel_admin_tagset(&ctrl->ctrl); + out_cleanup_queue: + if (new) + blk_cleanup_queue(ctrl->ctrl.admin_q); +@@ -1001,8 +1005,10 @@ static int nvme_rdma_configure_io_queues(struct nvme_rdma_ctrl *ctrl, bool new) + + out_wait_freeze_timed_out: + nvme_stop_queues(&ctrl->ctrl); ++ nvme_sync_io_queues(&ctrl->ctrl); + nvme_rdma_stop_io_queues(ctrl); + out_cleanup_connect_q: ++ nvme_cancel_tagset(&ctrl->ctrl); + if (new) + blk_cleanup_queue(ctrl->ctrl.connect_q); + out_free_tag_set: +@@ -1144,10 +1150,18 @@ static int nvme_rdma_setup_ctrl(struct nvme_rdma_ctrl *ctrl, bool new) + return 0; + + destroy_io: +- if (ctrl->ctrl.queue_count > 1) ++ if (ctrl->ctrl.queue_count > 1) { ++ nvme_stop_queues(&ctrl->ctrl); ++ nvme_sync_io_queues(&ctrl->ctrl); ++ nvme_rdma_stop_io_queues(ctrl); ++ nvme_cancel_tagset(&ctrl->ctrl); + nvme_rdma_destroy_io_queues(ctrl, new); ++ } + destroy_admin: ++ blk_mq_quiesce_queue(ctrl->ctrl.admin_q); ++ blk_sync_queue(ctrl->ctrl.admin_q); + nvme_rdma_stop_queue(&ctrl->queues[0]); ++ nvme_cancel_admin_tagset(&ctrl->ctrl); + nvme_rdma_destroy_admin_queue(ctrl, new); + return ret; + } +diff --git a/drivers/nvme/host/tcp.c b/drivers/nvme/host/tcp.c +index 881d28eb15e9d..30d24a5a5b826 100644 +--- a/drivers/nvme/host/tcp.c ++++ b/drivers/nvme/host/tcp.c +@@ -1815,8 +1815,10 @@ static int nvme_tcp_configure_io_queues(struct nvme_ctrl *ctrl, bool new) + + out_wait_freeze_timed_out: + nvme_stop_queues(ctrl); ++ nvme_sync_io_queues(ctrl); + nvme_tcp_stop_io_queues(ctrl); + out_cleanup_connect_q: ++ nvme_cancel_tagset(ctrl); + if (new) + blk_cleanup_queue(ctrl->connect_q); + out_free_tag_set: +@@ -1878,12 +1880,16 @@ static int nvme_tcp_configure_admin_queue(struct nvme_ctrl *ctrl, bool new) + + error = nvme_init_identify(ctrl); + if (error) +- goto out_stop_queue; ++ goto out_quiesce_queue; + + return 0; + ++out_quiesce_queue: ++ blk_mq_quiesce_queue(ctrl->admin_q); ++ blk_sync_queue(ctrl->admin_q); + out_stop_queue: + nvme_tcp_stop_queue(ctrl, 0); ++ nvme_cancel_admin_tagset(ctrl); + out_cleanup_queue: + if (new) + blk_cleanup_queue(ctrl->admin_q); +@@ -2003,10 +2009,18 @@ static int nvme_tcp_setup_ctrl(struct nvme_ctrl *ctrl, bool new) + return 0; + + destroy_io: +- if (ctrl->queue_count > 1) ++ if (ctrl->queue_count > 1) { ++ nvme_stop_queues(ctrl); ++ nvme_sync_io_queues(ctrl); ++ nvme_tcp_stop_io_queues(ctrl); ++ nvme_cancel_tagset(ctrl); + nvme_tcp_destroy_io_queues(ctrl, new); ++ } + destroy_admin: ++ blk_mq_quiesce_queue(ctrl->admin_q); ++ blk_sync_queue(ctrl->admin_q); + nvme_tcp_stop_queue(ctrl, 0); ++ nvme_cancel_admin_tagset(ctrl); + nvme_tcp_destroy_admin_queue(ctrl, new); + return ret; + } +diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c +index 790393d1e3189..ba791165ed194 100644 +--- a/drivers/pci/pci.c ++++ b/drivers/pci/pci.c +@@ -3596,7 +3596,14 @@ u32 pci_rebar_get_possible_sizes(struct pci_dev *pdev, int bar) + return 0; + + pci_read_config_dword(pdev, pos + PCI_REBAR_CAP, &cap); +- return (cap & PCI_REBAR_CAP_SIZES) >> 4; ++ cap &= PCI_REBAR_CAP_SIZES; ++ ++ /* Sapphire RX 5600 XT Pulse has an invalid cap dword for BAR 0 */ ++ if (pdev->vendor == PCI_VENDOR_ID_ATI && pdev->device == 0x731f && ++ bar == 0 && cap == 0x7000) ++ cap = 0x3f000; ++ ++ return cap >> 4; + } + + /** +diff --git a/drivers/phy/mediatek/phy-mtk-hdmi.c b/drivers/phy/mediatek/phy-mtk-hdmi.c +index 45be8aa724f3a..8313bd517e4cf 100644 +--- a/drivers/phy/mediatek/phy-mtk-hdmi.c ++++ b/drivers/phy/mediatek/phy-mtk-hdmi.c +@@ -201,6 +201,7 @@ static const struct of_device_id mtk_hdmi_phy_match[] = { + }, + {}, + }; ++MODULE_DEVICE_TABLE(of, mtk_hdmi_phy_match); + + static struct platform_driver mtk_hdmi_phy_driver = { + .probe = mtk_hdmi_phy_probe, +diff --git a/drivers/phy/mediatek/phy-mtk-mipi-dsi.c b/drivers/phy/mediatek/phy-mtk-mipi-dsi.c +index 18c481251f04a..9c7815bb90005 100644 +--- a/drivers/phy/mediatek/phy-mtk-mipi-dsi.c ++++ b/drivers/phy/mediatek/phy-mtk-mipi-dsi.c +@@ -233,6 +233,7 @@ static const struct of_device_id mtk_mipi_tx_match[] = { + .data = &mt8183_mipitx_data }, + { }, + }; ++MODULE_DEVICE_TABLE(of, mtk_mipi_tx_match); + + struct platform_driver mtk_mipi_tx_driver = { + .probe = mtk_mipi_tx_probe, +diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c +index 4e668aafbcca0..1851015299b3a 100644 +--- a/drivers/scsi/libiscsi.c ++++ b/drivers/scsi/libiscsi.c +@@ -3338,125 +3338,125 @@ int iscsi_session_get_param(struct iscsi_cls_session *cls_session, + + switch(param) { + case ISCSI_PARAM_FAST_ABORT: +- len = sprintf(buf, "%d\n", session->fast_abort); ++ len = sysfs_emit(buf, "%d\n", session->fast_abort); + break; + case ISCSI_PARAM_ABORT_TMO: +- len = sprintf(buf, "%d\n", session->abort_timeout); ++ len = sysfs_emit(buf, "%d\n", session->abort_timeout); + break; + case ISCSI_PARAM_LU_RESET_TMO: +- len = sprintf(buf, "%d\n", session->lu_reset_timeout); ++ len = sysfs_emit(buf, "%d\n", session->lu_reset_timeout); + break; + case ISCSI_PARAM_TGT_RESET_TMO: +- len = sprintf(buf, "%d\n", session->tgt_reset_timeout); ++ len = sysfs_emit(buf, "%d\n", session->tgt_reset_timeout); + break; + case ISCSI_PARAM_INITIAL_R2T_EN: +- len = sprintf(buf, "%d\n", session->initial_r2t_en); ++ len = sysfs_emit(buf, "%d\n", session->initial_r2t_en); + break; + case ISCSI_PARAM_MAX_R2T: +- len = sprintf(buf, "%hu\n", session->max_r2t); ++ len = sysfs_emit(buf, "%hu\n", session->max_r2t); + break; + case ISCSI_PARAM_IMM_DATA_EN: +- len = sprintf(buf, "%d\n", session->imm_data_en); ++ len = sysfs_emit(buf, "%d\n", session->imm_data_en); + break; + case ISCSI_PARAM_FIRST_BURST: +- len = sprintf(buf, "%u\n", session->first_burst); ++ len = sysfs_emit(buf, "%u\n", session->first_burst); + break; + case ISCSI_PARAM_MAX_BURST: +- len = sprintf(buf, "%u\n", session->max_burst); ++ len = sysfs_emit(buf, "%u\n", session->max_burst); + break; + case ISCSI_PARAM_PDU_INORDER_EN: +- len = sprintf(buf, "%d\n", session->pdu_inorder_en); ++ len = sysfs_emit(buf, "%d\n", session->pdu_inorder_en); + break; + case ISCSI_PARAM_DATASEQ_INORDER_EN: +- len = sprintf(buf, "%d\n", session->dataseq_inorder_en); ++ len = sysfs_emit(buf, "%d\n", session->dataseq_inorder_en); + break; + case ISCSI_PARAM_DEF_TASKMGMT_TMO: +- len = sprintf(buf, "%d\n", session->def_taskmgmt_tmo); ++ len = sysfs_emit(buf, "%d\n", session->def_taskmgmt_tmo); + break; + case ISCSI_PARAM_ERL: +- len = sprintf(buf, "%d\n", session->erl); ++ len = sysfs_emit(buf, "%d\n", session->erl); + break; + case ISCSI_PARAM_TARGET_NAME: +- len = sprintf(buf, "%s\n", session->targetname); ++ len = sysfs_emit(buf, "%s\n", session->targetname); + break; + case ISCSI_PARAM_TARGET_ALIAS: +- len = sprintf(buf, "%s\n", session->targetalias); ++ len = sysfs_emit(buf, "%s\n", session->targetalias); + break; + case ISCSI_PARAM_TPGT: +- len = sprintf(buf, "%d\n", session->tpgt); ++ len = sysfs_emit(buf, "%d\n", session->tpgt); + break; + case ISCSI_PARAM_USERNAME: +- len = sprintf(buf, "%s\n", session->username); ++ len = sysfs_emit(buf, "%s\n", session->username); + break; + case ISCSI_PARAM_USERNAME_IN: +- len = sprintf(buf, "%s\n", session->username_in); ++ len = sysfs_emit(buf, "%s\n", session->username_in); + break; + case ISCSI_PARAM_PASSWORD: +- len = sprintf(buf, "%s\n", session->password); ++ len = sysfs_emit(buf, "%s\n", session->password); + break; + case ISCSI_PARAM_PASSWORD_IN: +- len = sprintf(buf, "%s\n", session->password_in); ++ len = sysfs_emit(buf, "%s\n", session->password_in); + break; + case ISCSI_PARAM_IFACE_NAME: +- len = sprintf(buf, "%s\n", session->ifacename); ++ len = sysfs_emit(buf, "%s\n", session->ifacename); + break; + case ISCSI_PARAM_INITIATOR_NAME: +- len = sprintf(buf, "%s\n", session->initiatorname); ++ len = sysfs_emit(buf, "%s\n", session->initiatorname); + break; + case ISCSI_PARAM_BOOT_ROOT: +- len = sprintf(buf, "%s\n", session->boot_root); ++ len = sysfs_emit(buf, "%s\n", session->boot_root); + break; + case ISCSI_PARAM_BOOT_NIC: +- len = sprintf(buf, "%s\n", session->boot_nic); ++ len = sysfs_emit(buf, "%s\n", session->boot_nic); + break; + case ISCSI_PARAM_BOOT_TARGET: +- len = sprintf(buf, "%s\n", session->boot_target); ++ len = sysfs_emit(buf, "%s\n", session->boot_target); + break; + case ISCSI_PARAM_AUTO_SND_TGT_DISABLE: +- len = sprintf(buf, "%u\n", session->auto_snd_tgt_disable); ++ len = sysfs_emit(buf, "%u\n", session->auto_snd_tgt_disable); + break; + case ISCSI_PARAM_DISCOVERY_SESS: +- len = sprintf(buf, "%u\n", session->discovery_sess); ++ len = sysfs_emit(buf, "%u\n", session->discovery_sess); + break; + case ISCSI_PARAM_PORTAL_TYPE: +- len = sprintf(buf, "%s\n", session->portal_type); ++ len = sysfs_emit(buf, "%s\n", session->portal_type); + break; + case ISCSI_PARAM_CHAP_AUTH_EN: +- len = sprintf(buf, "%u\n", session->chap_auth_en); ++ len = sysfs_emit(buf, "%u\n", session->chap_auth_en); + break; + case ISCSI_PARAM_DISCOVERY_LOGOUT_EN: +- len = sprintf(buf, "%u\n", session->discovery_logout_en); ++ len = sysfs_emit(buf, "%u\n", session->discovery_logout_en); + break; + case ISCSI_PARAM_BIDI_CHAP_EN: +- len = sprintf(buf, "%u\n", session->bidi_chap_en); ++ len = sysfs_emit(buf, "%u\n", session->bidi_chap_en); + break; + case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL: +- len = sprintf(buf, "%u\n", session->discovery_auth_optional); ++ len = sysfs_emit(buf, "%u\n", session->discovery_auth_optional); + break; + case ISCSI_PARAM_DEF_TIME2WAIT: +- len = sprintf(buf, "%d\n", session->time2wait); ++ len = sysfs_emit(buf, "%d\n", session->time2wait); + break; + case ISCSI_PARAM_DEF_TIME2RETAIN: +- len = sprintf(buf, "%d\n", session->time2retain); ++ len = sysfs_emit(buf, "%d\n", session->time2retain); + break; + case ISCSI_PARAM_TSID: +- len = sprintf(buf, "%u\n", session->tsid); ++ len = sysfs_emit(buf, "%u\n", session->tsid); + break; + case ISCSI_PARAM_ISID: +- len = sprintf(buf, "%02x%02x%02x%02x%02x%02x\n", ++ len = sysfs_emit(buf, "%02x%02x%02x%02x%02x%02x\n", + session->isid[0], session->isid[1], + session->isid[2], session->isid[3], + session->isid[4], session->isid[5]); + break; + case ISCSI_PARAM_DISCOVERY_PARENT_IDX: +- len = sprintf(buf, "%u\n", session->discovery_parent_idx); ++ len = sysfs_emit(buf, "%u\n", session->discovery_parent_idx); + break; + case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: + if (session->discovery_parent_type) +- len = sprintf(buf, "%s\n", ++ len = sysfs_emit(buf, "%s\n", + session->discovery_parent_type); + else +- len = sprintf(buf, "\n"); ++ len = sysfs_emit(buf, "\n"); + break; + default: + return -ENOSYS; +@@ -3488,16 +3488,16 @@ int iscsi_conn_get_addr_param(struct sockaddr_storage *addr, + case ISCSI_PARAM_CONN_ADDRESS: + case ISCSI_HOST_PARAM_IPADDRESS: + if (sin) +- len = sprintf(buf, "%pI4\n", &sin->sin_addr.s_addr); ++ len = sysfs_emit(buf, "%pI4\n", &sin->sin_addr.s_addr); + else +- len = sprintf(buf, "%pI6\n", &sin6->sin6_addr); ++ len = sysfs_emit(buf, "%pI6\n", &sin6->sin6_addr); + break; + case ISCSI_PARAM_CONN_PORT: + case ISCSI_PARAM_LOCAL_PORT: + if (sin) +- len = sprintf(buf, "%hu\n", be16_to_cpu(sin->sin_port)); ++ len = sysfs_emit(buf, "%hu\n", be16_to_cpu(sin->sin_port)); + else +- len = sprintf(buf, "%hu\n", ++ len = sysfs_emit(buf, "%hu\n", + be16_to_cpu(sin6->sin6_port)); + break; + default: +@@ -3516,88 +3516,88 @@ int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, + + switch(param) { + case ISCSI_PARAM_PING_TMO: +- len = sprintf(buf, "%u\n", conn->ping_timeout); ++ len = sysfs_emit(buf, "%u\n", conn->ping_timeout); + break; + case ISCSI_PARAM_RECV_TMO: +- len = sprintf(buf, "%u\n", conn->recv_timeout); ++ len = sysfs_emit(buf, "%u\n", conn->recv_timeout); + break; + case ISCSI_PARAM_MAX_RECV_DLENGTH: +- len = sprintf(buf, "%u\n", conn->max_recv_dlength); ++ len = sysfs_emit(buf, "%u\n", conn->max_recv_dlength); + break; + case ISCSI_PARAM_MAX_XMIT_DLENGTH: +- len = sprintf(buf, "%u\n", conn->max_xmit_dlength); ++ len = sysfs_emit(buf, "%u\n", conn->max_xmit_dlength); + break; + case ISCSI_PARAM_HDRDGST_EN: +- len = sprintf(buf, "%d\n", conn->hdrdgst_en); ++ len = sysfs_emit(buf, "%d\n", conn->hdrdgst_en); + break; + case ISCSI_PARAM_DATADGST_EN: +- len = sprintf(buf, "%d\n", conn->datadgst_en); ++ len = sysfs_emit(buf, "%d\n", conn->datadgst_en); + break; + case ISCSI_PARAM_IFMARKER_EN: +- len = sprintf(buf, "%d\n", conn->ifmarker_en); ++ len = sysfs_emit(buf, "%d\n", conn->ifmarker_en); + break; + case ISCSI_PARAM_OFMARKER_EN: +- len = sprintf(buf, "%d\n", conn->ofmarker_en); ++ len = sysfs_emit(buf, "%d\n", conn->ofmarker_en); + break; + case ISCSI_PARAM_EXP_STATSN: +- len = sprintf(buf, "%u\n", conn->exp_statsn); ++ len = sysfs_emit(buf, "%u\n", conn->exp_statsn); + break; + case ISCSI_PARAM_PERSISTENT_PORT: +- len = sprintf(buf, "%d\n", conn->persistent_port); ++ len = sysfs_emit(buf, "%d\n", conn->persistent_port); + break; + case ISCSI_PARAM_PERSISTENT_ADDRESS: +- len = sprintf(buf, "%s\n", conn->persistent_address); ++ len = sysfs_emit(buf, "%s\n", conn->persistent_address); + break; + case ISCSI_PARAM_STATSN: +- len = sprintf(buf, "%u\n", conn->statsn); ++ len = sysfs_emit(buf, "%u\n", conn->statsn); + break; + case ISCSI_PARAM_MAX_SEGMENT_SIZE: +- len = sprintf(buf, "%u\n", conn->max_segment_size); ++ len = sysfs_emit(buf, "%u\n", conn->max_segment_size); + break; + case ISCSI_PARAM_KEEPALIVE_TMO: +- len = sprintf(buf, "%u\n", conn->keepalive_tmo); ++ len = sysfs_emit(buf, "%u\n", conn->keepalive_tmo); + break; + case ISCSI_PARAM_LOCAL_PORT: +- len = sprintf(buf, "%u\n", conn->local_port); ++ len = sysfs_emit(buf, "%u\n", conn->local_port); + break; + case ISCSI_PARAM_TCP_TIMESTAMP_STAT: +- len = sprintf(buf, "%u\n", conn->tcp_timestamp_stat); ++ len = sysfs_emit(buf, "%u\n", conn->tcp_timestamp_stat); + break; + case ISCSI_PARAM_TCP_NAGLE_DISABLE: +- len = sprintf(buf, "%u\n", conn->tcp_nagle_disable); ++ len = sysfs_emit(buf, "%u\n", conn->tcp_nagle_disable); + break; + case ISCSI_PARAM_TCP_WSF_DISABLE: +- len = sprintf(buf, "%u\n", conn->tcp_wsf_disable); ++ len = sysfs_emit(buf, "%u\n", conn->tcp_wsf_disable); + break; + case ISCSI_PARAM_TCP_TIMER_SCALE: +- len = sprintf(buf, "%u\n", conn->tcp_timer_scale); ++ len = sysfs_emit(buf, "%u\n", conn->tcp_timer_scale); + break; + case ISCSI_PARAM_TCP_TIMESTAMP_EN: +- len = sprintf(buf, "%u\n", conn->tcp_timestamp_en); ++ len = sysfs_emit(buf, "%u\n", conn->tcp_timestamp_en); + break; + case ISCSI_PARAM_IP_FRAGMENT_DISABLE: +- len = sprintf(buf, "%u\n", conn->fragment_disable); ++ len = sysfs_emit(buf, "%u\n", conn->fragment_disable); + break; + case ISCSI_PARAM_IPV4_TOS: +- len = sprintf(buf, "%u\n", conn->ipv4_tos); ++ len = sysfs_emit(buf, "%u\n", conn->ipv4_tos); + break; + case ISCSI_PARAM_IPV6_TC: +- len = sprintf(buf, "%u\n", conn->ipv6_traffic_class); ++ len = sysfs_emit(buf, "%u\n", conn->ipv6_traffic_class); + break; + case ISCSI_PARAM_IPV6_FLOW_LABEL: +- len = sprintf(buf, "%u\n", conn->ipv6_flow_label); ++ len = sysfs_emit(buf, "%u\n", conn->ipv6_flow_label); + break; + case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6: +- len = sprintf(buf, "%u\n", conn->is_fw_assigned_ipv6); ++ len = sysfs_emit(buf, "%u\n", conn->is_fw_assigned_ipv6); + break; + case ISCSI_PARAM_TCP_XMIT_WSF: +- len = sprintf(buf, "%u\n", conn->tcp_xmit_wsf); ++ len = sysfs_emit(buf, "%u\n", conn->tcp_xmit_wsf); + break; + case ISCSI_PARAM_TCP_RECV_WSF: +- len = sprintf(buf, "%u\n", conn->tcp_recv_wsf); ++ len = sysfs_emit(buf, "%u\n", conn->tcp_recv_wsf); + break; + case ISCSI_PARAM_LOCAL_IPADDR: +- len = sprintf(buf, "%s\n", conn->local_ipaddr); ++ len = sysfs_emit(buf, "%s\n", conn->local_ipaddr); + break; + default: + return -ENOSYS; +@@ -3615,13 +3615,13 @@ int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, + + switch (param) { + case ISCSI_HOST_PARAM_NETDEV_NAME: +- len = sprintf(buf, "%s\n", ihost->netdev); ++ len = sysfs_emit(buf, "%s\n", ihost->netdev); + break; + case ISCSI_HOST_PARAM_HWADDRESS: +- len = sprintf(buf, "%s\n", ihost->hwaddress); ++ len = sysfs_emit(buf, "%s\n", ihost->hwaddress); + break; + case ISCSI_HOST_PARAM_INITIATOR_NAME: +- len = sprintf(buf, "%s\n", ihost->initiatorname); ++ len = sysfs_emit(buf, "%s\n", ihost->initiatorname); + break; + default: + return -ENOSYS; +diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c +index 2e68c0a876986..c53c3f9fa526a 100644 +--- a/drivers/scsi/scsi_transport_iscsi.c ++++ b/drivers/scsi/scsi_transport_iscsi.c +@@ -132,7 +132,11 @@ show_transport_handle(struct device *dev, struct device_attribute *attr, + char *buf) + { + struct iscsi_internal *priv = dev_to_iscsi_internal(dev); +- return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport)); ++ ++ if (!capable(CAP_SYS_ADMIN)) ++ return -EACCES; ++ return sysfs_emit(buf, "%llu\n", ++ (unsigned long long)iscsi_handle(priv->iscsi_transport)); + } + static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL); + +@@ -142,7 +146,7 @@ show_transport_##name(struct device *dev, \ + struct device_attribute *attr,char *buf) \ + { \ + struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \ +- return sprintf(buf, format"\n", priv->iscsi_transport->name); \ ++ return sysfs_emit(buf, format"\n", priv->iscsi_transport->name);\ + } \ + static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL); + +@@ -183,7 +187,7 @@ static ssize_t + show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf) + { + struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev); +- return sprintf(buf, "%llu\n", (unsigned long long) ep->id); ++ return sysfs_emit(buf, "%llu\n", (unsigned long long) ep->id); + } + static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL); + +@@ -2883,6 +2887,9 @@ iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev) + struct iscsi_cls_session *session; + int err = 0, value = 0; + ++ if (ev->u.set_param.len > PAGE_SIZE) ++ return -EINVAL; ++ + session = iscsi_session_lookup(ev->u.set_param.sid); + conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid); + if (!conn || !session) +@@ -3030,6 +3037,9 @@ iscsi_set_host_param(struct iscsi_transport *transport, + if (!transport->set_host_param) + return -ENOSYS; + ++ if (ev->u.set_host_param.len > PAGE_SIZE) ++ return -EINVAL; ++ + shost = scsi_host_lookup(ev->u.set_host_param.host_no); + if (!shost) { + printk(KERN_ERR "set_host_param could not find host no %u\n", +@@ -3617,6 +3627,7 @@ iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group) + { + int err = 0; + u32 portid; ++ u32 pdu_len; + struct iscsi_uevent *ev = nlmsg_data(nlh); + struct iscsi_transport *transport = NULL; + struct iscsi_internal *priv; +@@ -3624,6 +3635,9 @@ iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group) + struct iscsi_cls_conn *conn; + struct iscsi_endpoint *ep = NULL; + ++ if (!netlink_capable(skb, CAP_SYS_ADMIN)) ++ return -EPERM; ++ + if (nlh->nlmsg_type == ISCSI_UEVENT_PATH_UPDATE) + *group = ISCSI_NL_GRP_UIP; + else +@@ -3756,6 +3770,14 @@ iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group) + err = -EINVAL; + break; + case ISCSI_UEVENT_SEND_PDU: ++ pdu_len = nlh->nlmsg_len - sizeof(*nlh) - sizeof(*ev); ++ ++ if ((ev->u.send_pdu.hdr_size > pdu_len) || ++ (ev->u.send_pdu.data_size > (pdu_len - ev->u.send_pdu.hdr_size))) { ++ err = -EINVAL; ++ break; ++ } ++ + conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid); + if (conn) { + mutex_lock(&conn_mutex); +@@ -3960,7 +3982,7 @@ static ssize_t show_conn_state(struct device *dev, + conn->state < ARRAY_SIZE(connection_state_names)) + state = connection_state_names[conn->state]; + +- return sprintf(buf, "%s\n", state); ++ return sysfs_emit(buf, "%s\n", state); + } + static ISCSI_CLASS_ATTR(conn, state, S_IRUGO, show_conn_state, + NULL); +@@ -4188,7 +4210,7 @@ show_priv_session_state(struct device *dev, struct device_attribute *attr, + char *buf) + { + struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent); +- return sprintf(buf, "%s\n", iscsi_session_state_name(session->state)); ++ return sysfs_emit(buf, "%s\n", iscsi_session_state_name(session->state)); + } + static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state, + NULL); +@@ -4197,7 +4219,7 @@ show_priv_session_creator(struct device *dev, struct device_attribute *attr, + char *buf) + { + struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent); +- return sprintf(buf, "%d\n", session->creator); ++ return sysfs_emit(buf, "%d\n", session->creator); + } + static ISCSI_CLASS_ATTR(priv_sess, creator, S_IRUGO, show_priv_session_creator, + NULL); +@@ -4206,7 +4228,7 @@ show_priv_session_target_id(struct device *dev, struct device_attribute *attr, + char *buf) + { + struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent); +- return sprintf(buf, "%d\n", session->target_id); ++ return sysfs_emit(buf, "%d\n", session->target_id); + } + static ISCSI_CLASS_ATTR(priv_sess, target_id, S_IRUGO, + show_priv_session_target_id, NULL); +@@ -4219,8 +4241,8 @@ show_priv_session_##field(struct device *dev, \ + struct iscsi_cls_session *session = \ + iscsi_dev_to_session(dev->parent); \ + if (session->field == -1) \ +- return sprintf(buf, "off\n"); \ +- return sprintf(buf, format"\n", session->field); \ ++ return sysfs_emit(buf, "off\n"); \ ++ return sysfs_emit(buf, format"\n", session->field); \ + } + + #define iscsi_priv_session_attr_store(field) \ +diff --git a/drivers/staging/fwserial/fwserial.c b/drivers/staging/fwserial/fwserial.c +index db83d34cd6779..c368082aae1aa 100644 +--- a/drivers/staging/fwserial/fwserial.c ++++ b/drivers/staging/fwserial/fwserial.c +@@ -2189,6 +2189,7 @@ static int fwserial_create(struct fw_unit *unit) + err = fw_core_add_address_handler(&port->rx_handler, + &fw_high_memory_region); + if (err) { ++ tty_port_destroy(&port->port); + kfree(port); + goto free_ports; + } +@@ -2271,6 +2272,7 @@ unregister_ttys: + + free_ports: + for (--i; i >= 0; --i) { ++ fw_core_remove_address_handler(&serial->ports[i]->rx_handler); + tty_port_destroy(&serial->ports[i]->port); + kfree(serial->ports[i]); + } +diff --git a/drivers/staging/most/sound/sound.c b/drivers/staging/most/sound/sound.c +index 3a1a590580427..45befb8c11268 100644 +--- a/drivers/staging/most/sound/sound.c ++++ b/drivers/staging/most/sound/sound.c +@@ -86,6 +86,8 @@ static void swap_copy24(u8 *dest, const u8 *source, unsigned int bytes) + { + unsigned int i = 0; + ++ if (bytes < 2) ++ return; + while (i < bytes - 2) { + dest[i] = source[i + 2]; + dest[i + 1] = source[i + 1]; +diff --git a/drivers/staging/vc04_services/bcm2835-audio/bcm2835-ctl.c b/drivers/staging/vc04_services/bcm2835-audio/bcm2835-ctl.c +index 4c2cae99776b9..3703409715dab 100644 +--- a/drivers/staging/vc04_services/bcm2835-audio/bcm2835-ctl.c ++++ b/drivers/staging/vc04_services/bcm2835-audio/bcm2835-ctl.c +@@ -224,7 +224,7 @@ int snd_bcm2835_new_ctl(struct bcm2835_chip *chip) + { + int err; + +- strcpy(chip->card->mixername, "Broadcom Mixer"); ++ strscpy(chip->card->mixername, "Broadcom Mixer", sizeof(chip->card->mixername)); + err = create_ctls(chip, ARRAY_SIZE(snd_bcm2835_ctl), snd_bcm2835_ctl); + if (err < 0) + return err; +@@ -261,7 +261,7 @@ static const struct snd_kcontrol_new snd_bcm2835_headphones_ctl[] = { + + int snd_bcm2835_new_headphones_ctl(struct bcm2835_chip *chip) + { +- strcpy(chip->card->mixername, "Broadcom Mixer"); ++ strscpy(chip->card->mixername, "Broadcom Mixer", sizeof(chip->card->mixername)); + return create_ctls(chip, ARRAY_SIZE(snd_bcm2835_headphones_ctl), + snd_bcm2835_headphones_ctl); + } +@@ -295,7 +295,7 @@ static const struct snd_kcontrol_new snd_bcm2835_hdmi[] = { + + int snd_bcm2835_new_hdmi_ctl(struct bcm2835_chip *chip) + { +- strcpy(chip->card->mixername, "Broadcom Mixer"); ++ strscpy(chip->card->mixername, "Broadcom Mixer", sizeof(chip->card->mixername)); + return create_ctls(chip, ARRAY_SIZE(snd_bcm2835_hdmi), + snd_bcm2835_hdmi); + } +diff --git a/drivers/staging/vc04_services/bcm2835-audio/bcm2835-pcm.c b/drivers/staging/vc04_services/bcm2835-audio/bcm2835-pcm.c +index f783b632141b5..096f2c54258aa 100644 +--- a/drivers/staging/vc04_services/bcm2835-audio/bcm2835-pcm.c ++++ b/drivers/staging/vc04_services/bcm2835-audio/bcm2835-pcm.c +@@ -334,7 +334,7 @@ int snd_bcm2835_new_pcm(struct bcm2835_chip *chip, const char *name, + + pcm->private_data = chip; + pcm->nonatomic = true; +- strcpy(pcm->name, name); ++ strscpy(pcm->name, name, sizeof(pcm->name)); + if (!spdif) { + chip->dest = route; + chip->volume = 0; +diff --git a/drivers/staging/vc04_services/bcm2835-audio/bcm2835.c b/drivers/staging/vc04_services/bcm2835-audio/bcm2835.c +index cf5f80f5ca6b0..c250fbef2fa3d 100644 +--- a/drivers/staging/vc04_services/bcm2835-audio/bcm2835.c ++++ b/drivers/staging/vc04_services/bcm2835-audio/bcm2835.c +@@ -185,9 +185,9 @@ static int snd_add_child_device(struct device *dev, + goto error; + } + +- strcpy(card->driver, audio_driver->driver.name); +- strcpy(card->shortname, audio_driver->shortname); +- strcpy(card->longname, audio_driver->longname); ++ strscpy(card->driver, audio_driver->driver.name, sizeof(card->driver)); ++ strscpy(card->shortname, audio_driver->shortname, sizeof(card->shortname)); ++ strscpy(card->longname, audio_driver->longname, sizeof(card->longname)); + + err = audio_driver->newpcm(chip, audio_driver->shortname, + audio_driver->route, +diff --git a/drivers/tty/n_tty.c b/drivers/tty/n_tty.c +index 0bd32ae8a269d..dce33405ecdb1 100644 +--- a/drivers/tty/n_tty.c ++++ b/drivers/tty/n_tty.c +@@ -1945,31 +1945,27 @@ static inline int input_available_p(struct tty_struct *tty, int poll) + * Helper function to speed up n_tty_read. It is only called when + * ICANON is off; it copies characters straight from the tty queue. + * +- * It can be profitably called twice; once to drain the space from +- * the tail pointer to the (physical) end of the buffer, and once +- * to drain the space from the (physical) beginning of the buffer +- * to head pointer. +- * + * Called under the ldata->atomic_read_lock sem + * ++ * Returns true if it successfully copied data, but there is still ++ * more data to be had. ++ * + * n_tty_read()/consumer path: + * caller holds non-exclusive termios_rwsem + * read_tail published + */ + +-static int copy_from_read_buf(struct tty_struct *tty, ++static bool copy_from_read_buf(struct tty_struct *tty, + unsigned char **kbp, + size_t *nr) + + { + struct n_tty_data *ldata = tty->disc_data; +- int retval; + size_t n; + bool is_eof; + size_t head = smp_load_acquire(&ldata->commit_head); + size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); + +- retval = 0; + n = min(head - ldata->read_tail, N_TTY_BUF_SIZE - tail); + n = min(*nr, n); + if (n) { +@@ -1982,11 +1978,14 @@ static int copy_from_read_buf(struct tty_struct *tty, + /* Turn single EOF into zero-length read */ + if (L_EXTPROC(tty) && ldata->icanon && is_eof && + (head == ldata->read_tail)) +- n = 0; ++ return false; + *kbp += n; + *nr -= n; ++ ++ /* If we have more to copy, let the caller know */ ++ return head != ldata->read_tail; + } +- return retval; ++ return false; + } + + /** +@@ -2012,21 +2011,22 @@ static int copy_from_read_buf(struct tty_struct *tty, + * read_tail published + */ + +-static int canon_copy_from_read_buf(struct tty_struct *tty, +- unsigned char **kbp, +- size_t *nr) ++static bool canon_copy_from_read_buf(struct tty_struct *tty, ++ unsigned char **kbp, ++ size_t *nr) + { + struct n_tty_data *ldata = tty->disc_data; + size_t n, size, more, c; + size_t eol; +- size_t tail; ++ size_t tail, canon_head; + int found = 0; + + /* N.B. avoid overrun if nr == 0 */ + if (!*nr) +- return 0; ++ return false; + +- n = min(*nr + 1, smp_load_acquire(&ldata->canon_head) - ldata->read_tail); ++ canon_head = smp_load_acquire(&ldata->canon_head); ++ n = min(*nr + 1, canon_head - ldata->read_tail); + + tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); + size = min_t(size_t, tail + n, N_TTY_BUF_SIZE); +@@ -2070,8 +2070,11 @@ static int canon_copy_from_read_buf(struct tty_struct *tty, + else + ldata->push = 0; + tty_audit_push(); ++ return false; + } +- return 0; ++ ++ /* No EOL found - do a continuation retry if there is more data */ ++ return ldata->read_tail != canon_head; + } + + /** +@@ -2135,6 +2138,30 @@ static ssize_t n_tty_read(struct tty_struct *tty, struct file *file, + int packet; + size_t tail; + ++ /* ++ * Is this a continuation of a read started earler? ++ * ++ * If so, we still hold the atomic_read_lock and the ++ * termios_rwsem, and can just continue to copy data. ++ */ ++ if (*cookie) { ++ if (ldata->icanon && !L_EXTPROC(tty)) { ++ if (canon_copy_from_read_buf(tty, &kb, &nr)) ++ return kb - kbuf; ++ } else { ++ if (copy_from_read_buf(tty, &kb, &nr)) ++ return kb - kbuf; ++ } ++ ++ /* No more data - release locks and stop retries */ ++ n_tty_kick_worker(tty); ++ n_tty_check_unthrottle(tty); ++ up_read(&tty->termios_rwsem); ++ mutex_unlock(&ldata->atomic_read_lock); ++ *cookie = NULL; ++ return kb - kbuf; ++ } ++ + c = job_control(tty, file); + if (c < 0) + return c; +@@ -2221,23 +2248,29 @@ static ssize_t n_tty_read(struct tty_struct *tty, struct file *file, + } + + if (ldata->icanon && !L_EXTPROC(tty)) { +- retval = canon_copy_from_read_buf(tty, &kb, &nr); +- if (retval) +- break; ++ if (canon_copy_from_read_buf(tty, &kb, &nr)) ++ goto more_to_be_read; + } else { +- int uncopied; +- + /* Deal with packet mode. */ + if (packet && kb == kbuf) { + *kb++ = TIOCPKT_DATA; + nr--; + } + +- uncopied = copy_from_read_buf(tty, &kb, &nr); +- uncopied += copy_from_read_buf(tty, &kb, &nr); +- if (uncopied) { +- retval = -EFAULT; +- break; ++ /* ++ * Copy data, and if there is more to be had ++ * and we have nothing more to wait for, then ++ * let's mark us for retries. ++ * ++ * NOTE! We return here with both the termios_sem ++ * and atomic_read_lock still held, the retries ++ * will release them when done. ++ */ ++ if (copy_from_read_buf(tty, &kb, &nr) && kb - kbuf >= minimum) { ++more_to_be_read: ++ remove_wait_queue(&tty->read_wait, &wait); ++ *cookie = cookie; ++ return kb - kbuf; + } + } + +diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c +index 623738d8e32c8..5fd87941ac712 100644 +--- a/drivers/tty/tty_io.c ++++ b/drivers/tty/tty_io.c +@@ -429,8 +429,7 @@ struct tty_driver *tty_find_polling_driver(char *name, int *line) + EXPORT_SYMBOL_GPL(tty_find_polling_driver); + #endif + +-static ssize_t hung_up_tty_read(struct file *file, char __user *buf, +- size_t count, loff_t *ppos) ++static ssize_t hung_up_tty_read(struct kiocb *iocb, struct iov_iter *to) + { + return 0; + } +@@ -502,7 +501,7 @@ static const struct file_operations console_fops = { + + static const struct file_operations hung_up_tty_fops = { + .llseek = no_llseek, +- .read = hung_up_tty_read, ++ .read_iter = hung_up_tty_read, + .write_iter = hung_up_tty_write, + .poll = hung_up_tty_poll, + .unlocked_ioctl = hung_up_tty_ioctl, +@@ -859,13 +858,20 @@ static int iterate_tty_read(struct tty_ldisc *ld, struct tty_struct *tty, + if (!size) + break; + +- /* +- * A ldisc read error return will override any previously copied +- * data (eg -EOVERFLOW from HDLC) +- */ + if (size < 0) { +- memzero_explicit(kernel_buf, sizeof(kernel_buf)); +- return size; ++ /* Did we have an earlier error (ie -EFAULT)? */ ++ if (retval) ++ break; ++ retval = size; ++ ++ /* ++ * -EOVERFLOW means we didn't have enough space ++ * for a whole packet, and we shouldn't return ++ * a partial result. ++ */ ++ if (retval == -EOVERFLOW) ++ offset = 0; ++ break; + } + + copied = copy_to_iter(kernel_buf, size, to); +@@ -921,8 +927,10 @@ static ssize_t tty_read(struct kiocb *iocb, struct iov_iter *to) + /* We want to wait for the line discipline to sort out in this + situation */ + ld = tty_ldisc_ref_wait(tty); ++ if (!ld) ++ return hung_up_tty_read(iocb, to); + i = -EIO; +- if (ld && ld->ops->read) ++ if (ld->ops->read) + i = iterate_tty_read(ld, tty, file, to); + tty_ldisc_deref(ld); + +diff --git a/drivers/tty/vt/consolemap.c b/drivers/tty/vt/consolemap.c +index f7d015c67963d..d815ac98b39e3 100644 +--- a/drivers/tty/vt/consolemap.c ++++ b/drivers/tty/vt/consolemap.c +@@ -495,7 +495,7 @@ con_insert_unipair(struct uni_pagedir *p, u_short unicode, u_short fontpos) + + p2[unicode & 0x3f] = fontpos; + +- p->sum += (fontpos << 20) + unicode; ++ p->sum += (fontpos << 20U) + unicode; + + return 0; + } +diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c +index 78bd28873945a..3dca6aab0f1f8 100644 +--- a/drivers/vfio/vfio_iommu_type1.c ++++ b/drivers/vfio/vfio_iommu_type1.c +@@ -24,6 +24,7 @@ + #include <linux/compat.h> + #include <linux/device.h> + #include <linux/fs.h> ++#include <linux/highmem.h> + #include <linux/iommu.h> + #include <linux/module.h> + #include <linux/mm.h> +@@ -431,9 +432,11 @@ static int follow_fault_pfn(struct vm_area_struct *vma, struct mm_struct *mm, + unsigned long vaddr, unsigned long *pfn, + bool write_fault) + { ++ pte_t *ptep; ++ spinlock_t *ptl; + int ret; + +- ret = follow_pfn(vma, vaddr, pfn); ++ ret = follow_pte(vma->vm_mm, vaddr, &ptep, &ptl); + if (ret) { + bool unlocked = false; + +@@ -447,9 +450,17 @@ static int follow_fault_pfn(struct vm_area_struct *vma, struct mm_struct *mm, + if (ret) + return ret; + +- ret = follow_pfn(vma, vaddr, pfn); ++ ret = follow_pte(vma->vm_mm, vaddr, &ptep, &ptl); ++ if (ret) ++ return ret; + } + ++ if (write_fault && !pte_write(*ptep)) ++ ret = -EFAULT; ++ else ++ *pfn = pte_pfn(*ptep); ++ ++ pte_unmap_unlock(ptep, ptl); + return ret; + } + +diff --git a/drivers/video/fbdev/udlfb.c b/drivers/video/fbdev/udlfb.c +index f9b3c1cb9530f..b9cdd02c10009 100644 +--- a/drivers/video/fbdev/udlfb.c ++++ b/drivers/video/fbdev/udlfb.c +@@ -1017,6 +1017,7 @@ static void dlfb_ops_destroy(struct fb_info *info) + } + vfree(dlfb->backing_buffer); + kfree(dlfb->edid); ++ dlfb_free_urb_list(dlfb); + usb_put_dev(dlfb->udev); + kfree(dlfb); + +diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c +index 6af7f2bf92de7..fbf93067642ac 100644 +--- a/fs/btrfs/transaction.c ++++ b/fs/btrfs/transaction.c +@@ -1319,7 +1319,6 @@ static noinline int commit_fs_roots(struct btrfs_trans_handle *trans) + struct btrfs_root *gang[8]; + int i; + int ret; +- int err = 0; + + spin_lock(&fs_info->fs_roots_radix_lock); + while (1) { +@@ -1331,6 +1330,8 @@ static noinline int commit_fs_roots(struct btrfs_trans_handle *trans) + break; + for (i = 0; i < ret; i++) { + struct btrfs_root *root = gang[i]; ++ int ret2; ++ + radix_tree_tag_clear(&fs_info->fs_roots_radix, + (unsigned long)root->root_key.objectid, + BTRFS_ROOT_TRANS_TAG); +@@ -1350,17 +1351,17 @@ static noinline int commit_fs_roots(struct btrfs_trans_handle *trans) + root->node); + } + +- err = btrfs_update_root(trans, fs_info->tree_root, ++ ret2 = btrfs_update_root(trans, fs_info->tree_root, + &root->root_key, + &root->root_item); ++ if (ret2) ++ return ret2; + spin_lock(&fs_info->fs_roots_radix_lock); +- if (err) +- break; + btrfs_qgroup_free_meta_all_pertrans(root); + } + } + spin_unlock(&fs_info->fs_roots_radix_lock); +- return err; ++ return 0; + } + + /* +diff --git a/fs/erofs/super.c b/fs/erofs/super.c +index be10b16ea66ee..d5a6b9b888a56 100644 +--- a/fs/erofs/super.c ++++ b/fs/erofs/super.c +@@ -158,8 +158,8 @@ static int erofs_read_superblock(struct super_block *sb) + blkszbits = dsb->blkszbits; + /* 9(512 bytes) + LOG_SECTORS_PER_BLOCK == LOG_BLOCK_SIZE */ + if (blkszbits != LOG_BLOCK_SIZE) { +- erofs_err(sb, "blksize %u isn't supported on this platform", +- 1 << blkszbits); ++ erofs_err(sb, "blkszbits %u isn't supported on this platform", ++ blkszbits); + goto out; + } + +diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c +index 6edb1ab579a18..8878049685769 100644 +--- a/fs/f2fs/namei.c ++++ b/fs/f2fs/namei.c +@@ -855,7 +855,11 @@ static int __f2fs_tmpfile(struct inode *dir, struct dentry *dentry, + + if (whiteout) { + f2fs_i_links_write(inode, false); ++ ++ spin_lock(&inode->i_lock); + inode->i_state |= I_LINKABLE; ++ spin_unlock(&inode->i_lock); ++ + *whiteout = inode; + } else { + d_tmpfile(dentry, inode); +@@ -1041,7 +1045,11 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry, + err = f2fs_add_link(old_dentry, whiteout); + if (err) + goto put_out_dir; ++ ++ spin_lock(&whiteout->i_lock); + whiteout->i_state &= ~I_LINKABLE; ++ spin_unlock(&whiteout->i_lock); ++ + iput(whiteout); + } + +diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h +index e81eb0748e2a9..229814b4f4a6c 100644 +--- a/fs/f2fs/segment.h ++++ b/fs/f2fs/segment.h +@@ -101,11 +101,11 @@ static inline void sanity_check_seg_type(struct f2fs_sb_info *sbi, + #define BLKS_PER_SEC(sbi) \ + ((sbi)->segs_per_sec * (sbi)->blocks_per_seg) + #define GET_SEC_FROM_SEG(sbi, segno) \ +- ((segno) / (sbi)->segs_per_sec) ++ (((segno) == -1) ? -1: (segno) / (sbi)->segs_per_sec) + #define GET_SEG_FROM_SEC(sbi, secno) \ + ((secno) * (sbi)->segs_per_sec) + #define GET_ZONE_FROM_SEC(sbi, secno) \ +- ((secno) / (sbi)->secs_per_zone) ++ (((secno) == -1) ? -1: (secno) / (sbi)->secs_per_zone) + #define GET_ZONE_FROM_SEG(sbi, segno) \ + GET_ZONE_FROM_SEC(sbi, GET_SEC_FROM_SEG(sbi, segno)) + +diff --git a/fs/jfs/jfs_filsys.h b/fs/jfs/jfs_filsys.h +index 1e899298f7f00..b5d702df7111a 100644 +--- a/fs/jfs/jfs_filsys.h ++++ b/fs/jfs/jfs_filsys.h +@@ -268,5 +268,6 @@ + * fsck() must be run to repair + */ + #define FM_EXTENDFS 0x00000008 /* file system extendfs() in progress */ ++#define FM_STATE_MAX 0x0000000f /* max value of s_state */ + + #endif /* _H_JFS_FILSYS */ +diff --git a/fs/jfs/jfs_mount.c b/fs/jfs/jfs_mount.c +index 2935d4c776ec7..5d7d7170c03c0 100644 +--- a/fs/jfs/jfs_mount.c ++++ b/fs/jfs/jfs_mount.c +@@ -37,6 +37,7 @@ + #include <linux/fs.h> + #include <linux/buffer_head.h> + #include <linux/blkdev.h> ++#include <linux/log2.h> + + #include "jfs_incore.h" + #include "jfs_filsys.h" +@@ -366,6 +367,15 @@ static int chkSuper(struct super_block *sb) + sbi->bsize = bsize; + sbi->l2bsize = le16_to_cpu(j_sb->s_l2bsize); + ++ /* check some fields for possible corruption */ ++ if (sbi->l2bsize != ilog2((u32)bsize) || ++ j_sb->pad != 0 || ++ le32_to_cpu(j_sb->s_state) > FM_STATE_MAX) { ++ rc = -EINVAL; ++ jfs_err("jfs_mount: Mount Failure: superblock is corrupt!"); ++ goto out; ++ } ++ + /* + * For now, ignore s_pbsize, l2bfactor. All I/O going through buffer + * cache. +diff --git a/fs/namei.c b/fs/namei.c +index 78443a85480a5..dd85e12ac85a6 100644 +--- a/fs/namei.c ++++ b/fs/namei.c +@@ -669,17 +669,17 @@ static bool legitimize_root(struct nameidata *nd) + */ + + /** +- * unlazy_walk - try to switch to ref-walk mode. ++ * try_to_unlazy - try to switch to ref-walk mode. + * @nd: nameidata pathwalk data +- * Returns: 0 on success, -ECHILD on failure ++ * Returns: true on success, false on failure + * +- * unlazy_walk attempts to legitimize the current nd->path and nd->root ++ * try_to_unlazy attempts to legitimize the current nd->path and nd->root + * for ref-walk mode. + * Must be called from rcu-walk context. +- * Nothing should touch nameidata between unlazy_walk() failure and ++ * Nothing should touch nameidata between try_to_unlazy() failure and + * terminate_walk(). + */ +-static int unlazy_walk(struct nameidata *nd) ++static bool try_to_unlazy(struct nameidata *nd) + { + struct dentry *parent = nd->path.dentry; + +@@ -694,14 +694,14 @@ static int unlazy_walk(struct nameidata *nd) + goto out; + rcu_read_unlock(); + BUG_ON(nd->inode != parent->d_inode); +- return 0; ++ return true; + + out1: + nd->path.mnt = NULL; + nd->path.dentry = NULL; + out: + rcu_read_unlock(); +- return -ECHILD; ++ return false; + } + + /** +@@ -792,7 +792,7 @@ static int complete_walk(struct nameidata *nd) + */ + if (!(nd->flags & (LOOKUP_ROOT | LOOKUP_IS_SCOPED))) + nd->root.mnt = NULL; +- if (unlikely(unlazy_walk(nd))) ++ if (!try_to_unlazy(nd)) + return -ECHILD; + } + +@@ -1466,7 +1466,7 @@ static struct dentry *lookup_fast(struct nameidata *nd, + unsigned seq; + dentry = __d_lookup_rcu(parent, &nd->last, &seq); + if (unlikely(!dentry)) { +- if (unlazy_walk(nd)) ++ if (!try_to_unlazy(nd)) + return ERR_PTR(-ECHILD); + return NULL; + } +@@ -1567,10 +1567,8 @@ static inline int may_lookup(struct nameidata *nd) + { + if (nd->flags & LOOKUP_RCU) { + int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK); +- if (err != -ECHILD) ++ if (err != -ECHILD || !try_to_unlazy(nd)) + return err; +- if (unlazy_walk(nd)) +- return -ECHILD; + } + return inode_permission(nd->inode, MAY_EXEC); + } +@@ -1592,7 +1590,7 @@ static int reserve_stack(struct nameidata *nd, struct path *link, unsigned seq) + // unlazy even if we fail to grab the link - cleanup needs it + bool grabbed_link = legitimize_path(nd, link, seq); + +- if (unlazy_walk(nd) != 0 || !grabbed_link) ++ if (!try_to_unlazy(nd) != 0 || !grabbed_link) + return -ECHILD; + + if (nd_alloc_stack(nd)) +@@ -1634,7 +1632,7 @@ static const char *pick_link(struct nameidata *nd, struct path *link, + touch_atime(&last->link); + cond_resched(); + } else if (atime_needs_update(&last->link, inode)) { +- if (unlikely(unlazy_walk(nd))) ++ if (!try_to_unlazy(nd)) + return ERR_PTR(-ECHILD); + touch_atime(&last->link); + } +@@ -1651,11 +1649,8 @@ static const char *pick_link(struct nameidata *nd, struct path *link, + get = inode->i_op->get_link; + if (nd->flags & LOOKUP_RCU) { + res = get(NULL, inode, &last->done); +- if (res == ERR_PTR(-ECHILD)) { +- if (unlikely(unlazy_walk(nd))) +- return ERR_PTR(-ECHILD); ++ if (res == ERR_PTR(-ECHILD) && try_to_unlazy(nd)) + res = get(link->dentry, inode, &last->done); +- } + } else { + res = get(link->dentry, inode, &last->done); + } +@@ -2195,7 +2190,7 @@ OK: + } + if (unlikely(!d_can_lookup(nd->path.dentry))) { + if (nd->flags & LOOKUP_RCU) { +- if (unlazy_walk(nd)) ++ if (!try_to_unlazy(nd)) + return -ECHILD; + } + return -ENOTDIR; +@@ -3129,7 +3124,6 @@ static const char *open_last_lookups(struct nameidata *nd, + struct inode *inode; + struct dentry *dentry; + const char *res; +- int error; + + nd->flags |= op->intent; + +@@ -3153,9 +3147,8 @@ static const char *open_last_lookups(struct nameidata *nd, + } else { + /* create side of things */ + if (nd->flags & LOOKUP_RCU) { +- error = unlazy_walk(nd); +- if (unlikely(error)) +- return ERR_PTR(error); ++ if (!try_to_unlazy(nd)) ++ return ERR_PTR(-ECHILD); + } + audit_inode(nd->name, dir, AUDIT_INODE_PARENT); + /* trailing slashes? */ +@@ -3164,9 +3157,7 @@ static const char *open_last_lookups(struct nameidata *nd, + } + + if (open_flag & (O_CREAT | O_TRUNC | O_WRONLY | O_RDWR)) { +- error = mnt_want_write(nd->path.mnt); +- if (!error) +- got_write = true; ++ got_write = !mnt_want_write(nd->path.mnt); + /* + * do _not_ fail yet - we might not need that or fail with + * a different error; let lookup_open() decide; we'll be +diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c +index 67c8dc9de8aa4..f1e21b6cfa481 100644 +--- a/fs/xfs/xfs_iops.c ++++ b/fs/xfs/xfs_iops.c +@@ -846,7 +846,7 @@ xfs_setattr_size( + ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL)); + ASSERT(S_ISREG(inode->i_mode)); + ASSERT((iattr->ia_valid & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET| +- ATTR_MTIME_SET|ATTR_KILL_PRIV|ATTR_TIMES_SET)) == 0); ++ ATTR_MTIME_SET|ATTR_TIMES_SET)) == 0); + + oldsize = inode->i_size; + newsize = iattr->ia_size; +diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h +index 5ff27c12ce688..fb79ac497794b 100644 +--- a/include/linux/netdevice.h ++++ b/include/linux/netdevice.h +@@ -3918,6 +3918,9 @@ int dev_pre_changeaddr_notify(struct net_device *dev, const char *addr, + struct netlink_ext_ack *extack); + int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa, + struct netlink_ext_ack *extack); ++int dev_set_mac_address_user(struct net_device *dev, struct sockaddr *sa, ++ struct netlink_ext_ack *extack); ++int dev_get_mac_address(struct sockaddr *sa, struct net *net, char *dev_name); + int dev_change_carrier(struct net_device *, bool new_carrier); + int dev_get_phys_port_id(struct net_device *dev, + struct netdev_phys_item_id *ppid); +diff --git a/include/linux/swap.h b/include/linux/swap.h +index 596bc2f4d9b03..55fe2f5b6f5ff 100644 +--- a/include/linux/swap.h ++++ b/include/linux/swap.h +@@ -482,6 +482,7 @@ struct backing_dev_info; + extern int init_swap_address_space(unsigned int type, unsigned long nr_pages); + extern void exit_swap_address_space(unsigned int type); + extern struct swap_info_struct *get_swap_device(swp_entry_t entry); ++sector_t swap_page_sector(struct page *page); + + static inline void put_swap_device(struct swap_info_struct *si) + { +diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h +index c1504aa3d9cfd..ba2f439bc04d3 100644 +--- a/include/net/bluetooth/hci.h ++++ b/include/net/bluetooth/hci.h +@@ -238,6 +238,14 @@ enum { + * during the hdev->setup vendor callback. + */ + HCI_QUIRK_BROKEN_ERR_DATA_REPORTING, ++ ++ /* ++ * When this quirk is set, then the hci_suspend_notifier is not ++ * registered. This is intended for devices which drop completely ++ * from the bus on system-suspend and which will show up as a new ++ * HCI after resume. ++ */ ++ HCI_QUIRK_NO_SUSPEND_NOTIFIER, + }; + + /* HCI device flags */ +diff --git a/include/uapi/linux/pkt_cls.h b/include/uapi/linux/pkt_cls.h +index ee95f42fb0ecf..88f4bf0047e7a 100644 +--- a/include/uapi/linux/pkt_cls.h ++++ b/include/uapi/linux/pkt_cls.h +@@ -591,6 +591,8 @@ enum { + TCA_FLOWER_KEY_CT_FLAGS_ESTABLISHED = 1 << 1, /* Part of an existing connection. */ + TCA_FLOWER_KEY_CT_FLAGS_RELATED = 1 << 2, /* Related to an established connection. */ + TCA_FLOWER_KEY_CT_FLAGS_TRACKED = 1 << 3, /* Conntrack has occurred. */ ++ ++ __TCA_FLOWER_KEY_CT_FLAGS_MAX, + }; + + enum { +diff --git a/kernel/sched/core.c b/kernel/sched/core.c +index ff74fca39ed21..fa1f83083a58b 100644 +--- a/kernel/sched/core.c ++++ b/kernel/sched/core.c +@@ -355,8 +355,9 @@ static enum hrtimer_restart hrtick(struct hrtimer *timer) + static void __hrtick_restart(struct rq *rq) + { + struct hrtimer *timer = &rq->hrtick_timer; ++ ktime_t time = rq->hrtick_time; + +- hrtimer_start_expires(timer, HRTIMER_MODE_ABS_PINNED_HARD); ++ hrtimer_start(timer, time, HRTIMER_MODE_ABS_PINNED_HARD); + } + + /* +@@ -380,7 +381,6 @@ static void __hrtick_start(void *arg) + void hrtick_start(struct rq *rq, u64 delay) + { + struct hrtimer *timer = &rq->hrtick_timer; +- ktime_t time; + s64 delta; + + /* +@@ -388,9 +388,7 @@ void hrtick_start(struct rq *rq, u64 delay) + * doesn't make sense and can cause timer DoS. + */ + delta = max_t(s64, delay, 10000LL); +- time = ktime_add_ns(timer->base->get_time(), delta); +- +- hrtimer_set_expires(timer, time); ++ rq->hrtick_time = ktime_add_ns(timer->base->get_time(), delta); + + if (rq == this_rq()) + __hrtick_restart(rq); +@@ -3478,7 +3476,7 @@ out: + + /** + * try_invoke_on_locked_down_task - Invoke a function on task in fixed state +- * @p: Process for which the function is to be invoked. ++ * @p: Process for which the function is to be invoked, can be @current. + * @func: Function to invoke. + * @arg: Argument to function. + * +@@ -3496,12 +3494,11 @@ out: + */ + bool try_invoke_on_locked_down_task(struct task_struct *p, bool (*func)(struct task_struct *t, void *arg), void *arg) + { +- bool ret = false; + struct rq_flags rf; ++ bool ret = false; + struct rq *rq; + +- lockdep_assert_irqs_enabled(); +- raw_spin_lock_irq(&p->pi_lock); ++ raw_spin_lock_irqsave(&p->pi_lock, rf.flags); + if (p->on_rq) { + rq = __task_rq_lock(p, &rf); + if (task_rq(p) == rq) +@@ -3518,7 +3515,7 @@ bool try_invoke_on_locked_down_task(struct task_struct *p, bool (*func)(struct t + ret = func(p, arg); + } + } +- raw_spin_unlock_irq(&p->pi_lock); ++ raw_spin_unlock_irqrestore(&p->pi_lock, rf.flags); + return ret; + } + +diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h +index bb09988451a04..282a6bbaacd73 100644 +--- a/kernel/sched/sched.h ++++ b/kernel/sched/sched.h +@@ -1031,6 +1031,7 @@ struct rq { + call_single_data_t hrtick_csd; + #endif + struct hrtimer hrtick_timer; ++ ktime_t hrtick_time; + #endif + + #ifdef CONFIG_SCHEDSTATS +diff --git a/mm/hugetlb.c b/mm/hugetlb.c +index 723e8d342c627..1690e8db5b0de 100644 +--- a/mm/hugetlb.c ++++ b/mm/hugetlb.c +@@ -5304,21 +5304,23 @@ static bool vma_shareable(struct vm_area_struct *vma, unsigned long addr) + void adjust_range_if_pmd_sharing_possible(struct vm_area_struct *vma, + unsigned long *start, unsigned long *end) + { +- unsigned long a_start, a_end; ++ unsigned long v_start = ALIGN(vma->vm_start, PUD_SIZE), ++ v_end = ALIGN_DOWN(vma->vm_end, PUD_SIZE); + +- if (!(vma->vm_flags & VM_MAYSHARE)) ++ /* ++ * vma need span at least one aligned PUD size and the start,end range ++ * must at least partialy within it. ++ */ ++ if (!(vma->vm_flags & VM_MAYSHARE) || !(v_end > v_start) || ++ (*end <= v_start) || (*start >= v_end)) + return; + + /* Extend the range to be PUD aligned for a worst case scenario */ +- a_start = ALIGN_DOWN(*start, PUD_SIZE); +- a_end = ALIGN(*end, PUD_SIZE); ++ if (*start > v_start) ++ *start = ALIGN_DOWN(*start, PUD_SIZE); + +- /* +- * Intersect the range with the vma range, since pmd sharing won't be +- * across vma after all +- */ +- *start = max(vma->vm_start, a_start); +- *end = min(vma->vm_end, a_end); ++ if (*end < v_end) ++ *end = ALIGN(*end, PUD_SIZE); + } + + /* +diff --git a/mm/page_io.c b/mm/page_io.c +index 9bca17ecc4df1..21f3160d39a83 100644 +--- a/mm/page_io.c ++++ b/mm/page_io.c +@@ -273,11 +273,6 @@ out: + return ret; + } + +-static sector_t swap_page_sector(struct page *page) +-{ +- return (sector_t)__page_file_index(page) << (PAGE_SHIFT - 9); +-} +- + static inline void count_swpout_vm_event(struct page *page) + { + #ifdef CONFIG_TRANSPARENT_HUGEPAGE +diff --git a/mm/swapfile.c b/mm/swapfile.c +index 9fffc5af29d1b..348f6665c06c4 100644 +--- a/mm/swapfile.c ++++ b/mm/swapfile.c +@@ -220,6 +220,19 @@ offset_to_swap_extent(struct swap_info_struct *sis, unsigned long offset) + BUG(); + } + ++sector_t swap_page_sector(struct page *page) ++{ ++ struct swap_info_struct *sis = page_swap_info(page); ++ struct swap_extent *se; ++ sector_t sector; ++ pgoff_t offset; ++ ++ offset = __page_file_index(page); ++ se = offset_to_swap_extent(sis, offset); ++ sector = se->start_block + (offset - se->start_page); ++ return sector << (PAGE_SHIFT - 9); ++} ++ + /* + * swap allocation tell device that a cluster of swap can now be discarded, + * to allow the swap device to optimize its wear-levelling. +diff --git a/net/bluetooth/amp.c b/net/bluetooth/amp.c +index 9c711f0dfae35..be2d469d6369d 100644 +--- a/net/bluetooth/amp.c ++++ b/net/bluetooth/amp.c +@@ -297,6 +297,9 @@ void amp_read_loc_assoc_final_data(struct hci_dev *hdev, + struct hci_request req; + int err; + ++ if (!mgr) ++ return; ++ + cp.phy_handle = hcon->handle; + cp.len_so_far = cpu_to_le16(0); + cp.max_len = cpu_to_le16(hdev->amp_assoc_size); +diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c +index 9f8573131b97e..6ea2e16c57bdf 100644 +--- a/net/bluetooth/hci_core.c ++++ b/net/bluetooth/hci_core.c +@@ -3568,7 +3568,8 @@ static int hci_suspend_notifier(struct notifier_block *nb, unsigned long action, + } + + /* Suspend notifier should only act on events when powered. */ +- if (!hdev_is_powered(hdev)) ++ if (!hdev_is_powered(hdev) || ++ hci_dev_test_flag(hdev, HCI_UNREGISTER)) + goto done; + + if (action == PM_SUSPEND_PREPARE) { +@@ -3829,10 +3830,12 @@ int hci_register_dev(struct hci_dev *hdev) + hci_sock_dev_event(hdev, HCI_DEV_REG); + hci_dev_hold(hdev); + +- hdev->suspend_notifier.notifier_call = hci_suspend_notifier; +- error = register_pm_notifier(&hdev->suspend_notifier); +- if (error) +- goto err_wqueue; ++ if (!test_bit(HCI_QUIRK_NO_SUSPEND_NOTIFIER, &hdev->quirks)) { ++ hdev->suspend_notifier.notifier_call = hci_suspend_notifier; ++ error = register_pm_notifier(&hdev->suspend_notifier); ++ if (error) ++ goto err_wqueue; ++ } + + queue_work(hdev->req_workqueue, &hdev->power_on); + +@@ -3867,9 +3870,11 @@ void hci_unregister_dev(struct hci_dev *hdev) + + cancel_work_sync(&hdev->power_on); + +- hci_suspend_clear_tasks(hdev); +- unregister_pm_notifier(&hdev->suspend_notifier); +- cancel_work_sync(&hdev->suspend_prepare); ++ if (!test_bit(HCI_QUIRK_NO_SUSPEND_NOTIFIER, &hdev->quirks)) { ++ hci_suspend_clear_tasks(hdev); ++ unregister_pm_notifier(&hdev->suspend_notifier); ++ cancel_work_sync(&hdev->suspend_prepare); ++ } + + hci_dev_do_close(hdev); + +diff --git a/net/bridge/br_sysfs_if.c b/net/bridge/br_sysfs_if.c +index 7a59cdddd3ce3..5047e9c2333a2 100644 +--- a/net/bridge/br_sysfs_if.c ++++ b/net/bridge/br_sysfs_if.c +@@ -55,9 +55,8 @@ static BRPORT_ATTR(_name, 0644, \ + static int store_flag(struct net_bridge_port *p, unsigned long v, + unsigned long mask) + { +- unsigned long flags; +- +- flags = p->flags; ++ unsigned long flags = p->flags; ++ int err; + + if (v) + flags |= mask; +@@ -65,6 +64,10 @@ static int store_flag(struct net_bridge_port *p, unsigned long v, + flags &= ~mask; + + if (flags != p->flags) { ++ err = br_switchdev_set_port_flag(p, flags, mask); ++ if (err) ++ return err; ++ + p->flags = flags; + br_port_flags_change(p, mask); + } +diff --git a/net/core/dev.c b/net/core/dev.c +index 449b45b843d40..a5a1dbe66b762 100644 +--- a/net/core/dev.c ++++ b/net/core/dev.c +@@ -8743,6 +8743,48 @@ int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa, + } + EXPORT_SYMBOL(dev_set_mac_address); + ++static DECLARE_RWSEM(dev_addr_sem); ++ ++int dev_set_mac_address_user(struct net_device *dev, struct sockaddr *sa, ++ struct netlink_ext_ack *extack) ++{ ++ int ret; ++ ++ down_write(&dev_addr_sem); ++ ret = dev_set_mac_address(dev, sa, extack); ++ up_write(&dev_addr_sem); ++ return ret; ++} ++EXPORT_SYMBOL(dev_set_mac_address_user); ++ ++int dev_get_mac_address(struct sockaddr *sa, struct net *net, char *dev_name) ++{ ++ size_t size = sizeof(sa->sa_data); ++ struct net_device *dev; ++ int ret = 0; ++ ++ down_read(&dev_addr_sem); ++ rcu_read_lock(); ++ ++ dev = dev_get_by_name_rcu(net, dev_name); ++ if (!dev) { ++ ret = -ENODEV; ++ goto unlock; ++ } ++ if (!dev->addr_len) ++ memset(sa->sa_data, 0, size); ++ else ++ memcpy(sa->sa_data, dev->dev_addr, ++ min_t(size_t, size, dev->addr_len)); ++ sa->sa_family = dev->type; ++ ++unlock: ++ rcu_read_unlock(); ++ up_read(&dev_addr_sem); ++ return ret; ++} ++EXPORT_SYMBOL(dev_get_mac_address); ++ + /** + * dev_change_carrier - Change device carrier + * @dev: device +diff --git a/net/core/dev_ioctl.c b/net/core/dev_ioctl.c +index db8a0ff86f366..478d032f34aca 100644 +--- a/net/core/dev_ioctl.c ++++ b/net/core/dev_ioctl.c +@@ -123,17 +123,6 @@ static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cm + ifr->ifr_mtu = dev->mtu; + return 0; + +- case SIOCGIFHWADDR: +- if (!dev->addr_len) +- memset(ifr->ifr_hwaddr.sa_data, 0, +- sizeof(ifr->ifr_hwaddr.sa_data)); +- else +- memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr, +- min(sizeof(ifr->ifr_hwaddr.sa_data), +- (size_t)dev->addr_len)); +- ifr->ifr_hwaddr.sa_family = dev->type; +- return 0; +- + case SIOCGIFSLAVE: + err = -EINVAL; + break; +@@ -274,7 +263,7 @@ static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd) + case SIOCSIFHWADDR: + if (dev->addr_len > sizeof(struct sockaddr)) + return -EINVAL; +- return dev_set_mac_address(dev, &ifr->ifr_hwaddr, NULL); ++ return dev_set_mac_address_user(dev, &ifr->ifr_hwaddr, NULL); + + case SIOCSIFHWBROADCAST: + if (ifr->ifr_hwaddr.sa_family != dev->type) +@@ -418,6 +407,12 @@ int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_c + */ + + switch (cmd) { ++ case SIOCGIFHWADDR: ++ dev_load(net, ifr->ifr_name); ++ ret = dev_get_mac_address(&ifr->ifr_hwaddr, net, ifr->ifr_name); ++ if (colon) ++ *colon = ':'; ++ return ret; + /* + * These ioctl calls: + * - can be done by all. +@@ -427,7 +422,6 @@ int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_c + case SIOCGIFFLAGS: + case SIOCGIFMETRIC: + case SIOCGIFMTU: +- case SIOCGIFHWADDR: + case SIOCGIFSLAVE: + case SIOCGIFMAP: + case SIOCGIFINDEX: +diff --git a/net/core/pktgen.c b/net/core/pktgen.c +index 105978604ffdb..3fba429f1f57b 100644 +--- a/net/core/pktgen.c ++++ b/net/core/pktgen.c +@@ -3464,7 +3464,7 @@ static int pktgen_thread_worker(void *arg) + struct pktgen_dev *pkt_dev = NULL; + int cpu = t->cpu; + +- BUG_ON(smp_processor_id() != cpu); ++ WARN_ON(smp_processor_id() != cpu); + + init_waitqueue_head(&t->queue); + complete(&t->start_done); +diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c +index 3d6ab194d0f58..f7c3885133dd1 100644 +--- a/net/core/rtnetlink.c ++++ b/net/core/rtnetlink.c +@@ -2660,7 +2660,7 @@ static int do_setlink(const struct sk_buff *skb, + sa->sa_family = dev->type; + memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]), + dev->addr_len); +- err = dev_set_mac_address(dev, sa, extack); ++ err = dev_set_mac_address_user(dev, sa, extack); + kfree(sa); + if (err) + goto errout; +diff --git a/net/core/skbuff.c b/net/core/skbuff.c +index 785daff48030d..28b8242f18d79 100644 +--- a/net/core/skbuff.c ++++ b/net/core/skbuff.c +@@ -3292,7 +3292,19 @@ EXPORT_SYMBOL(skb_split); + */ + static int skb_prepare_for_shift(struct sk_buff *skb) + { +- return skb_cloned(skb) && pskb_expand_head(skb, 0, 0, GFP_ATOMIC); ++ int ret = 0; ++ ++ if (skb_cloned(skb)) { ++ /* Save and restore truesize: pskb_expand_head() may reallocate ++ * memory where ksize(kmalloc(S)) != ksize(kmalloc(S)), but we ++ * cannot change truesize at this point. ++ */ ++ unsigned int save_truesize = skb->truesize; ++ ++ ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC); ++ skb->truesize = save_truesize; ++ } ++ return ret; + } + + /** +diff --git a/net/dsa/tag_rtl4_a.c b/net/dsa/tag_rtl4_a.c +index 2646abe5a69e8..c17d39b4a1a04 100644 +--- a/net/dsa/tag_rtl4_a.c ++++ b/net/dsa/tag_rtl4_a.c +@@ -12,9 +12,7 @@ + * + * The 2 bytes tag form a 16 bit big endian word. The exact + * meaning has been guessed from packet dumps from ingress +- * frames, as no working egress traffic has been available +- * we do not know the format of the egress tags or if they +- * are even supported. ++ * frames. + */ + + #include <linux/etherdevice.h> +@@ -36,17 +34,34 @@ + static struct sk_buff *rtl4a_tag_xmit(struct sk_buff *skb, + struct net_device *dev) + { +- /* +- * Just let it pass thru, we don't know if it is possible +- * to tag a frame with the 0x8899 ethertype and direct it +- * to a specific port, all attempts at reverse-engineering have +- * ended up with the frames getting dropped. +- * +- * The VLAN set-up needs to restrict the frames to the right port. +- * +- * If you have documentation on the tagging format for RTL8366RB +- * (tag type A) then please contribute. +- */ ++ struct dsa_port *dp = dsa_slave_to_port(dev); ++ u8 *tag; ++ u16 *p; ++ u16 out; ++ ++ /* Pad out to at least 60 bytes */ ++ if (unlikely(eth_skb_pad(skb))) ++ return NULL; ++ if (skb_cow_head(skb, RTL4_A_HDR_LEN) < 0) ++ return NULL; ++ ++ netdev_dbg(dev, "add realtek tag to package to port %d\n", ++ dp->index); ++ skb_push(skb, RTL4_A_HDR_LEN); ++ ++ memmove(skb->data, skb->data + RTL4_A_HDR_LEN, 2 * ETH_ALEN); ++ tag = skb->data + 2 * ETH_ALEN; ++ ++ /* Set Ethertype */ ++ p = (u16 *)tag; ++ *p = htons(RTL4_A_ETHERTYPE); ++ ++ out = (RTL4_A_PROTOCOL_RTL8366RB << 12) | (2 << 8); ++ /* The lower bits is the port numer */ ++ out |= (u8)dp->index; ++ p = (u16 *)(tag + 2); ++ *p = htons(out); ++ + return skb; + } + +diff --git a/net/hsr/hsr_framereg.c b/net/hsr/hsr_framereg.c +index 5c97de4599057..805f974923b92 100644 +--- a/net/hsr/hsr_framereg.c ++++ b/net/hsr/hsr_framereg.c +@@ -164,8 +164,10 @@ static struct hsr_node *hsr_add_node(struct hsr_priv *hsr, + * as initialization. (0 could trigger an spurious ring error warning). + */ + now = jiffies; +- for (i = 0; i < HSR_PT_PORTS; i++) ++ for (i = 0; i < HSR_PT_PORTS; i++) { + new_node->time_in[i] = now; ++ new_node->time_out[i] = now; ++ } + for (i = 0; i < HSR_PT_PORTS; i++) + new_node->seq_out[i] = seq_out; + +@@ -411,9 +413,12 @@ void hsr_register_frame_in(struct hsr_node *node, struct hsr_port *port, + int hsr_register_frame_out(struct hsr_port *port, struct hsr_node *node, + u16 sequence_nr) + { +- if (seq_nr_before_or_eq(sequence_nr, node->seq_out[port->type])) ++ if (seq_nr_before_or_eq(sequence_nr, node->seq_out[port->type]) && ++ time_is_after_jiffies(node->time_out[port->type] + ++ msecs_to_jiffies(HSR_ENTRY_FORGET_TIME))) + return 1; + ++ node->time_out[port->type] = jiffies; + node->seq_out[port->type] = sequence_nr; + return 0; + } +diff --git a/net/hsr/hsr_framereg.h b/net/hsr/hsr_framereg.h +index 86b43f539f2cc..d9628e7a5f051 100644 +--- a/net/hsr/hsr_framereg.h ++++ b/net/hsr/hsr_framereg.h +@@ -75,6 +75,7 @@ struct hsr_node { + enum hsr_port_type addr_B_port; + unsigned long time_in[HSR_PT_PORTS]; + bool time_in_stale[HSR_PT_PORTS]; ++ unsigned long time_out[HSR_PT_PORTS]; + /* if the node is a SAN */ + bool san_a; + bool san_b; +diff --git a/net/hsr/hsr_main.h b/net/hsr/hsr_main.h +index a9c30a608e35d..80e976a8f28cd 100644 +--- a/net/hsr/hsr_main.h ++++ b/net/hsr/hsr_main.h +@@ -21,6 +21,7 @@ + #define HSR_LIFE_CHECK_INTERVAL 2000 /* ms */ + #define HSR_NODE_FORGET_TIME 60000 /* ms */ + #define HSR_ANNOUNCE_INTERVAL 100 /* ms */ ++#define HSR_ENTRY_FORGET_TIME 400 /* ms */ + + /* By how much may slave1 and slave2 timestamps of latest received frame from + * each node differ before we notify of communication problem? +diff --git a/net/iucv/af_iucv.c b/net/iucv/af_iucv.c +index 882f028992c38..427a1abce0a8a 100644 +--- a/net/iucv/af_iucv.c ++++ b/net/iucv/af_iucv.c +@@ -2036,7 +2036,6 @@ static int afiucv_hs_rcv(struct sk_buff *skb, struct net_device *dev, + char nullstring[8]; + + if (!pskb_may_pull(skb, sizeof(*trans_hdr))) { +- WARN_ONCE(1, "AF_IUCV failed to receive skb, len=%u", skb->len); + kfree_skb(skb); + return NET_RX_SUCCESS; + } +diff --git a/net/mptcp/options.c b/net/mptcp/options.c +index e0d21c0607e53..2e26e39169b82 100644 +--- a/net/mptcp/options.c ++++ b/net/mptcp/options.c +@@ -401,6 +401,7 @@ static void clear_3rdack_retransmission(struct sock *sk) + } + + static bool mptcp_established_options_mp(struct sock *sk, struct sk_buff *skb, ++ bool snd_data_fin_enable, + unsigned int *size, + unsigned int remaining, + struct mptcp_out_options *opts) +@@ -418,9 +419,10 @@ static bool mptcp_established_options_mp(struct sock *sk, struct sk_buff *skb, + if (!skb) + return false; + +- /* MPC/MPJ needed only on 3rd ack packet */ +- if (subflow->fully_established || +- subflow->snd_isn != TCP_SKB_CB(skb)->seq) ++ /* MPC/MPJ needed only on 3rd ack packet, DATA_FIN and TCP shutdown take precedence */ ++ if (subflow->fully_established || snd_data_fin_enable || ++ subflow->snd_isn != TCP_SKB_CB(skb)->seq || ++ sk->sk_state != TCP_ESTABLISHED) + return false; + + if (subflow->mp_capable) { +@@ -492,6 +494,7 @@ static void mptcp_write_data_fin(struct mptcp_subflow_context *subflow, + } + + static bool mptcp_established_options_dss(struct sock *sk, struct sk_buff *skb, ++ bool snd_data_fin_enable, + unsigned int *size, + unsigned int remaining, + struct mptcp_out_options *opts) +@@ -499,13 +502,11 @@ static bool mptcp_established_options_dss(struct sock *sk, struct sk_buff *skb, + struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk); + struct mptcp_sock *msk = mptcp_sk(subflow->conn); + unsigned int dss_size = 0; +- u64 snd_data_fin_enable; + struct mptcp_ext *mpext; + unsigned int ack_size; + bool ret = false; + + mpext = skb ? mptcp_get_ext(skb) : NULL; +- snd_data_fin_enable = mptcp_data_fin_enabled(msk); + + if (!skb || (mpext && mpext->use_map) || snd_data_fin_enable) { + unsigned int map_size; +@@ -683,12 +684,15 @@ bool mptcp_established_options(struct sock *sk, struct sk_buff *skb, + unsigned int *size, unsigned int remaining, + struct mptcp_out_options *opts) + { ++ struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk); ++ struct mptcp_sock *msk = mptcp_sk(subflow->conn); + unsigned int opt_size = 0; ++ bool snd_data_fin; + bool ret = false; + + opts->suboptions = 0; + +- if (unlikely(mptcp_check_fallback(sk))) ++ if (unlikely(__mptcp_check_fallback(msk))) + return false; + + /* prevent adding of any MPTCP related options on reset packet +@@ -697,10 +701,10 @@ bool mptcp_established_options(struct sock *sk, struct sk_buff *skb, + if (unlikely(skb && TCP_SKB_CB(skb)->tcp_flags & TCPHDR_RST)) + return false; + +- if (mptcp_established_options_mp(sk, skb, &opt_size, remaining, opts)) ++ snd_data_fin = mptcp_data_fin_enabled(msk); ++ if (mptcp_established_options_mp(sk, skb, snd_data_fin, &opt_size, remaining, opts)) + ret = true; +- else if (mptcp_established_options_dss(sk, skb, &opt_size, remaining, +- opts)) ++ else if (mptcp_established_options_dss(sk, skb, snd_data_fin, &opt_size, remaining, opts)) + ret = true; + + /* we reserved enough space for the above options, and exceeding the +diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c +index f998a077c7dd0..b51872b9dd619 100644 +--- a/net/mptcp/protocol.c ++++ b/net/mptcp/protocol.c +@@ -364,8 +364,6 @@ static void mptcp_check_data_fin_ack(struct sock *sk) + + /* Look for an acknowledged DATA_FIN */ + if (mptcp_pending_data_fin_ack(sk)) { +- mptcp_stop_timer(sk); +- + WRITE_ONCE(msk->snd_data_fin_enable, 0); + + switch (sk->sk_state) { +@@ -2299,6 +2297,7 @@ static void mptcp_worker(struct work_struct *work) + if (!test_and_clear_bit(MPTCP_WORK_RTX, &msk->flags)) + goto unlock; + ++ __mptcp_clean_una(sk); + dfrag = mptcp_rtx_head(sk); + if (!dfrag) + goto unlock; +diff --git a/net/mptcp/protocol.h b/net/mptcp/protocol.h +index d67de793d363f..d6ca1a5b94fc0 100644 +--- a/net/mptcp/protocol.h ++++ b/net/mptcp/protocol.h +@@ -325,20 +325,13 @@ static inline struct mptcp_data_frag *mptcp_pending_tail(const struct sock *sk) + return list_last_entry(&msk->rtx_queue, struct mptcp_data_frag, list); + } + +-static inline struct mptcp_data_frag *mptcp_rtx_tail(const struct sock *sk) ++static inline struct mptcp_data_frag *mptcp_rtx_head(const struct sock *sk) + { + struct mptcp_sock *msk = mptcp_sk(sk); + +- if (!before64(msk->snd_nxt, READ_ONCE(msk->snd_una))) ++ if (msk->snd_una == READ_ONCE(msk->snd_nxt)) + return NULL; + +- return list_last_entry(&msk->rtx_queue, struct mptcp_data_frag, list); +-} +- +-static inline struct mptcp_data_frag *mptcp_rtx_head(const struct sock *sk) +-{ +- struct mptcp_sock *msk = mptcp_sk(sk); +- + return list_first_entry_or_null(&msk->rtx_queue, struct mptcp_data_frag, list); + } + +diff --git a/net/mptcp/subflow.c b/net/mptcp/subflow.c +index 278cbe3e539ea..9d28f6e3dc49a 100644 +--- a/net/mptcp/subflow.c ++++ b/net/mptcp/subflow.c +@@ -1026,6 +1026,12 @@ static void subflow_data_ready(struct sock *sk) + + msk = mptcp_sk(parent); + if (state & TCPF_LISTEN) { ++ /* MPJ subflow are removed from accept queue before reaching here, ++ * avoid stray wakeups ++ */ ++ if (reqsk_queue_empty(&inet_csk(sk)->icsk_accept_queue)) ++ return; ++ + set_bit(MPTCP_DATA_READY, &msk->flags); + parent->sk_data_ready(parent); + return; +diff --git a/net/psample/psample.c b/net/psample/psample.c +index 33e238c965bd8..482c07f2766b1 100644 +--- a/net/psample/psample.c ++++ b/net/psample/psample.c +@@ -309,10 +309,10 @@ static int psample_tunnel_meta_len(struct ip_tunnel_info *tun_info) + unsigned short tun_proto = ip_tunnel_info_af(tun_info); + const struct ip_tunnel_key *tun_key = &tun_info->key; + int tun_opts_len = tun_info->options_len; +- int sum = 0; ++ int sum = nla_total_size(0); /* PSAMPLE_ATTR_TUNNEL */ + + if (tun_key->tun_flags & TUNNEL_KEY) +- sum += nla_total_size(sizeof(u64)); ++ sum += nla_total_size_64bit(sizeof(u64)); + + if (tun_info->mode & IP_TUNNEL_INFO_BRIDGE) + sum += nla_total_size(0); +diff --git a/net/sched/cls_flower.c b/net/sched/cls_flower.c +index 84f932532db7d..46c1b3e9f66a5 100644 +--- a/net/sched/cls_flower.c ++++ b/net/sched/cls_flower.c +@@ -30,6 +30,11 @@ + + #include <uapi/linux/netfilter/nf_conntrack_common.h> + ++#define TCA_FLOWER_KEY_CT_FLAGS_MAX \ ++ ((__TCA_FLOWER_KEY_CT_FLAGS_MAX - 1) << 1) ++#define TCA_FLOWER_KEY_CT_FLAGS_MASK \ ++ (TCA_FLOWER_KEY_CT_FLAGS_MAX - 1) ++ + struct fl_flow_key { + struct flow_dissector_key_meta meta; + struct flow_dissector_key_control control; +@@ -686,8 +691,10 @@ static const struct nla_policy fl_policy[TCA_FLOWER_MAX + 1] = { + [TCA_FLOWER_KEY_ENC_IP_TTL_MASK] = { .type = NLA_U8 }, + [TCA_FLOWER_KEY_ENC_OPTS] = { .type = NLA_NESTED }, + [TCA_FLOWER_KEY_ENC_OPTS_MASK] = { .type = NLA_NESTED }, +- [TCA_FLOWER_KEY_CT_STATE] = { .type = NLA_U16 }, +- [TCA_FLOWER_KEY_CT_STATE_MASK] = { .type = NLA_U16 }, ++ [TCA_FLOWER_KEY_CT_STATE] = ++ NLA_POLICY_MASK(NLA_U16, TCA_FLOWER_KEY_CT_FLAGS_MASK), ++ [TCA_FLOWER_KEY_CT_STATE_MASK] = ++ NLA_POLICY_MASK(NLA_U16, TCA_FLOWER_KEY_CT_FLAGS_MASK), + [TCA_FLOWER_KEY_CT_ZONE] = { .type = NLA_U16 }, + [TCA_FLOWER_KEY_CT_ZONE_MASK] = { .type = NLA_U16 }, + [TCA_FLOWER_KEY_CT_MARK] = { .type = NLA_U32 }, +@@ -1390,12 +1397,33 @@ static int fl_set_enc_opt(struct nlattr **tb, struct fl_flow_key *key, + return 0; + } + ++static int fl_validate_ct_state(u16 state, struct nlattr *tb, ++ struct netlink_ext_ack *extack) ++{ ++ if (state && !(state & TCA_FLOWER_KEY_CT_FLAGS_TRACKED)) { ++ NL_SET_ERR_MSG_ATTR(extack, tb, ++ "no trk, so no other flag can be set"); ++ return -EINVAL; ++ } ++ ++ if (state & TCA_FLOWER_KEY_CT_FLAGS_NEW && ++ state & TCA_FLOWER_KEY_CT_FLAGS_ESTABLISHED) { ++ NL_SET_ERR_MSG_ATTR(extack, tb, ++ "new and est are mutually exclusive"); ++ return -EINVAL; ++ } ++ ++ return 0; ++} ++ + static int fl_set_key_ct(struct nlattr **tb, + struct flow_dissector_key_ct *key, + struct flow_dissector_key_ct *mask, + struct netlink_ext_ack *extack) + { + if (tb[TCA_FLOWER_KEY_CT_STATE]) { ++ int err; ++ + if (!IS_ENABLED(CONFIG_NF_CONNTRACK)) { + NL_SET_ERR_MSG(extack, "Conntrack isn't enabled"); + return -EOPNOTSUPP; +@@ -1403,6 +1431,13 @@ static int fl_set_key_ct(struct nlattr **tb, + fl_set_key_val(tb, &key->ct_state, TCA_FLOWER_KEY_CT_STATE, + &mask->ct_state, TCA_FLOWER_KEY_CT_STATE_MASK, + sizeof(key->ct_state)); ++ ++ err = fl_validate_ct_state(mask->ct_state, ++ tb[TCA_FLOWER_KEY_CT_STATE_MASK], ++ extack); ++ if (err) ++ return err; ++ + } + if (tb[TCA_FLOWER_KEY_CT_ZONE]) { + if (!IS_ENABLED(CONFIG_NF_CONNTRACK_ZONES)) { +diff --git a/security/smack/smackfs.c b/security/smack/smackfs.c +index 5d44b7d258ef0..22ded2c26089c 100644 +--- a/security/smack/smackfs.c ++++ b/security/smack/smackfs.c +@@ -1167,7 +1167,7 @@ static ssize_t smk_write_net4addr(struct file *file, const char __user *buf, + return -EPERM; + if (*ppos != 0) + return -EINVAL; +- if (count < SMK_NETLBLADDRMIN) ++ if (count < SMK_NETLBLADDRMIN || count > PAGE_SIZE - 1) + return -EINVAL; + + data = memdup_user_nul(buf, count); +@@ -1427,7 +1427,7 @@ static ssize_t smk_write_net6addr(struct file *file, const char __user *buf, + return -EPERM; + if (*ppos != 0) + return -EINVAL; +- if (count < SMK_NETLBLADDRMIN) ++ if (count < SMK_NETLBLADDRMIN || count > PAGE_SIZE - 1) + return -EINVAL; + + data = memdup_user_nul(buf, count); +@@ -1834,6 +1834,10 @@ static ssize_t smk_write_ambient(struct file *file, const char __user *buf, + if (!smack_privileged(CAP_MAC_ADMIN)) + return -EPERM; + ++ /* Enough data must be present */ ++ if (count == 0 || count > PAGE_SIZE) ++ return -EINVAL; ++ + data = memdup_user_nul(buf, count); + if (IS_ERR(data)) + return PTR_ERR(data); +@@ -2005,6 +2009,9 @@ static ssize_t smk_write_onlycap(struct file *file, const char __user *buf, + if (!smack_privileged(CAP_MAC_ADMIN)) + return -EPERM; + ++ if (count > PAGE_SIZE) ++ return -EINVAL; ++ + data = memdup_user_nul(buf, count); + if (IS_ERR(data)) + return PTR_ERR(data); +@@ -2092,6 +2099,9 @@ static ssize_t smk_write_unconfined(struct file *file, const char __user *buf, + if (!smack_privileged(CAP_MAC_ADMIN)) + return -EPERM; + ++ if (count > PAGE_SIZE) ++ return -EINVAL; ++ + data = memdup_user_nul(buf, count); + if (IS_ERR(data)) + return PTR_ERR(data); +@@ -2648,6 +2658,10 @@ static ssize_t smk_write_syslog(struct file *file, const char __user *buf, + if (!smack_privileged(CAP_MAC_ADMIN)) + return -EPERM; + ++ /* Enough data must be present */ ++ if (count == 0 || count > PAGE_SIZE) ++ return -EINVAL; ++ + data = memdup_user_nul(buf, count); + if (IS_ERR(data)) + return PTR_ERR(data); +@@ -2740,10 +2754,13 @@ static ssize_t smk_write_relabel_self(struct file *file, const char __user *buf, + return -EPERM; + + /* ++ * No partial write. + * Enough data must be present. + */ + if (*ppos != 0) + return -EINVAL; ++ if (count == 0 || count > PAGE_SIZE) ++ return -EINVAL; + + data = memdup_user_nul(buf, count); + if (IS_ERR(data)) +diff --git a/security/tomoyo/file.c b/security/tomoyo/file.c +index 051f7297877cb..1e6077568fdec 100644 +--- a/security/tomoyo/file.c ++++ b/security/tomoyo/file.c +@@ -362,14 +362,14 @@ static bool tomoyo_merge_path_acl(struct tomoyo_acl_info *a, + { + u16 * const a_perm = &container_of(a, struct tomoyo_path_acl, head) + ->perm; +- u16 perm = *a_perm; ++ u16 perm = READ_ONCE(*a_perm); + const u16 b_perm = container_of(b, struct tomoyo_path_acl, head)->perm; + + if (is_delete) + perm &= ~b_perm; + else + perm |= b_perm; +- *a_perm = perm; ++ WRITE_ONCE(*a_perm, perm); + return !perm; + } + +@@ -437,7 +437,7 @@ static bool tomoyo_merge_mkdev_acl(struct tomoyo_acl_info *a, + { + u8 *const a_perm = &container_of(a, struct tomoyo_mkdev_acl, + head)->perm; +- u8 perm = *a_perm; ++ u8 perm = READ_ONCE(*a_perm); + const u8 b_perm = container_of(b, struct tomoyo_mkdev_acl, head) + ->perm; + +@@ -445,7 +445,7 @@ static bool tomoyo_merge_mkdev_acl(struct tomoyo_acl_info *a, + perm &= ~b_perm; + else + perm |= b_perm; +- *a_perm = perm; ++ WRITE_ONCE(*a_perm, perm); + return !perm; + } + +@@ -517,14 +517,14 @@ static bool tomoyo_merge_path2_acl(struct tomoyo_acl_info *a, + { + u8 * const a_perm = &container_of(a, struct tomoyo_path2_acl, head) + ->perm; +- u8 perm = *a_perm; ++ u8 perm = READ_ONCE(*a_perm); + const u8 b_perm = container_of(b, struct tomoyo_path2_acl, head)->perm; + + if (is_delete) + perm &= ~b_perm; + else + perm |= b_perm; +- *a_perm = perm; ++ WRITE_ONCE(*a_perm, perm); + return !perm; + } + +@@ -655,7 +655,7 @@ static bool tomoyo_merge_path_number_acl(struct tomoyo_acl_info *a, + { + u8 * const a_perm = &container_of(a, struct tomoyo_path_number_acl, + head)->perm; +- u8 perm = *a_perm; ++ u8 perm = READ_ONCE(*a_perm); + const u8 b_perm = container_of(b, struct tomoyo_path_number_acl, head) + ->perm; + +@@ -663,7 +663,7 @@ static bool tomoyo_merge_path_number_acl(struct tomoyo_acl_info *a, + perm &= ~b_perm; + else + perm |= b_perm; +- *a_perm = perm; ++ WRITE_ONCE(*a_perm, perm); + return !perm; + } + +diff --git a/security/tomoyo/network.c b/security/tomoyo/network.c +index f9ff121d7e1eb..a89ed55d85d41 100644 +--- a/security/tomoyo/network.c ++++ b/security/tomoyo/network.c +@@ -233,14 +233,14 @@ static bool tomoyo_merge_inet_acl(struct tomoyo_acl_info *a, + { + u8 * const a_perm = + &container_of(a, struct tomoyo_inet_acl, head)->perm; +- u8 perm = *a_perm; ++ u8 perm = READ_ONCE(*a_perm); + const u8 b_perm = container_of(b, struct tomoyo_inet_acl, head)->perm; + + if (is_delete) + perm &= ~b_perm; + else + perm |= b_perm; +- *a_perm = perm; ++ WRITE_ONCE(*a_perm, perm); + return !perm; + } + +@@ -259,14 +259,14 @@ static bool tomoyo_merge_unix_acl(struct tomoyo_acl_info *a, + { + u8 * const a_perm = + &container_of(a, struct tomoyo_unix_acl, head)->perm; +- u8 perm = *a_perm; ++ u8 perm = READ_ONCE(*a_perm); + const u8 b_perm = container_of(b, struct tomoyo_unix_acl, head)->perm; + + if (is_delete) + perm &= ~b_perm; + else + perm |= b_perm; +- *a_perm = perm; ++ WRITE_ONCE(*a_perm, perm); + return !perm; + } + +diff --git a/security/tomoyo/util.c b/security/tomoyo/util.c +index 176b803ebcfc9..e89cac913583c 100644 +--- a/security/tomoyo/util.c ++++ b/security/tomoyo/util.c +@@ -1058,30 +1058,30 @@ bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r) + + if (ptr->is_deleted) + continue; ++ /* ++ * Reading perm bitmap might race with tomoyo_merge_*() because ++ * caller does not hold tomoyo_policy_lock mutex. But exceeding ++ * max_learning_entry parameter by a few entries does not harm. ++ */ + switch (ptr->type) { + case TOMOYO_TYPE_PATH_ACL: +- perm = container_of(ptr, struct tomoyo_path_acl, head) +- ->perm; ++ data_race(perm = container_of(ptr, struct tomoyo_path_acl, head)->perm); + break; + case TOMOYO_TYPE_PATH2_ACL: +- perm = container_of(ptr, struct tomoyo_path2_acl, head) +- ->perm; ++ data_race(perm = container_of(ptr, struct tomoyo_path2_acl, head)->perm); + break; + case TOMOYO_TYPE_PATH_NUMBER_ACL: +- perm = container_of(ptr, struct tomoyo_path_number_acl, +- head)->perm; ++ data_race(perm = container_of(ptr, struct tomoyo_path_number_acl, head) ++ ->perm); + break; + case TOMOYO_TYPE_MKDEV_ACL: +- perm = container_of(ptr, struct tomoyo_mkdev_acl, +- head)->perm; ++ data_race(perm = container_of(ptr, struct tomoyo_mkdev_acl, head)->perm); + break; + case TOMOYO_TYPE_INET_ACL: +- perm = container_of(ptr, struct tomoyo_inet_acl, +- head)->perm; ++ data_race(perm = container_of(ptr, struct tomoyo_inet_acl, head)->perm); + break; + case TOMOYO_TYPE_UNIX_ACL: +- perm = container_of(ptr, struct tomoyo_unix_acl, +- head)->perm; ++ data_race(perm = container_of(ptr, struct tomoyo_unix_acl, head)->perm); + break; + case TOMOYO_TYPE_MANUAL_TASK_ACL: + perm = 0; +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index 1927605f0f7ed..5f4f8c2d760f0 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -2532,6 +2532,7 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { + SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD), ++ SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS), + SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), + SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3), + SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX), +@@ -6396,6 +6397,7 @@ enum { + ALC269_FIXUP_LEMOTE_A1802, + ALC269_FIXUP_LEMOTE_A190X, + ALC256_FIXUP_INTEL_NUC8_RUGGED, ++ ALC256_FIXUP_INTEL_NUC10, + ALC255_FIXUP_XIAOMI_HEADSET_MIC, + ALC274_FIXUP_HP_MIC, + ALC274_FIXUP_HP_HEADSET_MIC, +@@ -7782,6 +7784,15 @@ static const struct hda_fixup alc269_fixups[] = { + .chained = true, + .chain_id = ALC269_FIXUP_HEADSET_MODE + }, ++ [ALC256_FIXUP_INTEL_NUC10] = { ++ .type = HDA_FIXUP_PINS, ++ .v.pins = (const struct hda_pintbl[]) { ++ { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ ++ { } ++ }, ++ .chained = true, ++ .chain_id = ALC269_FIXUP_HEADSET_MODE ++ }, + [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = { + .type = HDA_FIXUP_VERBS, + .v.verbs = (const struct hda_verb[]) { +@@ -8128,6 +8139,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1558, 0x8551, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC), + SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC), ++ SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[5|7][0-9]RZ[Q]", ALC269_FIXUP_DMIC), + SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), +@@ -8222,6 +8234,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802), + SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X), + SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED), ++ SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10), + + #if 0 + /* Below is a quirk table taken from the old code. +diff --git a/sound/soc/intel/boards/bytcr_rt5640.c b/sound/soc/intel/boards/bytcr_rt5640.c +index 5520d7c800196..f00d4e417b6cf 100644 +--- a/sound/soc/intel/boards/bytcr_rt5640.c ++++ b/sound/soc/intel/boards/bytcr_rt5640.c +@@ -71,6 +71,7 @@ enum { + #define BYT_RT5640_SSP0_AIF2 BIT(21) + #define BYT_RT5640_MCLK_EN BIT(22) + #define BYT_RT5640_MCLK_25MHZ BIT(23) ++#define BYT_RT5640_NO_SPEAKERS BIT(24) + + #define BYTCR_INPUT_DEFAULTS \ + (BYT_RT5640_IN3_MAP | \ +@@ -132,6 +133,8 @@ static void log_quirks(struct device *dev) + dev_info(dev, "quirk JD_NOT_INV enabled\n"); + if (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER) + dev_info(dev, "quirk MONO_SPEAKER enabled\n"); ++ if (byt_rt5640_quirk & BYT_RT5640_NO_SPEAKERS) ++ dev_info(dev, "quirk NO_SPEAKERS enabled\n"); + if (byt_rt5640_quirk & BYT_RT5640_DIFF_MIC) + dev_info(dev, "quirk DIFF_MIC enabled\n"); + if (byt_rt5640_quirk & BYT_RT5640_SSP0_AIF1) { +@@ -399,6 +402,19 @@ static const struct dmi_system_id byt_rt5640_quirk_table[] = { + BYT_RT5640_SSP0_AIF1 | + BYT_RT5640_MCLK_EN), + }, ++ { /* Acer One 10 S1002 */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Acer"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "One S1002"), ++ }, ++ .driver_data = (void *)(BYT_RT5640_IN1_MAP | ++ BYT_RT5640_JD_SRC_JD2_IN4N | ++ BYT_RT5640_OVCD_TH_2000UA | ++ BYT_RT5640_OVCD_SF_0P75 | ++ BYT_RT5640_DIFF_MIC | ++ BYT_RT5640_SSP0_AIF2 | ++ BYT_RT5640_MCLK_EN), ++ }, + { + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), +@@ -524,6 +540,16 @@ static const struct dmi_system_id byt_rt5640_quirk_table[] = { + BYT_RT5640_MONO_SPEAKER | + BYT_RT5640_MCLK_EN), + }, ++ { /* Estar Beauty HD MID 7316R */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Estar"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "eSTAR BEAUTY HD Intel Quad core"), ++ }, ++ .driver_data = (void *)(BYTCR_INPUT_DEFAULTS | ++ BYT_RT5640_MONO_SPEAKER | ++ BYT_RT5640_SSP0_AIF1 | ++ BYT_RT5640_MCLK_EN), ++ }, + { + .matches = { + DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), +@@ -798,6 +824,20 @@ static const struct dmi_system_id byt_rt5640_quirk_table[] = { + BYT_RT5640_SSP0_AIF2 | + BYT_RT5640_MCLK_EN), + }, ++ { /* Voyo Winpad A15 */ ++ .matches = { ++ DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"), ++ DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"), ++ /* Above strings are too generic, also match on BIOS date */ ++ DMI_MATCH(DMI_BIOS_DATE, "11/20/2014"), ++ }, ++ .driver_data = (void *)(BYT_RT5640_IN1_MAP | ++ BYT_RT5640_JD_SRC_JD2_IN4N | ++ BYT_RT5640_OVCD_TH_2000UA | ++ BYT_RT5640_OVCD_SF_0P75 | ++ BYT_RT5640_DIFF_MIC | ++ BYT_RT5640_MCLK_EN), ++ }, + { /* Catch-all for generic Insyde tablets, must be last */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Insyde"), +@@ -946,7 +986,7 @@ static int byt_rt5640_init(struct snd_soc_pcm_runtime *runtime) + ret = snd_soc_dapm_add_routes(&card->dapm, + byt_rt5640_mono_spk_map, + ARRAY_SIZE(byt_rt5640_mono_spk_map)); +- } else { ++ } else if (!(byt_rt5640_quirk & BYT_RT5640_NO_SPEAKERS)) { + ret = snd_soc_dapm_add_routes(&card->dapm, + byt_rt5640_stereo_spk_map, + ARRAY_SIZE(byt_rt5640_stereo_spk_map)); +@@ -1188,6 +1228,7 @@ static int snd_byt_rt5640_mc_probe(struct platform_device *pdev) + { + struct device *dev = &pdev->dev; + static const char * const map_name[] = { "dmic1", "dmic2", "in1", "in3" }; ++ __maybe_unused const char *spk_type; + const struct dmi_system_id *dmi_id; + struct byt_rt5640_private *priv; + struct snd_soc_acpi_mach *mach; +@@ -1196,7 +1237,7 @@ static int snd_byt_rt5640_mc_probe(struct platform_device *pdev) + bool sof_parent; + int ret_val = 0; + int dai_index = 0; +- int i; ++ int i, cfg_spk; + + is_bytcr = false; + priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); +@@ -1335,16 +1376,24 @@ static int snd_byt_rt5640_mc_probe(struct platform_device *pdev) + } + } + ++ if (byt_rt5640_quirk & BYT_RT5640_NO_SPEAKERS) { ++ cfg_spk = 0; ++ spk_type = "none"; ++ } else if (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER) { ++ cfg_spk = 1; ++ spk_type = "mono"; ++ } else { ++ cfg_spk = 2; ++ spk_type = "stereo"; ++ } ++ + snprintf(byt_rt5640_components, sizeof(byt_rt5640_components), +- "cfg-spk:%s cfg-mic:%s", +- (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER) ? "1" : "2", ++ "cfg-spk:%d cfg-mic:%s", cfg_spk, + map_name[BYT_RT5640_MAP(byt_rt5640_quirk)]); + byt_rt5640_card.components = byt_rt5640_components; + #if !IS_ENABLED(CONFIG_SND_SOC_INTEL_USER_FRIENDLY_LONG_NAMES) + snprintf(byt_rt5640_long_name, sizeof(byt_rt5640_long_name), +- "bytcr-rt5640-%s-spk-%s-mic", +- (byt_rt5640_quirk & BYT_RT5640_MONO_SPEAKER) ? +- "mono" : "stereo", ++ "bytcr-rt5640-%s-spk-%s-mic", spk_type, + map_name[BYT_RT5640_MAP(byt_rt5640_quirk)]); + byt_rt5640_card.long_name = byt_rt5640_long_name; + #endif +diff --git a/sound/soc/intel/boards/bytcr_rt5651.c b/sound/soc/intel/boards/bytcr_rt5651.c +index f289ec8563a11..148b7b1bd3e8c 100644 +--- a/sound/soc/intel/boards/bytcr_rt5651.c ++++ b/sound/soc/intel/boards/bytcr_rt5651.c +@@ -435,6 +435,19 @@ static const struct dmi_system_id byt_rt5651_quirk_table[] = { + BYT_RT5651_SSP0_AIF1 | + BYT_RT5651_MONO_SPEAKER), + }, ++ { ++ /* Jumper EZpad 7 */ ++ .callback = byt_rt5651_quirk_cb, ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Jumper"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "EZpad"), ++ /* Jumper12x.WJ2012.bsBKRCP05 with the version dropped */ ++ DMI_MATCH(DMI_BIOS_VERSION, "Jumper12x.WJ2012.bsBKRCP"), ++ }, ++ .driver_data = (void *)(BYT_RT5651_DEFAULT_QUIRKS | ++ BYT_RT5651_IN2_MAP | ++ BYT_RT5651_JD_NOT_INV), ++ }, + { + /* KIANO SlimNote 14.2 */ + .callback = byt_rt5651_quirk_cb, +diff --git a/sound/soc/intel/boards/sof_sdw.c b/sound/soc/intel/boards/sof_sdw.c +index 152ea166eeaef..daca06dde99ba 100644 +--- a/sound/soc/intel/boards/sof_sdw.c ++++ b/sound/soc/intel/boards/sof_sdw.c +@@ -126,9 +126,10 @@ static const struct dmi_system_id sof_sdw_quirk_table[] = { + DMI_MATCH(DMI_PRODUCT_NAME, + "Tiger Lake Client Platform"), + }, +- .driver_data = (void *)(SOF_RT711_JD_SRC_JD1 | +- SOF_SDW_TGL_HDMI | SOF_SDW_PCH_DMIC | +- SOF_SSP_PORT(SOF_I2S_SSP2)), ++ .driver_data = (void *)(SOF_SDW_TGL_HDMI | ++ SOF_RT711_JD_SRC_JD1 | ++ SOF_SDW_PCH_DMIC | ++ SOF_SSP_PORT(SOF_I2S_SSP2)), + }, + { + .callback = sof_sdw_quirk_cb, +@@ -152,7 +153,8 @@ static const struct dmi_system_id sof_sdw_quirk_table[] = { + DMI_MATCH(DMI_SYS_VENDOR, "Google"), + DMI_MATCH(DMI_PRODUCT_NAME, "Volteer"), + }, +- .driver_data = (void *)(SOF_SDW_TGL_HDMI | SOF_SDW_PCH_DMIC | ++ .driver_data = (void *)(SOF_SDW_TGL_HDMI | ++ SOF_SDW_PCH_DMIC | + SOF_SDW_FOUR_SPK), + }, + { +@@ -161,7 +163,8 @@ static const struct dmi_system_id sof_sdw_quirk_table[] = { + DMI_MATCH(DMI_SYS_VENDOR, "Google"), + DMI_MATCH(DMI_PRODUCT_NAME, "Ripto"), + }, +- .driver_data = (void *)(SOF_SDW_TGL_HDMI | SOF_SDW_PCH_DMIC | ++ .driver_data = (void *)(SOF_SDW_TGL_HDMI | ++ SOF_SDW_PCH_DMIC | + SOF_SDW_FOUR_SPK), + }, + +@@ -933,7 +936,7 @@ static int sof_card_dai_links_create(struct device *dev, + ctx->idisp_codec = true; + + /* enable dmic01 & dmic16k */ +- dmic_num = (sof_sdw_quirk & SOF_SDW_PCH_DMIC) ? 2 : 0; ++ dmic_num = (sof_sdw_quirk & SOF_SDW_PCH_DMIC || mach_params->dmic_num) ? 2 : 0; + comp_num += dmic_num; + + dev_dbg(dev, "sdw %d, ssp %d, dmic %d, hdmi %d", sdw_be_num, ssp_num, +diff --git a/sound/soc/intel/common/soc-intel-quirks.h b/sound/soc/intel/common/soc-intel-quirks.h +index b07df3059926d..a93987ab7f4d7 100644 +--- a/sound/soc/intel/common/soc-intel-quirks.h ++++ b/sound/soc/intel/common/soc-intel-quirks.h +@@ -11,6 +11,7 @@ + + #if IS_ENABLED(CONFIG_X86) + ++#include <linux/dmi.h> + #include <asm/cpu_device_id.h> + #include <asm/intel-family.h> + #include <asm/iosf_mbi.h> +@@ -38,12 +39,36 @@ SOC_INTEL_IS_CPU(cml, KABYLAKE_L); + + static inline bool soc_intel_is_byt_cr(struct platform_device *pdev) + { ++ /* ++ * List of systems which: ++ * 1. Use a non CR version of the Bay Trail SoC ++ * 2. Contain at least 6 interrupt resources so that the ++ * platform_get_resource(pdev, IORESOURCE_IRQ, 5) check below ++ * succeeds ++ * 3. Despite 1. and 2. still have their IPC IRQ at index 0 rather then 5 ++ * ++ * This needs to be here so that it can be shared between the SST and ++ * SOF drivers. We rely on the compiler to optimize this out in files ++ * where soc_intel_is_byt_cr is not used. ++ */ ++ static const struct dmi_system_id force_bytcr_table[] = { ++ { /* Lenovo Yoga Tablet 2 series */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), ++ DMI_MATCH(DMI_PRODUCT_FAMILY, "YOGATablet2"), ++ }, ++ }, ++ {} ++ }; + struct device *dev = &pdev->dev; + int status = 0; + + if (!soc_intel_is_byt()) + return false; + ++ if (dmi_check_system(force_bytcr_table)) ++ return true; ++ + if (iosf_mbi_available()) { + u32 bios_status; + +diff --git a/sound/soc/qcom/lpass-cpu.c b/sound/soc/qcom/lpass-cpu.c +index 8e5415c9234f1..d55851d2049e2 100644 +--- a/sound/soc/qcom/lpass-cpu.c ++++ b/sound/soc/qcom/lpass-cpu.c +@@ -743,7 +743,6 @@ static void of_lpass_cpu_parse_dai_data(struct device *dev, + } + if (id == LPASS_DP_RX) { + data->hdmi_port_enable = 1; +- dev_err(dev, "HDMI Port is enabled: %d\n", id); + } else { + data->mi2s_playback_sd_mode[id] = + of_lpass_cpu_parse_sd_lines(dev, node, +diff --git a/sound/usb/implicit.c b/sound/usb/implicit.c +index bba54430e6d0b..11a85e66aa96d 100644 +--- a/sound/usb/implicit.c ++++ b/sound/usb/implicit.c +@@ -304,7 +304,8 @@ static int audioformat_implicit_fb_quirk(struct snd_usb_audio *chip, + /* Pioneer devices with vendor spec class */ + if (attr == USB_ENDPOINT_SYNC_ASYNC && + alts->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC && +- USB_ID_VENDOR(chip->usb_id) == 0x2b73 /* Pioneer */) { ++ (USB_ID_VENDOR(chip->usb_id) == 0x2b73 || /* Pioneer */ ++ USB_ID_VENDOR(chip->usb_id) == 0x08e4 /* Pioneer */)) { + if (skip_pioneer_sync_ep(chip, fmt, alts)) + return 1; + } +diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h +index c8a4bdf18207c..1165a5ac60f22 100644 +--- a/sound/usb/quirks-table.h ++++ b/sound/usb/quirks-table.h +@@ -3757,6 +3757,123 @@ AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"), + } + } + }, ++{ ++ /* ++ * Pioneer DJ DJM-750 ++ * 8 channels playback & 8 channels capture @ 44.1/48/96kHz S24LE ++ */ ++ USB_DEVICE_VENDOR_SPEC(0x08e4, 0x017f), ++ .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { ++ .ifnum = QUIRK_ANY_INTERFACE, ++ .type = QUIRK_COMPOSITE, ++ .data = (const struct snd_usb_audio_quirk[]) { ++ { ++ .ifnum = 0, ++ .type = QUIRK_AUDIO_FIXED_ENDPOINT, ++ .data = &(const struct audioformat) { ++ .formats = SNDRV_PCM_FMTBIT_S24_3LE, ++ .channels = 8, ++ .iface = 0, ++ .altsetting = 1, ++ .altset_idx = 1, ++ .endpoint = 0x05, ++ .ep_attr = USB_ENDPOINT_XFER_ISOC| ++ USB_ENDPOINT_SYNC_ASYNC, ++ .rates = SNDRV_PCM_RATE_44100| ++ SNDRV_PCM_RATE_48000| ++ SNDRV_PCM_RATE_96000, ++ .rate_min = 44100, ++ .rate_max = 96000, ++ .nr_rates = 3, ++ .rate_table = (unsigned int[]) { 44100, 48000, 96000 } ++ } ++ }, ++ { ++ .ifnum = 0, ++ .type = QUIRK_AUDIO_FIXED_ENDPOINT, ++ .data = &(const struct audioformat) { ++ .formats = SNDRV_PCM_FMTBIT_S24_3LE, ++ .channels = 8, ++ .iface = 0, ++ .altsetting = 1, ++ .altset_idx = 1, ++ .endpoint = 0x86, ++ .ep_idx = 1, ++ .ep_attr = USB_ENDPOINT_XFER_ISOC| ++ USB_ENDPOINT_SYNC_ASYNC| ++ USB_ENDPOINT_USAGE_IMPLICIT_FB, ++ .rates = SNDRV_PCM_RATE_44100| ++ SNDRV_PCM_RATE_48000| ++ SNDRV_PCM_RATE_96000, ++ .rate_min = 44100, ++ .rate_max = 96000, ++ .nr_rates = 3, ++ .rate_table = (unsigned int[]) { 44100, 48000, 96000 } ++ } ++ }, ++ { ++ .ifnum = -1 ++ } ++ } ++ } ++}, ++{ ++ /* ++ * Pioneer DJ DJM-450 ++ * PCM is 8 channels out @ 48 fixed (endpoint 0x01) ++ * and 8 channels in @ 48 fixed (endpoint 0x82). ++ */ ++ USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0013), ++ .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { ++ .ifnum = QUIRK_ANY_INTERFACE, ++ .type = QUIRK_COMPOSITE, ++ .data = (const struct snd_usb_audio_quirk[]) { ++ { ++ .ifnum = 0, ++ .type = QUIRK_AUDIO_FIXED_ENDPOINT, ++ .data = &(const struct audioformat) { ++ .formats = SNDRV_PCM_FMTBIT_S24_3LE, ++ .channels = 8, // outputs ++ .iface = 0, ++ .altsetting = 1, ++ .altset_idx = 1, ++ .endpoint = 0x01, ++ .ep_attr = USB_ENDPOINT_XFER_ISOC| ++ USB_ENDPOINT_SYNC_ASYNC, ++ .rates = SNDRV_PCM_RATE_48000, ++ .rate_min = 48000, ++ .rate_max = 48000, ++ .nr_rates = 1, ++ .rate_table = (unsigned int[]) { 48000 } ++ } ++ }, ++ { ++ .ifnum = 0, ++ .type = QUIRK_AUDIO_FIXED_ENDPOINT, ++ .data = &(const struct audioformat) { ++ .formats = SNDRV_PCM_FMTBIT_S24_3LE, ++ .channels = 8, // inputs ++ .iface = 0, ++ .altsetting = 1, ++ .altset_idx = 1, ++ .endpoint = 0x82, ++ .ep_idx = 1, ++ .ep_attr = USB_ENDPOINT_XFER_ISOC| ++ USB_ENDPOINT_SYNC_ASYNC| ++ USB_ENDPOINT_USAGE_IMPLICIT_FB, ++ .rates = SNDRV_PCM_RATE_48000, ++ .rate_min = 48000, ++ .rate_max = 48000, ++ .nr_rates = 1, ++ .rate_table = (unsigned int[]) { 48000 } ++ } ++ }, ++ { ++ .ifnum = -1 ++ } ++ } ++ } ++}, + + #undef USB_DEVICE_VENDOR_SPEC + #undef USB_AUDIO_DEVICE +diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c +index e196e364cef19..9ba4682ebc482 100644 +--- a/sound/usb/quirks.c ++++ b/sound/usb/quirks.c +@@ -1470,6 +1470,23 @@ static void set_format_emu_quirk(struct snd_usb_substream *subs, + subs->pkt_offset_adj = (emu_samplerate_id >= EMU_QUIRK_SR_176400HZ) ? 4 : 0; + } + ++static int pioneer_djm_set_format_quirk(struct snd_usb_substream *subs, ++ u16 windex) ++{ ++ unsigned int cur_rate = subs->data_endpoint->cur_rate; ++ u8 sr[3]; ++ // Convert to little endian ++ sr[0] = cur_rate & 0xff; ++ sr[1] = (cur_rate >> 8) & 0xff; ++ sr[2] = (cur_rate >> 16) & 0xff; ++ usb_set_interface(subs->dev, 0, 1); ++ // we should derive windex from fmt-sync_ep but it's not set ++ snd_usb_ctl_msg(subs->stream->chip->dev, ++ usb_rcvctrlpipe(subs->stream->chip->dev, 0), ++ 0x01, 0x22, 0x0100, windex, &sr, 0x0003); ++ return 0; ++} ++ + void snd_usb_set_format_quirk(struct snd_usb_substream *subs, + const struct audioformat *fmt) + { +@@ -1483,6 +1500,9 @@ void snd_usb_set_format_quirk(struct snd_usb_substream *subs, + case USB_ID(0x534d, 0x2109): /* MacroSilicon MS2109 */ + subs->stream_offset_adj = 2; + break; ++ case USB_ID(0x2b73, 0x0013): /* Pioneer DJM-450 */ ++ pioneer_djm_set_format_quirk(subs, 0x0082); ++ break; + } + } + +diff --git a/tools/testing/selftests/bpf/xdpxceiver.c b/tools/testing/selftests/bpf/xdpxceiver.c +index 1e722ee76b1fc..e7945b6246c82 100644 +--- a/tools/testing/selftests/bpf/xdpxceiver.c ++++ b/tools/testing/selftests/bpf/xdpxceiver.c +@@ -729,7 +729,6 @@ static void worker_pkt_validate(void) + u32 payloadseqnum = -2; + + while (1) { +- pkt_node_rx_q = malloc(sizeof(struct pkt)); + pkt_node_rx_q = TAILQ_LAST(&head, head_s); + if (!pkt_node_rx_q) + break; |