commit: b6cc76d171506ea5f54f296e60c2abad9a0ad920 Author: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> AuthorDate: Thu Feb 9 11:11:34 2017 +0000 Commit: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> CommitDate: Thu Feb 9 11:11:34 2017 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=b6cc76d1
Linux patch 4.9.9 0000_README | 4 + 1008_linux-4.9.9.patch | 2333 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2337 insertions(+) diff --git a/0000_README b/0000_README index c9cccee..3bab163 100644 --- a/0000_README +++ b/0000_README @@ -75,6 +75,10 @@ Patch: 1007_linux-4.9.8.patch From: http://www.kernel.org Desc: Linux 4.9.8 +Patch: 1008_linux-4.9.9.patch +From: http://www.kernel.org +Desc: Linux 4.9.9 + 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/1008_linux-4.9.9.patch b/1008_linux-4.9.9.patch new file mode 100644 index 0000000..393ec22 --- /dev/null +++ b/1008_linux-4.9.9.patch @@ -0,0 +1,2333 @@ +diff --git a/Makefile b/Makefile +index 1130803ab93c..c0c41c9fac0c 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 9 +-SUBLEVEL = 8 ++SUBLEVEL = 9 + EXTRAVERSION = + NAME = Roaring Lionus + +diff --git a/arch/arm64/crypto/aes-modes.S b/arch/arm64/crypto/aes-modes.S +index c53dbeae79f2..838dad5c209f 100644 +--- a/arch/arm64/crypto/aes-modes.S ++++ b/arch/arm64/crypto/aes-modes.S +@@ -193,15 +193,16 @@ AES_ENTRY(aes_cbc_encrypt) + cbz w6, .Lcbcencloop + + ld1 {v0.16b}, [x5] /* get iv */ +- enc_prepare w3, x2, x5 ++ enc_prepare w3, x2, x6 + + .Lcbcencloop: + ld1 {v1.16b}, [x1], #16 /* get next pt block */ + eor v0.16b, v0.16b, v1.16b /* ..and xor with iv */ +- encrypt_block v0, w3, x2, x5, w6 ++ encrypt_block v0, w3, x2, x6, w7 + st1 {v0.16b}, [x0], #16 + subs w4, w4, #1 + bne .Lcbcencloop ++ st1 {v0.16b}, [x5] /* return iv */ + ret + AES_ENDPROC(aes_cbc_encrypt) + +@@ -211,7 +212,7 @@ AES_ENTRY(aes_cbc_decrypt) + cbz w6, .LcbcdecloopNx + + ld1 {v7.16b}, [x5] /* get iv */ +- dec_prepare w3, x2, x5 ++ dec_prepare w3, x2, x6 + + .LcbcdecloopNx: + #if INTERLEAVE >= 2 +@@ -248,7 +249,7 @@ AES_ENTRY(aes_cbc_decrypt) + .Lcbcdecloop: + ld1 {v1.16b}, [x1], #16 /* get next ct block */ + mov v0.16b, v1.16b /* ...and copy to v0 */ +- decrypt_block v0, w3, x2, x5, w6 ++ decrypt_block v0, w3, x2, x6, w7 + eor v0.16b, v0.16b, v7.16b /* xor with iv => pt */ + mov v7.16b, v1.16b /* ct is next iv */ + st1 {v0.16b}, [x0], #16 +@@ -256,6 +257,7 @@ AES_ENTRY(aes_cbc_decrypt) + bne .Lcbcdecloop + .Lcbcdecout: + FRAME_POP ++ st1 {v7.16b}, [x5] /* return iv */ + ret + AES_ENDPROC(aes_cbc_decrypt) + +@@ -267,24 +269,15 @@ AES_ENDPROC(aes_cbc_decrypt) + + AES_ENTRY(aes_ctr_encrypt) + FRAME_PUSH +- cbnz w6, .Lctrfirst /* 1st time around? */ +- umov x5, v4.d[1] /* keep swabbed ctr in reg */ +- rev x5, x5 +-#if INTERLEAVE >= 2 +- cmn w5, w4 /* 32 bit overflow? */ +- bcs .Lctrinc +- add x5, x5, #1 /* increment BE ctr */ +- b .LctrincNx +-#else +- b .Lctrinc +-#endif +-.Lctrfirst: ++ cbz w6, .Lctrnotfirst /* 1st time around? */ + enc_prepare w3, x2, x6 + ld1 {v4.16b}, [x5] +- umov x5, v4.d[1] /* keep swabbed ctr in reg */ +- rev x5, x5 ++ ++.Lctrnotfirst: ++ umov x8, v4.d[1] /* keep swabbed ctr in reg */ ++ rev x8, x8 + #if INTERLEAVE >= 2 +- cmn w5, w4 /* 32 bit overflow? */ ++ cmn w8, w4 /* 32 bit overflow? */ + bcs .Lctrloop + .LctrloopNx: + subs w4, w4, #INTERLEAVE +@@ -292,11 +285,11 @@ AES_ENTRY(aes_ctr_encrypt) + #if INTERLEAVE == 2 + mov v0.8b, v4.8b + mov v1.8b, v4.8b +- rev x7, x5 +- add x5, x5, #1 ++ rev x7, x8 ++ add x8, x8, #1 + ins v0.d[1], x7 +- rev x7, x5 +- add x5, x5, #1 ++ rev x7, x8 ++ add x8, x8, #1 + ins v1.d[1], x7 + ld1 {v2.16b-v3.16b}, [x1], #32 /* get 2 input blocks */ + do_encrypt_block2x +@@ -305,7 +298,7 @@ AES_ENTRY(aes_ctr_encrypt) + st1 {v0.16b-v1.16b}, [x0], #32 + #else + ldr q8, =0x30000000200000001 /* addends 1,2,3[,0] */ +- dup v7.4s, w5 ++ dup v7.4s, w8 + mov v0.16b, v4.16b + add v7.4s, v7.4s, v8.4s + mov v1.16b, v4.16b +@@ -323,18 +316,12 @@ AES_ENTRY(aes_ctr_encrypt) + eor v2.16b, v7.16b, v2.16b + eor v3.16b, v5.16b, v3.16b + st1 {v0.16b-v3.16b}, [x0], #64 +- add x5, x5, #INTERLEAVE ++ add x8, x8, #INTERLEAVE + #endif +- cbz w4, .LctroutNx +-.LctrincNx: +- rev x7, x5 ++ rev x7, x8 + ins v4.d[1], x7 ++ cbz w4, .Lctrout + b .LctrloopNx +-.LctroutNx: +- sub x5, x5, #1 +- rev x7, x5 +- ins v4.d[1], x7 +- b .Lctrout + .Lctr1x: + adds w4, w4, #INTERLEAVE + beq .Lctrout +@@ -342,30 +329,39 @@ AES_ENTRY(aes_ctr_encrypt) + .Lctrloop: + mov v0.16b, v4.16b + encrypt_block v0, w3, x2, x6, w7 ++ ++ adds x8, x8, #1 /* increment BE ctr */ ++ rev x7, x8 ++ ins v4.d[1], x7 ++ bcs .Lctrcarry /* overflow? */ ++ ++.Lctrcarrydone: + subs w4, w4, #1 + bmi .Lctrhalfblock /* blocks < 0 means 1/2 block */ + ld1 {v3.16b}, [x1], #16 + eor v3.16b, v0.16b, v3.16b + st1 {v3.16b}, [x0], #16 +- beq .Lctrout +-.Lctrinc: +- adds x5, x5, #1 /* increment BE ctr */ +- rev x7, x5 +- ins v4.d[1], x7 +- bcc .Lctrloop /* no overflow? */ +- umov x7, v4.d[0] /* load upper word of ctr */ +- rev x7, x7 /* ... to handle the carry */ +- add x7, x7, #1 +- rev x7, x7 +- ins v4.d[0], x7 +- b .Lctrloop ++ bne .Lctrloop ++ ++.Lctrout: ++ st1 {v4.16b}, [x5] /* return next CTR value */ ++ FRAME_POP ++ ret ++ + .Lctrhalfblock: + ld1 {v3.8b}, [x1] + eor v3.8b, v0.8b, v3.8b + st1 {v3.8b}, [x0] +-.Lctrout: + FRAME_POP + ret ++ ++.Lctrcarry: ++ umov x7, v4.d[0] /* load upper word of ctr */ ++ rev x7, x7 /* ... to handle the carry */ ++ add x7, x7, #1 ++ rev x7, x7 ++ ins v4.d[0], x7 ++ b .Lctrcarrydone + AES_ENDPROC(aes_ctr_encrypt) + .ltorg + +diff --git a/arch/powerpc/include/asm/cpu_has_feature.h b/arch/powerpc/include/asm/cpu_has_feature.h +index b312b152461b..6e834caa3720 100644 +--- a/arch/powerpc/include/asm/cpu_has_feature.h ++++ b/arch/powerpc/include/asm/cpu_has_feature.h +@@ -23,7 +23,9 @@ static __always_inline bool cpu_has_feature(unsigned long feature) + { + int i; + ++#ifndef __clang__ /* clang can't cope with this */ + BUILD_BUG_ON(!__builtin_constant_p(feature)); ++#endif + + #ifdef CONFIG_JUMP_LABEL_FEATURE_CHECK_DEBUG + if (!static_key_initialized) { +diff --git a/arch/powerpc/include/asm/mmu.h b/arch/powerpc/include/asm/mmu.h +index e311c25751a4..a244e09d2d88 100644 +--- a/arch/powerpc/include/asm/mmu.h ++++ b/arch/powerpc/include/asm/mmu.h +@@ -160,7 +160,9 @@ static __always_inline bool mmu_has_feature(unsigned long feature) + { + int i; + ++#ifndef __clang__ /* clang can't cope with this */ + BUILD_BUG_ON(!__builtin_constant_p(feature)); ++#endif + + #ifdef CONFIG_JUMP_LABEL_FEATURE_CHECK_DEBUG + if (!static_key_initialized) { +diff --git a/arch/powerpc/kernel/eeh_driver.c b/arch/powerpc/kernel/eeh_driver.c +index 5c31369435f2..a5dd493670a0 100644 +--- a/arch/powerpc/kernel/eeh_driver.c ++++ b/arch/powerpc/kernel/eeh_driver.c +@@ -545,7 +545,7 @@ static void *eeh_pe_detach_dev(void *data, void *userdata) + static void *__eeh_clear_pe_frozen_state(void *data, void *flag) + { + struct eeh_pe *pe = (struct eeh_pe *)data; +- bool *clear_sw_state = flag; ++ bool clear_sw_state = *(bool *)flag; + int i, rc = 1; + + for (i = 0; rc && i < 3; i++) +diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c +index 88ac964f4858..1e8c57207346 100644 +--- a/arch/powerpc/kernel/prom_init.c ++++ b/arch/powerpc/kernel/prom_init.c +@@ -2747,6 +2747,9 @@ static void __init prom_find_boot_cpu(void) + + cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu); + ++ if (!PHANDLE_VALID(cpu_pkg)) ++ return; ++ + prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval)); + prom.cpu = be32_to_cpu(rval); + +diff --git a/arch/powerpc/mm/pgtable-radix.c b/arch/powerpc/mm/pgtable-radix.c +index ebb7f46f0532..9a25dce87875 100644 +--- a/arch/powerpc/mm/pgtable-radix.c ++++ b/arch/powerpc/mm/pgtable-radix.c +@@ -65,7 +65,7 @@ int radix__map_kernel_page(unsigned long ea, unsigned long pa, + if (!pmdp) + return -ENOMEM; + if (map_page_size == PMD_SIZE) { +- ptep = (pte_t *)pudp; ++ ptep = pmdp_ptep(pmdp); + goto set_the_pte; + } + ptep = pte_alloc_kernel(pmdp, ea); +@@ -90,7 +90,7 @@ int radix__map_kernel_page(unsigned long ea, unsigned long pa, + } + pmdp = pmd_offset(pudp, ea); + if (map_page_size == PMD_SIZE) { +- ptep = (pte_t *)pudp; ++ ptep = pmdp_ptep(pmdp); + goto set_the_pte; + } + if (!pmd_present(*pmdp)) { +diff --git a/arch/x86/events/intel/uncore.c b/arch/x86/events/intel/uncore.c +index dbaaf7dc8373..19d646a783fd 100644 +--- a/arch/x86/events/intel/uncore.c ++++ b/arch/x86/events/intel/uncore.c +@@ -763,30 +763,6 @@ static void uncore_pmu_unregister(struct intel_uncore_pmu *pmu) + pmu->registered = false; + } + +-static void __uncore_exit_boxes(struct intel_uncore_type *type, int cpu) +-{ +- struct intel_uncore_pmu *pmu = type->pmus; +- struct intel_uncore_box *box; +- int i, pkg; +- +- if (pmu) { +- pkg = topology_physical_package_id(cpu); +- for (i = 0; i < type->num_boxes; i++, pmu++) { +- box = pmu->boxes[pkg]; +- if (box) +- uncore_box_exit(box); +- } +- } +-} +- +-static void uncore_exit_boxes(void *dummy) +-{ +- struct intel_uncore_type **types; +- +- for (types = uncore_msr_uncores; *types; types++) +- __uncore_exit_boxes(*types++, smp_processor_id()); +-} +- + static void uncore_free_boxes(struct intel_uncore_pmu *pmu) + { + int pkg; +@@ -1077,22 +1053,12 @@ static int uncore_cpu_dying(unsigned int cpu) + return 0; + } + +-static int first_init; +- + static int uncore_cpu_starting(unsigned int cpu) + { + struct intel_uncore_type *type, **types = uncore_msr_uncores; + struct intel_uncore_pmu *pmu; + struct intel_uncore_box *box; +- int i, pkg, ncpus = 1; +- +- if (first_init) { +- /* +- * On init we get the number of online cpus in the package +- * and set refcount for all of them. +- */ +- ncpus = cpumask_weight(topology_core_cpumask(cpu)); +- } ++ int i, pkg; + + pkg = topology_logical_package_id(cpu); + for (; *types; types++) { +@@ -1103,7 +1069,7 @@ static int uncore_cpu_starting(unsigned int cpu) + if (!box) + continue; + /* The first cpu on a package activates the box */ +- if (atomic_add_return(ncpus, &box->refcnt) == ncpus) ++ if (atomic_inc_return(&box->refcnt) == 1) + uncore_box_init(box); + } + } +@@ -1407,19 +1373,17 @@ static int __init intel_uncore_init(void) + "PERF_X86_UNCORE_PREP", + uncore_cpu_prepare, NULL); + } +- first_init = 1; ++ + cpuhp_setup_state(CPUHP_AP_PERF_X86_UNCORE_STARTING, + "AP_PERF_X86_UNCORE_STARTING", + uncore_cpu_starting, uncore_cpu_dying); +- first_init = 0; ++ + cpuhp_setup_state(CPUHP_AP_PERF_X86_UNCORE_ONLINE, + "AP_PERF_X86_UNCORE_ONLINE", + uncore_event_cpu_online, uncore_event_cpu_offline); + return 0; + + err: +- /* Undo box->init_box() */ +- on_each_cpu_mask(&uncore_cpu_mask, uncore_exit_boxes, NULL, 1); + uncore_types_exit(uncore_msr_uncores); + uncore_pci_exit(); + return ret; +diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c +index 3d8ff40ecc6f..7249f1500bcb 100644 +--- a/arch/x86/kernel/apic/io_apic.c ++++ b/arch/x86/kernel/apic/io_apic.c +@@ -2118,6 +2118,7 @@ static inline void __init check_timer(void) + if (idx != -1 && irq_trigger(idx)) + unmask_ioapic_irq(irq_get_chip_data(0)); + } ++ irq_domain_deactivate_irq(irq_data); + irq_domain_activate_irq(irq_data); + if (timer_irq_works()) { + if (disable_timer_pin_1 > 0) +@@ -2139,6 +2140,7 @@ static inline void __init check_timer(void) + * legacy devices should be connected to IO APIC #0 + */ + replace_pin_at_irq_node(data, node, apic1, pin1, apic2, pin2); ++ irq_domain_deactivate_irq(irq_data); + irq_domain_activate_irq(irq_data); + legacy_pic->unmask(0); + if (timer_irq_works()) { +diff --git a/arch/x86/kernel/hpet.c b/arch/x86/kernel/hpet.c +index 274fab99169d..932348fbb6ea 100644 +--- a/arch/x86/kernel/hpet.c ++++ b/arch/x86/kernel/hpet.c +@@ -352,6 +352,7 @@ static int hpet_resume(struct clock_event_device *evt, int timer) + } else { + struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt); + ++ irq_domain_deactivate_irq(irq_get_irq_data(hdev->irq)); + irq_domain_activate_irq(irq_get_irq_data(hdev->irq)); + disable_irq(hdev->irq); + irq_set_affinity(hdev->irq, cpumask_of(hdev->cpu)); +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index 487b957e7802..731044efb195 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -3148,6 +3148,7 @@ static void fill_xsave(u8 *dest, struct kvm_vcpu *vcpu) + memcpy(dest, xsave, XSAVE_HDR_OFFSET); + + /* Set XSTATE_BV */ ++ xstate_bv &= vcpu->arch.guest_supported_xcr0 | XFEATURE_MASK_FPSSE; + *(u64 *)(dest + XSAVE_HDR_OFFSET) = xstate_bv; + + /* +diff --git a/arch/x86/platform/efi/efi_64.c b/arch/x86/platform/efi/efi_64.c +index 319148bd4b05..2f25a363068c 100644 +--- a/arch/x86/platform/efi/efi_64.c ++++ b/arch/x86/platform/efi/efi_64.c +@@ -269,6 +269,22 @@ int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages) + efi_scratch.use_pgd = true; + + /* ++ * Certain firmware versions are way too sentimential and still believe ++ * they are exclusive and unquestionable owners of the first physical page, ++ * even though they explicitly mark it as EFI_CONVENTIONAL_MEMORY ++ * (but then write-access it later during SetVirtualAddressMap()). ++ * ++ * Create a 1:1 mapping for this page, to avoid triple faults during early ++ * boot with such firmware. We are free to hand this page to the BIOS, ++ * as trim_bios_range() will reserve the first page and isolate it away ++ * from memory allocators anyway. ++ */ ++ if (kernel_map_pages_in_pgd(pgd, 0x0, 0x0, 1, _PAGE_RW)) { ++ pr_err("Failed to create 1:1 mapping for the first page!\n"); ++ return 1; ++ } ++ ++ /* + * When making calls to the firmware everything needs to be 1:1 + * mapped and addressable with 32-bit pointers. Map the kernel + * text and allocate a new stack because we can't rely on the +diff --git a/arch/xtensa/kernel/setup.c b/arch/xtensa/kernel/setup.c +index 88a044af7504..32cdc2c52e98 100644 +--- a/arch/xtensa/kernel/setup.c ++++ b/arch/xtensa/kernel/setup.c +@@ -540,7 +540,7 @@ subsys_initcall(topology_init); + + void cpu_reset(void) + { +-#if XCHAL_HAVE_PTP_MMU ++#if XCHAL_HAVE_PTP_MMU && IS_ENABLED(CONFIG_MMU) + local_irq_disable(); + /* + * We have full MMU: all autoload ways, ways 7, 8 and 9 of DTLB must +diff --git a/crypto/algapi.c b/crypto/algapi.c +index df939b54b09f..1fad2a6b3bbb 100644 +--- a/crypto/algapi.c ++++ b/crypto/algapi.c +@@ -356,6 +356,7 @@ int crypto_register_alg(struct crypto_alg *alg) + struct crypto_larval *larval; + int err; + ++ alg->cra_flags &= ~CRYPTO_ALG_DEAD; + err = crypto_check_alg(alg); + if (err) + return err; +diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c +index 223a770f78f3..33e363dcc63b 100644 +--- a/drivers/ata/libata-core.c ++++ b/drivers/ata/libata-core.c +@@ -1695,6 +1695,8 @@ unsigned ata_exec_internal_sg(struct ata_device *dev, + + if (qc->err_mask & ~AC_ERR_OTHER) + qc->err_mask &= ~AC_ERR_OTHER; ++ } else if (qc->tf.command == ATA_CMD_REQ_SENSE_DATA) { ++ qc->result_tf.command |= ATA_SENSE; + } + + /* finish up */ +@@ -4316,10 +4318,10 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = { + { "ST380013AS", "3.20", ATA_HORKAGE_MAX_SEC_1024 }, + + /* +- * Device times out with higher max sects. ++ * These devices time out with higher max sects. + * https://bugzilla.kernel.org/show_bug.cgi?id=121671 + */ +- { "LITEON CX1-JB256-HP", NULL, ATA_HORKAGE_MAX_SEC_1024 }, ++ { "LITEON CX1-JB*-HP", NULL, ATA_HORKAGE_MAX_SEC_1024 }, + + /* Devices we expect to fail diagnostics */ + +diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c +index 823e938c9a78..2f32782cea6d 100644 +--- a/drivers/ata/sata_mv.c ++++ b/drivers/ata/sata_mv.c +@@ -4132,6 +4132,9 @@ static int mv_platform_probe(struct platform_device *pdev) + host->iomap = NULL; + hpriv->base = devm_ioremap(&pdev->dev, res->start, + resource_size(res)); ++ if (!hpriv->base) ++ return -ENOMEM; ++ + hpriv->base -= SATAHC0_REG_BASE; + + hpriv->clk = clk_get(&pdev->dev, NULL); +diff --git a/drivers/base/memory.c b/drivers/base/memory.c +index e7f86a8887d2..c5cdd190b781 100644 +--- a/drivers/base/memory.c ++++ b/drivers/base/memory.c +@@ -391,33 +391,33 @@ static ssize_t show_valid_zones(struct device *dev, + { + struct memory_block *mem = to_memory_block(dev); + unsigned long start_pfn, end_pfn; ++ unsigned long valid_start, valid_end, valid_pages; + unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block; +- struct page *first_page; + struct zone *zone; + int zone_shift = 0; + + start_pfn = section_nr_to_pfn(mem->start_section_nr); + end_pfn = start_pfn + nr_pages; +- first_page = pfn_to_page(start_pfn); + + /* The block contains more than one zone can not be offlined. */ +- if (!test_pages_in_a_zone(start_pfn, end_pfn)) ++ if (!test_pages_in_a_zone(start_pfn, end_pfn, &valid_start, &valid_end)) + return sprintf(buf, "none\n"); + +- zone = page_zone(first_page); ++ zone = page_zone(pfn_to_page(valid_start)); ++ valid_pages = valid_end - valid_start; + + /* MMOP_ONLINE_KEEP */ + sprintf(buf, "%s", zone->name); + + /* MMOP_ONLINE_KERNEL */ +- zone_can_shift(start_pfn, nr_pages, ZONE_NORMAL, &zone_shift); ++ zone_can_shift(valid_start, valid_pages, ZONE_NORMAL, &zone_shift); + if (zone_shift) { + strcat(buf, " "); + strcat(buf, (zone + zone_shift)->name); + } + + /* MMOP_ONLINE_MOVABLE */ +- zone_can_shift(start_pfn, nr_pages, ZONE_MOVABLE, &zone_shift); ++ zone_can_shift(valid_start, valid_pages, ZONE_MOVABLE, &zone_shift); + if (zone_shift) { + strcat(buf, " "); + strcat(buf, (zone + zone_shift)->name); +diff --git a/drivers/bcma/bcma_private.h b/drivers/bcma/bcma_private.h +index f642c4264c27..168fa175d65a 100644 +--- a/drivers/bcma/bcma_private.h ++++ b/drivers/bcma/bcma_private.h +@@ -45,6 +45,9 @@ int bcma_sprom_get(struct bcma_bus *bus); + void bcma_core_chipcommon_early_init(struct bcma_drv_cc *cc); + void bcma_core_chipcommon_init(struct bcma_drv_cc *cc); + void bcma_chipco_bcm4331_ext_pa_lines_ctl(struct bcma_drv_cc *cc, bool enable); ++#ifdef CONFIG_BCMA_DRIVER_MIPS ++void bcma_chipco_serial_init(struct bcma_drv_cc *cc); ++#endif /* CONFIG_BCMA_DRIVER_MIPS */ + + /* driver_chipcommon_b.c */ + int bcma_core_chipcommon_b_init(struct bcma_drv_cc_b *ccb); +diff --git a/drivers/bcma/driver_chipcommon.c b/drivers/bcma/driver_chipcommon.c +index b4f6520e74f0..62f5bfa5065d 100644 +--- a/drivers/bcma/driver_chipcommon.c ++++ b/drivers/bcma/driver_chipcommon.c +@@ -15,8 +15,6 @@ + #include <linux/platform_device.h> + #include <linux/bcma/bcma.h> + +-static void bcma_chipco_serial_init(struct bcma_drv_cc *cc); +- + static inline u32 bcma_cc_write32_masked(struct bcma_drv_cc *cc, u16 offset, + u32 mask, u32 value) + { +@@ -186,9 +184,6 @@ void bcma_core_chipcommon_early_init(struct bcma_drv_cc *cc) + if (cc->capabilities & BCMA_CC_CAP_PMU) + bcma_pmu_early_init(cc); + +- if (IS_BUILTIN(CONFIG_BCM47XX) && bus->hosttype == BCMA_HOSTTYPE_SOC) +- bcma_chipco_serial_init(cc); +- + if (bus->hosttype == BCMA_HOSTTYPE_SOC) + bcma_core_chipcommon_flash_detect(cc); + +@@ -378,9 +373,9 @@ u32 bcma_chipco_gpio_pulldown(struct bcma_drv_cc *cc, u32 mask, u32 value) + return res; + } + +-static void bcma_chipco_serial_init(struct bcma_drv_cc *cc) ++#ifdef CONFIG_BCMA_DRIVER_MIPS ++void bcma_chipco_serial_init(struct bcma_drv_cc *cc) + { +-#if IS_BUILTIN(CONFIG_BCM47XX) + unsigned int irq; + u32 baud_base; + u32 i; +@@ -422,5 +417,5 @@ static void bcma_chipco_serial_init(struct bcma_drv_cc *cc) + ports[i].baud_base = baud_base; + ports[i].reg_shift = 0; + } +-#endif /* CONFIG_BCM47XX */ + } ++#endif /* CONFIG_BCMA_DRIVER_MIPS */ +diff --git a/drivers/bcma/driver_mips.c b/drivers/bcma/driver_mips.c +index 96f171328200..89af807cf29c 100644 +--- a/drivers/bcma/driver_mips.c ++++ b/drivers/bcma/driver_mips.c +@@ -278,9 +278,12 @@ static void bcma_core_mips_nvram_init(struct bcma_drv_mips *mcore) + + void bcma_core_mips_early_init(struct bcma_drv_mips *mcore) + { ++ struct bcma_bus *bus = mcore->core->bus; ++ + if (mcore->early_setup_done) + return; + ++ bcma_chipco_serial_init(&bus->drv_cc); + bcma_core_mips_nvram_init(mcore); + + mcore->early_setup_done = true; +diff --git a/drivers/dma/cppi41.c b/drivers/dma/cppi41.c +index d5ba43a87a68..55c1782e3623 100644 +--- a/drivers/dma/cppi41.c ++++ b/drivers/dma/cppi41.c +@@ -153,6 +153,8 @@ struct cppi41_dd { + + /* context for suspend/resume */ + unsigned int dma_tdfdq; ++ ++ bool is_suspended; + }; + + #define FIST_COMPLETION_QUEUE 93 +@@ -257,6 +259,10 @@ static struct cppi41_channel *desc_to_chan(struct cppi41_dd *cdd, u32 desc) + BUG_ON(desc_num >= ALLOC_DECS_NUM); + c = cdd->chan_busy[desc_num]; + cdd->chan_busy[desc_num] = NULL; ++ ++ /* Usecount for chan_busy[], paired with push_desc_queue() */ ++ pm_runtime_put(cdd->ddev.dev); ++ + return c; + } + +@@ -447,6 +453,15 @@ static void push_desc_queue(struct cppi41_channel *c) + */ + __iowmb(); + ++ /* ++ * DMA transfers can take at least 200ms to complete with USB mass ++ * storage connected. To prevent autosuspend timeouts, we must use ++ * pm_runtime_get/put() when chan_busy[] is modified. This will get ++ * cleared in desc_to_chan() or cppi41_stop_chan() depending on the ++ * outcome of the transfer. ++ */ ++ pm_runtime_get(cdd->ddev.dev); ++ + desc_phys = lower_32_bits(c->desc_phys); + desc_num = (desc_phys - cdd->descs_phys) / sizeof(struct cppi41_desc); + WARN_ON(cdd->chan_busy[desc_num]); +@@ -457,20 +472,26 @@ static void push_desc_queue(struct cppi41_channel *c) + cppi_writel(reg, cdd->qmgr_mem + QMGR_QUEUE_D(c->q_num)); + } + +-static void pending_desc(struct cppi41_channel *c) ++/* ++ * Caller must hold cdd->lock to prevent push_desc_queue() ++ * getting called out of order. We have both cppi41_dma_issue_pending() ++ * and cppi41_runtime_resume() call this function. ++ */ ++static void cppi41_run_queue(struct cppi41_dd *cdd) + { +- struct cppi41_dd *cdd = c->cdd; +- unsigned long flags; ++ struct cppi41_channel *c, *_c; + +- spin_lock_irqsave(&cdd->lock, flags); +- list_add_tail(&c->node, &cdd->pending); +- spin_unlock_irqrestore(&cdd->lock, flags); ++ list_for_each_entry_safe(c, _c, &cdd->pending, node) { ++ push_desc_queue(c); ++ list_del(&c->node); ++ } + } + + static void cppi41_dma_issue_pending(struct dma_chan *chan) + { + struct cppi41_channel *c = to_cpp41_chan(chan); + struct cppi41_dd *cdd = c->cdd; ++ unsigned long flags; + int error; + + error = pm_runtime_get(cdd->ddev.dev); +@@ -482,10 +503,11 @@ static void cppi41_dma_issue_pending(struct dma_chan *chan) + return; + } + +- if (likely(pm_runtime_active(cdd->ddev.dev))) +- push_desc_queue(c); +- else +- pending_desc(c); ++ spin_lock_irqsave(&cdd->lock, flags); ++ list_add_tail(&c->node, &cdd->pending); ++ if (!cdd->is_suspended) ++ cppi41_run_queue(cdd); ++ spin_unlock_irqrestore(&cdd->lock, flags); + + pm_runtime_mark_last_busy(cdd->ddev.dev); + pm_runtime_put_autosuspend(cdd->ddev.dev); +@@ -705,6 +727,9 @@ static int cppi41_stop_chan(struct dma_chan *chan) + WARN_ON(!cdd->chan_busy[desc_num]); + cdd->chan_busy[desc_num] = NULL; + ++ /* Usecount for chan_busy[], paired with push_desc_queue() */ ++ pm_runtime_put(cdd->ddev.dev); ++ + return 0; + } + +@@ -1150,8 +1175,12 @@ static int __maybe_unused cppi41_resume(struct device *dev) + static int __maybe_unused cppi41_runtime_suspend(struct device *dev) + { + struct cppi41_dd *cdd = dev_get_drvdata(dev); ++ unsigned long flags; + ++ spin_lock_irqsave(&cdd->lock, flags); ++ cdd->is_suspended = true; + WARN_ON(!list_empty(&cdd->pending)); ++ spin_unlock_irqrestore(&cdd->lock, flags); + + return 0; + } +@@ -1159,14 +1188,11 @@ static int __maybe_unused cppi41_runtime_suspend(struct device *dev) + static int __maybe_unused cppi41_runtime_resume(struct device *dev) + { + struct cppi41_dd *cdd = dev_get_drvdata(dev); +- struct cppi41_channel *c, *_c; + unsigned long flags; + + spin_lock_irqsave(&cdd->lock, flags); +- list_for_each_entry_safe(c, _c, &cdd->pending, node) { +- push_desc_queue(c); +- list_del(&c->node); +- } ++ cdd->is_suspended = false; ++ cppi41_run_queue(cdd); + spin_unlock_irqrestore(&cdd->lock, flags); + + return 0; +diff --git a/drivers/firmware/efi/libstub/fdt.c b/drivers/firmware/efi/libstub/fdt.c +index 921dfa047202..260c4b4b492e 100644 +--- a/drivers/firmware/efi/libstub/fdt.c ++++ b/drivers/firmware/efi/libstub/fdt.c +@@ -187,6 +187,7 @@ static efi_status_t update_fdt_memmap(void *fdt, struct efi_boot_memmap *map) + struct exit_boot_struct { + efi_memory_desc_t *runtime_map; + int *runtime_entry_count; ++ void *new_fdt_addr; + }; + + static efi_status_t exit_boot_func(efi_system_table_t *sys_table_arg, +@@ -202,7 +203,7 @@ static efi_status_t exit_boot_func(efi_system_table_t *sys_table_arg, + efi_get_virtmap(*map->map, *map->map_size, *map->desc_size, + p->runtime_map, p->runtime_entry_count); + +- return EFI_SUCCESS; ++ return update_fdt_memmap(p->new_fdt_addr, map); + } + + /* +@@ -300,22 +301,13 @@ efi_status_t allocate_new_fdt_and_exit_boot(efi_system_table_t *sys_table, + + priv.runtime_map = runtime_map; + priv.runtime_entry_count = &runtime_entry_count; ++ priv.new_fdt_addr = (void *)*new_fdt_addr; + status = efi_exit_boot_services(sys_table, handle, &map, &priv, + exit_boot_func); + + if (status == EFI_SUCCESS) { + efi_set_virtual_address_map_t *svam; + +- status = update_fdt_memmap((void *)*new_fdt_addr, &map); +- if (status != EFI_SUCCESS) { +- /* +- * The kernel won't get far without the memory map, but +- * may still be able to print something meaningful so +- * return success here. +- */ +- return EFI_SUCCESS; +- } +- + /* Install the new virtual address map */ + svam = sys_table->runtime->set_virtual_address_map; + status = svam(runtime_entry_count * desc_size, desc_size, +diff --git a/drivers/gpu/drm/amd/amdgpu/gmc_v6_0.c b/drivers/gpu/drm/amd/amdgpu/gmc_v6_0.c +index b13c8aaec078..6df924f72f29 100644 +--- a/drivers/gpu/drm/amd/amdgpu/gmc_v6_0.c ++++ b/drivers/gpu/drm/amd/amdgpu/gmc_v6_0.c +@@ -227,6 +227,9 @@ static void gmc_v6_0_mc_program(struct amdgpu_device *adev) + } + WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0); + ++ if (adev->mode_info.num_crtc) ++ amdgpu_display_set_vga_render_state(adev, false); ++ + gmc_v6_0_mc_stop(adev, &save); + + if (gmc_v6_0_wait_for_idle((void *)adev)) { +@@ -256,7 +259,6 @@ static void gmc_v6_0_mc_program(struct amdgpu_device *adev) + dev_warn(adev->dev, "Wait for MC idle timedout !\n"); + } + gmc_v6_0_mc_resume(adev, &save); +- amdgpu_display_set_vga_render_state(adev, false); + } + + static int gmc_v6_0_mc_init(struct amdgpu_device *adev) +diff --git a/drivers/gpu/drm/i915/intel_lrc.c b/drivers/gpu/drm/i915/intel_lrc.c +index 67db1577ee49..4147e51cf893 100644 +--- a/drivers/gpu/drm/i915/intel_lrc.c ++++ b/drivers/gpu/drm/i915/intel_lrc.c +@@ -2152,30 +2152,42 @@ static int execlists_context_deferred_alloc(struct i915_gem_context *ctx, + + void intel_lr_context_resume(struct drm_i915_private *dev_priv) + { +- struct i915_gem_context *ctx = dev_priv->kernel_context; + struct intel_engine_cs *engine; ++ struct i915_gem_context *ctx; ++ ++ /* Because we emit WA_TAIL_DWORDS there may be a disparity ++ * between our bookkeeping in ce->ring->head and ce->ring->tail and ++ * that stored in context. As we only write new commands from ++ * ce->ring->tail onwards, everything before that is junk. If the GPU ++ * starts reading from its RING_HEAD from the context, it may try to ++ * execute that junk and die. ++ * ++ * So to avoid that we reset the context images upon resume. For ++ * simplicity, we just zero everything out. ++ */ ++ list_for_each_entry(ctx, &dev_priv->context_list, link) { ++ for_each_engine(engine, dev_priv) { ++ struct intel_context *ce = &ctx->engine[engine->id]; ++ u32 *reg; + +- for_each_engine(engine, dev_priv) { +- struct intel_context *ce = &ctx->engine[engine->id]; +- void *vaddr; +- uint32_t *reg_state; +- +- if (!ce->state) +- continue; +- +- vaddr = i915_gem_object_pin_map(ce->state->obj, I915_MAP_WB); +- if (WARN_ON(IS_ERR(vaddr))) +- continue; ++ if (!ce->state) ++ continue; + +- reg_state = vaddr + LRC_STATE_PN * PAGE_SIZE; ++ reg = i915_gem_object_pin_map(ce->state->obj, ++ I915_MAP_WB); ++ if (WARN_ON(IS_ERR(reg))) ++ continue; + +- reg_state[CTX_RING_HEAD+1] = 0; +- reg_state[CTX_RING_TAIL+1] = 0; ++ reg += LRC_STATE_PN * PAGE_SIZE / sizeof(*reg); ++ reg[CTX_RING_HEAD+1] = 0; ++ reg[CTX_RING_TAIL+1] = 0; + +- ce->state->obj->dirty = true; +- i915_gem_object_unpin_map(ce->state->obj); ++ ce->state->obj->dirty = true; ++ i915_gem_object_unpin_map(ce->state->obj); + +- ce->ring->head = 0; +- ce->ring->tail = 0; ++ ce->ring->head = ce->ring->tail = 0; ++ ce->ring->last_retired_head = -1; ++ intel_ring_update_space(ce->ring); ++ } + } + } +diff --git a/drivers/gpu/drm/nouveau/dispnv04/hw.c b/drivers/gpu/drm/nouveau/dispnv04/hw.c +index 74856a8b8f35..e64f52464ecf 100644 +--- a/drivers/gpu/drm/nouveau/dispnv04/hw.c ++++ b/drivers/gpu/drm/nouveau/dispnv04/hw.c +@@ -222,6 +222,7 @@ nouveau_hw_get_clock(struct drm_device *dev, enum nvbios_pll_type plltype) + uint32_t mpllP; + + pci_read_config_dword(pci_get_bus_and_slot(0, 3), 0x6c, &mpllP); ++ mpllP = (mpllP >> 8) & 0xf; + if (!mpllP) + mpllP = 4; + +@@ -232,7 +233,7 @@ nouveau_hw_get_clock(struct drm_device *dev, enum nvbios_pll_type plltype) + uint32_t clock; + + pci_read_config_dword(pci_get_bus_and_slot(0, 5), 0x4c, &clock); +- return clock; ++ return clock / 1000; + } + + ret = nouveau_hw_get_pllvals(dev, plltype, &pllvals); +diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/disp/hdagt215.c b/drivers/gpu/drm/nouveau/nvkm/engine/disp/hdagt215.c +index 6f0436df0219..f8f2f16c22a2 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/engine/disp/hdagt215.c ++++ b/drivers/gpu/drm/nouveau/nvkm/engine/disp/hdagt215.c +@@ -59,7 +59,7 @@ gt215_hda_eld(NV50_DISP_MTHD_V1) + ); + } + for (i = 0; i < size; i++) +- nvkm_wr32(device, 0x61c440 + soff, (i << 8) | args->v0.data[0]); ++ nvkm_wr32(device, 0x61c440 + soff, (i << 8) | args->v0.data[i]); + for (; i < 0x60; i++) + nvkm_wr32(device, 0x61c440 + soff, (i << 8)); + nvkm_mask(device, 0x61c448 + soff, 0x80000003, 0x80000003); +diff --git a/drivers/hid/hid-cp2112.c b/drivers/hid/hid-cp2112.c +index 60d30203a5fa..e06c1344c913 100644 +--- a/drivers/hid/hid-cp2112.c ++++ b/drivers/hid/hid-cp2112.c +@@ -167,7 +167,7 @@ struct cp2112_device { + atomic_t xfer_avail; + struct gpio_chip gc; + u8 *in_out_buffer; +- spinlock_t lock; ++ struct mutex lock; + }; + + static int gpio_push_pull = 0xFF; +@@ -179,10 +179,9 @@ static int cp2112_gpio_direction_input(struct gpio_chip *chip, unsigned offset) + struct cp2112_device *dev = gpiochip_get_data(chip); + struct hid_device *hdev = dev->hdev; + u8 *buf = dev->in_out_buffer; +- unsigned long flags; + int ret; + +- spin_lock_irqsave(&dev->lock, flags); ++ mutex_lock(&dev->lock); + + ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf, + CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT, +@@ -206,8 +205,8 @@ static int cp2112_gpio_direction_input(struct gpio_chip *chip, unsigned offset) + ret = 0; + + exit: +- spin_unlock_irqrestore(&dev->lock, flags); +- return ret <= 0 ? ret : -EIO; ++ mutex_unlock(&dev->lock); ++ return ret < 0 ? ret : -EIO; + } + + static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value) +@@ -215,10 +214,9 @@ static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value) + struct cp2112_device *dev = gpiochip_get_data(chip); + struct hid_device *hdev = dev->hdev; + u8 *buf = dev->in_out_buffer; +- unsigned long flags; + int ret; + +- spin_lock_irqsave(&dev->lock, flags); ++ mutex_lock(&dev->lock); + + buf[0] = CP2112_GPIO_SET; + buf[1] = value ? 0xff : 0; +@@ -230,7 +228,7 @@ static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value) + if (ret < 0) + hid_err(hdev, "error setting GPIO values: %d\n", ret); + +- spin_unlock_irqrestore(&dev->lock, flags); ++ mutex_unlock(&dev->lock); + } + + static int cp2112_gpio_get(struct gpio_chip *chip, unsigned offset) +@@ -238,10 +236,9 @@ static int cp2112_gpio_get(struct gpio_chip *chip, unsigned offset) + struct cp2112_device *dev = gpiochip_get_data(chip); + struct hid_device *hdev = dev->hdev; + u8 *buf = dev->in_out_buffer; +- unsigned long flags; + int ret; + +- spin_lock_irqsave(&dev->lock, flags); ++ mutex_lock(&dev->lock); + + ret = hid_hw_raw_request(hdev, CP2112_GPIO_GET, buf, + CP2112_GPIO_GET_LENGTH, HID_FEATURE_REPORT, +@@ -255,7 +252,7 @@ static int cp2112_gpio_get(struct gpio_chip *chip, unsigned offset) + ret = (buf[1] >> offset) & 1; + + exit: +- spin_unlock_irqrestore(&dev->lock, flags); ++ mutex_unlock(&dev->lock); + + return ret; + } +@@ -266,10 +263,9 @@ static int cp2112_gpio_direction_output(struct gpio_chip *chip, + struct cp2112_device *dev = gpiochip_get_data(chip); + struct hid_device *hdev = dev->hdev; + u8 *buf = dev->in_out_buffer; +- unsigned long flags; + int ret; + +- spin_lock_irqsave(&dev->lock, flags); ++ mutex_lock(&dev->lock); + + ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf, + CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT, +@@ -290,7 +286,7 @@ static int cp2112_gpio_direction_output(struct gpio_chip *chip, + goto fail; + } + +- spin_unlock_irqrestore(&dev->lock, flags); ++ mutex_unlock(&dev->lock); + + /* + * Set gpio value when output direction is already set, +@@ -301,7 +297,7 @@ static int cp2112_gpio_direction_output(struct gpio_chip *chip, + return 0; + + fail: +- spin_unlock_irqrestore(&dev->lock, flags); ++ mutex_unlock(&dev->lock); + return ret < 0 ? ret : -EIO; + } + +@@ -1057,7 +1053,7 @@ static int cp2112_probe(struct hid_device *hdev, const struct hid_device_id *id) + if (!dev->in_out_buffer) + return -ENOMEM; + +- spin_lock_init(&dev->lock); ++ mutex_init(&dev->lock); + + ret = hid_parse(hdev); + if (ret) { +diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h +index 575aa65436d1..9845189fae92 100644 +--- a/drivers/hid/hid-ids.h ++++ b/drivers/hid/hid-ids.h +@@ -76,6 +76,9 @@ + #define USB_VENDOR_ID_ALPS_JP 0x044E + #define HID_DEVICE_ID_ALPS_U1_DUAL 0x120B + ++#define USB_VENDOR_ID_AMI 0x046b ++#define USB_DEVICE_ID_AMI_VIRT_KEYBOARD_AND_MOUSE 0xff10 ++ + #define USB_VENDOR_ID_ANTON 0x1130 + #define USB_DEVICE_ID_ANTON_TOUCH_PAD 0x3101 + +diff --git a/drivers/hid/hid-lg.c b/drivers/hid/hid-lg.c +index c5c5fbe9d605..52026dc94d5c 100644 +--- a/drivers/hid/hid-lg.c ++++ b/drivers/hid/hid-lg.c +@@ -872,7 +872,7 @@ static const struct hid_device_id lg_devices[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG), + .driver_data = LG_NOGET | LG_FF4 }, + { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2), +- .driver_data = LG_FF2 }, ++ .driver_data = LG_NOGET | LG_FF2 }, + { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940), + .driver_data = LG_FF3 }, + { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR), +diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c +index e6cfd323babc..cde060fefa91 100644 +--- a/drivers/hid/usbhid/hid-quirks.c ++++ b/drivers/hid/usbhid/hid-quirks.c +@@ -57,6 +57,7 @@ static const struct hid_blacklist { + { USB_VENDOR_ID_AIREN, USB_DEVICE_ID_AIREN_SLIMPLUS, HID_QUIRK_NOGET }, + { USB_VENDOR_ID_AKAI, USB_DEVICE_ID_AKAI_MPKMINI2, HID_QUIRK_NO_INIT_REPORTS }, + { USB_VENDOR_ID_AKAI_09E8, USB_DEVICE_ID_AKAI_09E8_MIDIMIX, HID_QUIRK_NO_INIT_REPORTS }, ++ { USB_VENDOR_ID_AMI, USB_DEVICE_ID_AMI_VIRT_KEYBOARD_AND_MOUSE, HID_QUIRK_ALWAYS_POLL }, + { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM, HID_QUIRK_NOGET }, + { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_CS124U, HID_QUIRK_NOGET }, + { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET }, +diff --git a/drivers/hid/wacom_wac.c b/drivers/hid/wacom_wac.c +index 1cb79925730d..623be90704ab 100644 +--- a/drivers/hid/wacom_wac.c ++++ b/drivers/hid/wacom_wac.c +@@ -164,19 +164,21 @@ static int wacom_pl_irq(struct wacom_wac *wacom) + wacom->id[0] = STYLUS_DEVICE_ID; + } + +- pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1)); +- if (features->pressure_max > 255) +- pressure = (pressure << 1) | ((data[4] >> 6) & 1); +- pressure += (features->pressure_max + 1) / 2; +- +- input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14)); +- input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14)); +- input_report_abs(input, ABS_PRESSURE, pressure); +- +- input_report_key(input, BTN_TOUCH, data[4] & 0x08); +- input_report_key(input, BTN_STYLUS, data[4] & 0x10); +- /* Only allow the stylus2 button to be reported for the pen tool. */ +- input_report_key(input, BTN_STYLUS2, (wacom->tool[0] == BTN_TOOL_PEN) && (data[4] & 0x20)); ++ if (prox) { ++ pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1)); ++ if (features->pressure_max > 255) ++ pressure = (pressure << 1) | ((data[4] >> 6) & 1); ++ pressure += (features->pressure_max + 1) / 2; ++ ++ input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14)); ++ input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14)); ++ input_report_abs(input, ABS_PRESSURE, pressure); ++ ++ input_report_key(input, BTN_TOUCH, data[4] & 0x08); ++ input_report_key(input, BTN_STYLUS, data[4] & 0x10); ++ /* Only allow the stylus2 button to be reported for the pen tool. */ ++ input_report_key(input, BTN_STYLUS2, (wacom->tool[0] == BTN_TOOL_PEN) && (data[4] & 0x20)); ++ } + + if (!prox) + wacom->id[0] = 0; +diff --git a/drivers/iio/adc/palmas_gpadc.c b/drivers/iio/adc/palmas_gpadc.c +index 2bbf0c521beb..7d61b566e148 100644 +--- a/drivers/iio/adc/palmas_gpadc.c ++++ b/drivers/iio/adc/palmas_gpadc.c +@@ -775,7 +775,7 @@ static int palmas_adc_wakeup_reset(struct palmas_gpadc *adc) + + static int palmas_gpadc_suspend(struct device *dev) + { +- struct iio_dev *indio_dev = dev_to_iio_dev(dev); ++ struct iio_dev *indio_dev = dev_get_drvdata(dev); + struct palmas_gpadc *adc = iio_priv(indio_dev); + int wakeup = adc->wakeup1_enable || adc->wakeup2_enable; + int ret; +@@ -798,7 +798,7 @@ static int palmas_gpadc_suspend(struct device *dev) + + static int palmas_gpadc_resume(struct device *dev) + { +- struct iio_dev *indio_dev = dev_to_iio_dev(dev); ++ struct iio_dev *indio_dev = dev_get_drvdata(dev); + struct palmas_gpadc *adc = iio_priv(indio_dev); + int wakeup = adc->wakeup1_enable || adc->wakeup2_enable; + int ret; +diff --git a/drivers/iio/health/afe4403.c b/drivers/iio/health/afe4403.c +index 9a081465c42f..6bb23a49e81e 100644 +--- a/drivers/iio/health/afe4403.c ++++ b/drivers/iio/health/afe4403.c +@@ -422,7 +422,7 @@ MODULE_DEVICE_TABLE(of, afe4403_of_match); + + static int __maybe_unused afe4403_suspend(struct device *dev) + { +- struct iio_dev *indio_dev = dev_to_iio_dev(dev); ++ struct iio_dev *indio_dev = spi_get_drvdata(to_spi_device(dev)); + struct afe4403_data *afe = iio_priv(indio_dev); + int ret; + +@@ -443,7 +443,7 @@ static int __maybe_unused afe4403_suspend(struct device *dev) + + static int __maybe_unused afe4403_resume(struct device *dev) + { +- struct iio_dev *indio_dev = dev_to_iio_dev(dev); ++ struct iio_dev *indio_dev = spi_get_drvdata(to_spi_device(dev)); + struct afe4403_data *afe = iio_priv(indio_dev); + int ret; + +diff --git a/drivers/iio/health/afe4404.c b/drivers/iio/health/afe4404.c +index 45266404f7e3..964f5231a831 100644 +--- a/drivers/iio/health/afe4404.c ++++ b/drivers/iio/health/afe4404.c +@@ -428,7 +428,7 @@ MODULE_DEVICE_TABLE(of, afe4404_of_match); + + static int __maybe_unused afe4404_suspend(struct device *dev) + { +- struct iio_dev *indio_dev = dev_to_iio_dev(dev); ++ struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); + struct afe4404_data *afe = iio_priv(indio_dev); + int ret; + +@@ -449,7 +449,7 @@ static int __maybe_unused afe4404_suspend(struct device *dev) + + static int __maybe_unused afe4404_resume(struct device *dev) + { +- struct iio_dev *indio_dev = dev_to_iio_dev(dev); ++ struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); + struct afe4404_data *afe = iio_priv(indio_dev); + int ret; + +diff --git a/drivers/iio/health/max30100.c b/drivers/iio/health/max30100.c +index 90ab8a2d2846..183c14329d6e 100644 +--- a/drivers/iio/health/max30100.c ++++ b/drivers/iio/health/max30100.c +@@ -238,7 +238,7 @@ static irqreturn_t max30100_interrupt_handler(int irq, void *private) + + mutex_lock(&data->lock); + +- while (cnt || (cnt = max30100_fifo_count(data) > 0)) { ++ while (cnt || (cnt = max30100_fifo_count(data)) > 0) { + ret = max30100_read_measurement(data); + if (ret) + break; +diff --git a/drivers/iio/humidity/dht11.c b/drivers/iio/humidity/dht11.c +index 9c47bc98f3ac..2a22ad920333 100644 +--- a/drivers/iio/humidity/dht11.c ++++ b/drivers/iio/humidity/dht11.c +@@ -71,7 +71,8 @@ + * a) select an implementation using busy loop polling on those systems + * b) use the checksum to do some probabilistic decoding + */ +-#define DHT11_START_TRANSMISSION 18 /* ms */ ++#define DHT11_START_TRANSMISSION_MIN 18000 /* us */ ++#define DHT11_START_TRANSMISSION_MAX 20000 /* us */ + #define DHT11_MIN_TIMERES 34000 /* ns */ + #define DHT11_THRESHOLD 49000 /* ns */ + #define DHT11_AMBIG_LOW 23000 /* ns */ +@@ -228,7 +229,8 @@ static int dht11_read_raw(struct iio_dev *iio_dev, + ret = gpio_direction_output(dht11->gpio, 0); + if (ret) + goto err; +- msleep(DHT11_START_TRANSMISSION); ++ usleep_range(DHT11_START_TRANSMISSION_MIN, ++ DHT11_START_TRANSMISSION_MAX); + ret = gpio_direction_input(dht11->gpio); + if (ret) + goto err; +diff --git a/drivers/infiniband/hw/cxgb4/qp.c b/drivers/infiniband/hw/cxgb4/qp.c +index bb0fde6e2047..cc2243f6cc7f 100644 +--- a/drivers/infiniband/hw/cxgb4/qp.c ++++ b/drivers/infiniband/hw/cxgb4/qp.c +@@ -321,7 +321,8 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq, + FW_RI_RES_WR_DCAEN_V(0) | + FW_RI_RES_WR_DCACPU_V(0) | + FW_RI_RES_WR_FBMIN_V(2) | +- FW_RI_RES_WR_FBMAX_V(2) | ++ (t4_sq_onchip(&wq->sq) ? FW_RI_RES_WR_FBMAX_V(2) : ++ FW_RI_RES_WR_FBMAX_V(3)) | + FW_RI_RES_WR_CIDXFTHRESHO_V(0) | + FW_RI_RES_WR_CIDXFTHRESH_V(0) | + FW_RI_RES_WR_EQSIZE_V(eqsize)); +@@ -345,7 +346,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq, + FW_RI_RES_WR_DCAEN_V(0) | + FW_RI_RES_WR_DCACPU_V(0) | + FW_RI_RES_WR_FBMIN_V(2) | +- FW_RI_RES_WR_FBMAX_V(2) | ++ FW_RI_RES_WR_FBMAX_V(3) | + FW_RI_RES_WR_CIDXFTHRESHO_V(0) | + FW_RI_RES_WR_CIDXFTHRESH_V(0) | + FW_RI_RES_WR_EQSIZE_V(eqsize)); +diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c +index e1e274a0a34f..ba637ff8aa7e 100644 +--- a/drivers/mmc/host/sdhci.c ++++ b/drivers/mmc/host/sdhci.c +@@ -2719,7 +2719,8 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id) + if (intmask & SDHCI_INT_RETUNE) + mmc_retune_needed(host->mmc); + +- if (intmask & SDHCI_INT_CARD_INT) { ++ if ((intmask & SDHCI_INT_CARD_INT) && ++ (host->ier & SDHCI_INT_CARD_INT)) { + sdhci_enable_sdio_irq_nolock(host, false); + host->thread_isr |= SDHCI_INT_CARD_INT; + result = IRQ_WAKE_THREAD; +diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-8000.c b/drivers/net/wireless/intel/iwlwifi/iwl-8000.c +index d02ca1491d16..8d3e53fac1da 100644 +--- a/drivers/net/wireless/intel/iwlwifi/iwl-8000.c ++++ b/drivers/net/wireless/intel/iwlwifi/iwl-8000.c +@@ -91,7 +91,7 @@ + + #define IWL8000_FW_PRE "iwlwifi-8000C-" + #define IWL8000_MODULE_FIRMWARE(api) \ +- IWL8000_FW_PRE "-" __stringify(api) ".ucode" ++ IWL8000_FW_PRE __stringify(api) ".ucode" + + #define IWL8265_FW_PRE "iwlwifi-8265-" + #define IWL8265_MODULE_FIRMWARE(api) \ +diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c +index fc771885e383..52de3c6d760c 100644 +--- a/drivers/net/wireless/intel/iwlwifi/mvm/sta.c ++++ b/drivers/net/wireless/intel/iwlwifi/mvm/sta.c +@@ -1144,9 +1144,10 @@ static void iwl_mvm_realloc_queues_after_restart(struct iwl_mvm *mvm, + .frame_limit = IWL_FRAME_LIMIT, + }; + +- /* Make sure reserved queue is still marked as such (or allocated) */ +- mvm->queue_info[mvm_sta->reserved_queue].status = +- IWL_MVM_QUEUE_RESERVED; ++ /* Make sure reserved queue is still marked as such (if allocated) */ ++ if (mvm_sta->reserved_queue != IEEE80211_INVAL_HW_QUEUE) ++ mvm->queue_info[mvm_sta->reserved_queue].status = ++ IWL_MVM_QUEUE_RESERVED; + + for (i = 0; i <= IWL_MAX_TID_COUNT; i++) { + struct iwl_mvm_tid_data *tid_data = &mvm_sta->tid_data[i]; +diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c +index 0ec649d961d7..b0916b126923 100644 +--- a/drivers/pci/pcie/aspm.c ++++ b/drivers/pci/pcie/aspm.c +@@ -518,25 +518,32 @@ static struct pcie_link_state *alloc_pcie_link_state(struct pci_dev *pdev) + link = kzalloc(sizeof(*link), GFP_KERNEL); + if (!link) + return NULL; ++ + INIT_LIST_HEAD(&link->sibling); + INIT_LIST_HEAD(&link->children); + INIT_LIST_HEAD(&link->link); + link->pdev = pdev; +- if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT) { ++ ++ /* ++ * Root Ports and PCI/PCI-X to PCIe Bridges are roots of PCIe ++ * hierarchies. ++ */ ++ if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT || ++ pci_pcie_type(pdev) == PCI_EXP_TYPE_PCIE_BRIDGE) { ++ link->root = link; ++ } else { + struct pcie_link_state *parent; ++ + parent = pdev->bus->parent->self->link_state; + if (!parent) { + kfree(link); + return NULL; + } ++ + link->parent = parent; ++ link->root = link->parent->root; + list_add(&link->link, &parent->children); + } +- /* Setup a pointer to the root port link */ +- if (!link->parent) +- link->root = link; +- else +- link->root = link->parent->root; + + list_add(&link->sibling, &link_list); + pdev->link_state = link; +diff --git a/drivers/pinctrl/intel/pinctrl-baytrail.c b/drivers/pinctrl/intel/pinctrl-baytrail.c +index 079015385fd8..583ae3f38fc0 100644 +--- a/drivers/pinctrl/intel/pinctrl-baytrail.c ++++ b/drivers/pinctrl/intel/pinctrl-baytrail.c +@@ -731,16 +731,23 @@ static void __iomem *byt_gpio_reg(struct byt_gpio *vg, unsigned int offset, + int reg) + { + struct byt_community *comm = byt_get_community(vg, offset); +- u32 reg_offset = 0; ++ u32 reg_offset; + + if (!comm) + return NULL; + + offset -= comm->pin_base; +- if (reg == BYT_INT_STAT_REG) ++ switch (reg) { ++ case BYT_INT_STAT_REG: + reg_offset = (offset / 32) * 4; +- else ++ break; ++ case BYT_DEBOUNCE_REG: ++ reg_offset = 0; ++ break; ++ default: + reg_offset = comm->pad_map[offset] * 16; ++ break; ++ } + + return comm->reg_base + reg_offset + reg; + } +@@ -1612,7 +1619,9 @@ static void byt_gpio_irq_handler(struct irq_desc *desc) + continue; + } + ++ raw_spin_lock(&vg->lock); + pending = readl(reg); ++ raw_spin_unlock(&vg->lock); + for_each_set_bit(pin, &pending, 32) { + virq = irq_find_mapping(vg->chip.irqdomain, base + pin); + generic_handle_irq(virq); +diff --git a/drivers/pinctrl/intel/pinctrl-merrifield.c b/drivers/pinctrl/intel/pinctrl-merrifield.c +index 7826c7f0cb7c..9931be6af0ca 100644 +--- a/drivers/pinctrl/intel/pinctrl-merrifield.c ++++ b/drivers/pinctrl/intel/pinctrl-merrifield.c +@@ -794,6 +794,9 @@ static int mrfld_config_set(struct pinctrl_dev *pctldev, unsigned int pin, + unsigned int i; + int ret; + ++ if (!mrfld_buf_available(mp, pin)) ++ return -ENOTSUPP; ++ + for (i = 0; i < nconfigs; i++) { + switch (pinconf_to_config_param(configs[i])) { + case PIN_CONFIG_BIAS_DISABLE: +diff --git a/drivers/regulator/axp20x-regulator.c b/drivers/regulator/axp20x-regulator.c +index e6a512ebeae2..a3ade9e4ef47 100644 +--- a/drivers/regulator/axp20x-regulator.c ++++ b/drivers/regulator/axp20x-regulator.c +@@ -272,7 +272,7 @@ static const struct regulator_desc axp806_regulators[] = { + 64, AXP806_DCDCD_V_CTRL, 0x3f, AXP806_PWR_OUT_CTRL1, + BIT(3)), + AXP_DESC(AXP806, DCDCE, "dcdce", "vine", 1100, 3400, 100, +- AXP806_DCDCB_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(4)), ++ AXP806_DCDCE_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(4)), + AXP_DESC(AXP806, ALDO1, "aldo1", "aldoin", 700, 3300, 100, + AXP806_ALDO1_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(5)), + AXP_DESC(AXP806, ALDO2, "aldo2", "aldoin", 700, 3400, 100, +diff --git a/drivers/staging/greybus/timesync_platform.c b/drivers/staging/greybus/timesync_platform.c +index 113f3d6c4b3a..27f75b17679b 100644 +--- a/drivers/staging/greybus/timesync_platform.c ++++ b/drivers/staging/greybus/timesync_platform.c +@@ -45,12 +45,18 @@ u32 gb_timesync_platform_get_clock_rate(void) + + int gb_timesync_platform_lock_bus(struct gb_timesync_svc *pdata) + { ++ if (!arche_platform_change_state_cb) ++ return 0; ++ + return arche_platform_change_state_cb(ARCHE_PLATFORM_STATE_TIME_SYNC, + pdata); + } + + void gb_timesync_platform_unlock_bus(void) + { ++ if (!arche_platform_change_state_cb) ++ return; ++ + arche_platform_change_state_cb(ARCHE_PLATFORM_STATE_ACTIVE, NULL); + } + +diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c +index d2e50a27140c..24f9f98968a5 100644 +--- a/drivers/usb/core/quirks.c ++++ b/drivers/usb/core/quirks.c +@@ -37,6 +37,10 @@ static const struct usb_device_id usb_quirk_list[] = { + /* CBM - Flash disk */ + { USB_DEVICE(0x0204, 0x6025), .driver_info = USB_QUIRK_RESET_RESUME }, + ++ /* WORLDE easy key (easykey.25) MIDI controller */ ++ { USB_DEVICE(0x0218, 0x0401), .driver_info = ++ USB_QUIRK_CONFIG_INTF_STRINGS }, ++ + /* HP 5300/5370C scanner */ + { USB_DEVICE(0x03f0, 0x0701), .driver_info = + USB_QUIRK_STRING_FETCH_255 }, +diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c +index 17989b72cdae..8d412d8b1f29 100644 +--- a/drivers/usb/gadget/function/f_fs.c ++++ b/drivers/usb/gadget/function/f_fs.c +@@ -2269,6 +2269,8 @@ static int __ffs_data_do_os_desc(enum ffs_os_desc_type type, + if (len < sizeof(*d) || h->interface >= ffs->interfaces_count) + return -EINVAL; + length = le32_to_cpu(d->dwSize); ++ if (len < length) ++ return -EINVAL; + type = le32_to_cpu(d->dwPropertyDataType); + if (type < USB_EXT_PROP_UNICODE || + type > USB_EXT_PROP_UNICODE_MULTI) { +@@ -2277,6 +2279,11 @@ static int __ffs_data_do_os_desc(enum ffs_os_desc_type type, + return -EINVAL; + } + pnl = le16_to_cpu(d->wPropertyNameLength); ++ if (length < 14 + pnl) { ++ pr_vdebug("invalid os descriptor length: %d pnl:%d (descriptor %d)\n", ++ length, pnl, type); ++ return -EINVAL; ++ } + pdl = le32_to_cpu(*(u32 *)((u8 *)data + 10 + pnl)); + if (length != 14 + pnl + pdl) { + pr_vdebug("invalid os descriptor length: %d pnl:%d pdl:%d (descriptor %d)\n", +@@ -2363,6 +2370,9 @@ static int __ffs_data_got_descs(struct ffs_data *ffs, + } + } + if (flags & (1 << i)) { ++ if (len < 4) { ++ goto error; ++ } + os_descs_count = get_unaligned_le32(data); + data += 4; + len -= 4; +@@ -2435,7 +2445,8 @@ static int __ffs_data_got_strings(struct ffs_data *ffs, + + ENTER(); + +- if (unlikely(get_unaligned_le32(data) != FUNCTIONFS_STRINGS_MAGIC || ++ if (unlikely(len < 16 || ++ get_unaligned_le32(data) != FUNCTIONFS_STRINGS_MAGIC || + get_unaligned_le32(data + 4) != len)) + goto error; + str_count = get_unaligned_le32(data + 8); +diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c +index c3e172e15ec3..338575fb2d27 100644 +--- a/drivers/usb/musb/musb_core.c ++++ b/drivers/usb/musb/musb_core.c +@@ -578,11 +578,11 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, + | MUSB_PORT_STAT_RESUME; + musb->rh_timer = jiffies + + msecs_to_jiffies(USB_RESUME_TIMEOUT); +- musb->need_finish_resume = 1; +- + musb->xceiv->otg->state = OTG_STATE_A_HOST; + musb->is_active = 1; + musb_host_resume_root_hub(musb); ++ schedule_delayed_work(&musb->finish_resume_work, ++ msecs_to_jiffies(USB_RESUME_TIMEOUT)); + break; + case OTG_STATE_B_WAIT_ACON: + musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL; +@@ -2691,11 +2691,6 @@ static int musb_resume(struct device *dev) + mask = MUSB_DEVCTL_BDEVICE | MUSB_DEVCTL_FSDEV | MUSB_DEVCTL_LSDEV; + if ((devctl & mask) != (musb->context.devctl & mask)) + musb->port1_status = 0; +- if (musb->need_finish_resume) { +- musb->need_finish_resume = 0; +- schedule_delayed_work(&musb->finish_resume_work, +- msecs_to_jiffies(USB_RESUME_TIMEOUT)); +- } + + /* + * The USB HUB code expects the device to be in RPM_ACTIVE once it came +@@ -2747,12 +2742,6 @@ static int musb_runtime_resume(struct device *dev) + + musb_restore_context(musb); + +- if (musb->need_finish_resume) { +- musb->need_finish_resume = 0; +- schedule_delayed_work(&musb->finish_resume_work, +- msecs_to_jiffies(USB_RESUME_TIMEOUT)); +- } +- + spin_lock_irqsave(&musb->lock, flags); + error = musb_run_resume_work(musb); + if (error) +diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h +index 47331dbdde29..854fbf7b6b23 100644 +--- a/drivers/usb/musb/musb_core.h ++++ b/drivers/usb/musb/musb_core.h +@@ -410,7 +410,6 @@ struct musb { + + /* is_suspended means USB B_PERIPHERAL suspend */ + unsigned is_suspended:1; +- unsigned need_finish_resume :1; + + /* may_wakeup means remote wakeup is enabled */ + unsigned may_wakeup:1; +diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c +index 7ce31a4c7e7f..42cc72e54c05 100644 +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -2007,6 +2007,7 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_WMD200, 0xff, 0xff, 0xff) }, + { USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_6802, 0xff, 0xff, 0xff) }, + { USB_DEVICE_AND_INTERFACE_INFO(WETELECOM_VENDOR_ID, WETELECOM_PRODUCT_WMD300, 0xff, 0xff, 0xff) }, ++ { USB_DEVICE_AND_INTERFACE_INFO(0x03f0, 0x421d, 0xff, 0xff, 0xff) }, /* HP lt2523 (Novatel E371) */ + { } /* Terminating entry */ + }; + MODULE_DEVICE_TABLE(usb, option_ids); +diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c +index 46fca6b75846..1db4b61bdf7b 100644 +--- a/drivers/usb/serial/pl2303.c ++++ b/drivers/usb/serial/pl2303.c +@@ -49,6 +49,7 @@ static const struct usb_device_id id_table[] = { + { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) }, + { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) }, + { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) }, ++ { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) }, + { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) }, + { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) }, + { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) }, +diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h +index e3b7af8adfb7..09d9be88209e 100644 +--- a/drivers/usb/serial/pl2303.h ++++ b/drivers/usb/serial/pl2303.h +@@ -27,6 +27,7 @@ + #define ATEN_VENDOR_ID 0x0557 + #define ATEN_VENDOR_ID2 0x0547 + #define ATEN_PRODUCT_ID 0x2008 ++#define ATEN_PRODUCT_ID2 0x2118 + + #define IODATA_VENDOR_ID 0x04bb + #define IODATA_PRODUCT_ID 0x0a03 +diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c +index 1bc6089b9008..696458db7e3c 100644 +--- a/drivers/usb/serial/qcserial.c ++++ b/drivers/usb/serial/qcserial.c +@@ -124,6 +124,7 @@ static const struct usb_device_id id_table[] = { + {USB_DEVICE(0x1410, 0xa021)}, /* Novatel Gobi 3000 Composite */ + {USB_DEVICE(0x413c, 0x8193)}, /* Dell Gobi 3000 QDL */ + {USB_DEVICE(0x413c, 0x8194)}, /* Dell Gobi 3000 Composite */ ++ {USB_DEVICE(0x413c, 0x81a6)}, /* Dell DW5570 QDL (MC8805) */ + {USB_DEVICE(0x1199, 0x68a4)}, /* Sierra Wireless QDL */ + {USB_DEVICE(0x1199, 0x68a5)}, /* Sierra Wireless Modem */ + {USB_DEVICE(0x1199, 0x68a8)}, /* Sierra Wireless QDL */ +diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c +index c6f2d89c0e97..64613fbf5cf8 100644 +--- a/drivers/vhost/vhost.c ++++ b/drivers/vhost/vhost.c +@@ -130,14 +130,14 @@ static long vhost_get_vring_endian(struct vhost_virtqueue *vq, u32 idx, + + static void vhost_init_is_le(struct vhost_virtqueue *vq) + { +- if (vhost_has_feature(vq, VIRTIO_F_VERSION_1)) +- vq->is_le = true; ++ vq->is_le = vhost_has_feature(vq, VIRTIO_F_VERSION_1) ++ || virtio_legacy_is_little_endian(); + } + #endif /* CONFIG_VHOST_CROSS_ENDIAN_LEGACY */ + + static void vhost_reset_is_le(struct vhost_virtqueue *vq) + { +- vq->is_le = virtio_legacy_is_little_endian(); ++ vhost_init_is_le(vq); + } + + struct vhost_flush_struct { +@@ -1713,10 +1713,8 @@ int vhost_vq_init_access(struct vhost_virtqueue *vq) + int r; + bool is_le = vq->is_le; + +- if (!vq->private_data) { +- vhost_reset_is_le(vq); ++ if (!vq->private_data) + return 0; +- } + + vhost_init_is_le(vq); + +diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c +index f1360487a594..489bfc61cf30 100644 +--- a/drivers/virtio/virtio_ring.c ++++ b/drivers/virtio/virtio_ring.c +@@ -159,13 +159,6 @@ static bool vring_use_dma_api(struct virtio_device *vdev) + if (xen_domain()) + return true; + +- /* +- * On ARM-based machines, the DMA ops will do the right thing, +- * so always use them with legacy devices. +- */ +- if (IS_ENABLED(CONFIG_ARM) || IS_ENABLED(CONFIG_ARM64)) +- return !virtio_has_feature(vdev, VIRTIO_F_VERSION_1); +- + return false; + } + +diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c +index 8f6a2a5863b9..a27fc8791551 100644 +--- a/fs/cifs/readdir.c ++++ b/fs/cifs/readdir.c +@@ -285,6 +285,7 @@ initiate_cifs_search(const unsigned int xid, struct file *file) + rc = -ENOMEM; + goto error_exit; + } ++ spin_lock_init(&cifsFile->file_info_lock); + file->private_data = cifsFile; + cifsFile->tlink = cifs_get_tlink(tlink); + tcon = tlink_tcon(tlink); +diff --git a/fs/dax.c b/fs/dax.c +index 014defd2e744..bf6218da7928 100644 +--- a/fs/dax.c ++++ b/fs/dax.c +@@ -1270,6 +1270,11 @@ iomap_dax_actor(struct inode *inode, loff_t pos, loff_t length, void *data, + struct blk_dax_ctl dax = { 0 }; + ssize_t map_len; + ++ if (fatal_signal_pending(current)) { ++ ret = -EINTR; ++ break; ++ } ++ + dax.sector = iomap->blkno + + (((pos & PAGE_MASK) - iomap->offset) >> 9); + dax.size = (length + offset + PAGE_SIZE - 1) & PAGE_MASK; +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index 478630af0d19..bbc316db9495 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -3827,6 +3827,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) + (EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb))); + db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) / + EXT4_DESC_PER_BLOCK(sb); ++ if (ext4_has_feature_meta_bg(sb)) { ++ if (le32_to_cpu(es->s_first_meta_bg) >= db_count) { ++ ext4_msg(sb, KERN_WARNING, ++ "first meta block group too large: %u " ++ "(group descriptor block count %u)", ++ le32_to_cpu(es->s_first_meta_bg), db_count); ++ goto failed_mount; ++ } ++ } + sbi->s_group_desc = ext4_kvmalloc(db_count * + sizeof(struct buffer_head *), + GFP_KERNEL); +diff --git a/fs/iomap.c b/fs/iomap.c +index a8ee8c33ca78..814ae8f9587d 100644 +--- a/fs/iomap.c ++++ b/fs/iomap.c +@@ -113,6 +113,9 @@ iomap_write_begin(struct inode *inode, loff_t pos, unsigned len, unsigned flags, + + BUG_ON(pos + len > iomap->offset + iomap->length); + ++ if (fatal_signal_pending(current)) ++ return -EINTR; ++ + page = grab_cache_page_write_begin(inode->i_mapping, index, flags); + if (!page) + return -ENOMEM; +diff --git a/fs/nfsd/nfs4layouts.c b/fs/nfsd/nfs4layouts.c +index 42aace4fc4c8..64813697f4c4 100644 +--- a/fs/nfsd/nfs4layouts.c ++++ b/fs/nfsd/nfs4layouts.c +@@ -223,10 +223,11 @@ nfsd4_alloc_layout_stateid(struct nfsd4_compound_state *cstate, + struct nfs4_layout_stateid *ls; + struct nfs4_stid *stp; + +- stp = nfs4_alloc_stid(cstate->clp, nfs4_layout_stateid_cache); ++ stp = nfs4_alloc_stid(cstate->clp, nfs4_layout_stateid_cache, ++ nfsd4_free_layout_stateid); + if (!stp) + return NULL; +- stp->sc_free = nfsd4_free_layout_stateid; ++ + get_nfs4_file(fp); + stp->sc_file = fp; + +diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c +index 4b4beaaa4eaa..a0dee8ae9f97 100644 +--- a/fs/nfsd/nfs4state.c ++++ b/fs/nfsd/nfs4state.c +@@ -633,8 +633,8 @@ find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new) + return co; + } + +-struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, +- struct kmem_cache *slab) ++struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab, ++ void (*sc_free)(struct nfs4_stid *)) + { + struct nfs4_stid *stid; + int new_id; +@@ -650,6 +650,8 @@ struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, + idr_preload_end(); + if (new_id < 0) + goto out_free; ++ ++ stid->sc_free = sc_free; + stid->sc_client = cl; + stid->sc_stateid.si_opaque.so_id = new_id; + stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid; +@@ -675,15 +677,12 @@ struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, + static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp) + { + struct nfs4_stid *stid; +- struct nfs4_ol_stateid *stp; + +- stid = nfs4_alloc_stid(clp, stateid_slab); ++ stid = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_ol_stateid); + if (!stid) + return NULL; + +- stp = openlockstateid(stid); +- stp->st_stid.sc_free = nfs4_free_ol_stateid; +- return stp; ++ return openlockstateid(stid); + } + + static void nfs4_free_deleg(struct nfs4_stid *stid) +@@ -781,11 +780,10 @@ alloc_init_deleg(struct nfs4_client *clp, struct svc_fh *current_fh, + goto out_dec; + if (delegation_blocked(¤t_fh->fh_handle)) + goto out_dec; +- dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab)); ++ dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab, nfs4_free_deleg)); + if (dp == NULL) + goto out_dec; + +- dp->dl_stid.sc_free = nfs4_free_deleg; + /* + * delegation seqid's are never incremented. The 4.1 special + * meaning of seqid 0 isn't meaningful, really, but let's avoid +@@ -5580,7 +5578,6 @@ init_lock_stateid(struct nfs4_ol_stateid *stp, struct nfs4_lockowner *lo, + stp->st_stateowner = nfs4_get_stateowner(&lo->lo_owner); + get_nfs4_file(fp); + stp->st_stid.sc_file = fp; +- stp->st_stid.sc_free = nfs4_free_lock_stateid; + stp->st_access_bmap = 0; + stp->st_deny_bmap = open_stp->st_deny_bmap; + stp->st_openstp = open_stp; +@@ -5623,7 +5620,7 @@ find_or_create_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fi, + lst = find_lock_stateid(lo, fi); + if (lst == NULL) { + spin_unlock(&clp->cl_lock); +- ns = nfs4_alloc_stid(clp, stateid_slab); ++ ns = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_lock_stateid); + if (ns == NULL) + return NULL; + +diff --git a/fs/nfsd/state.h b/fs/nfsd/state.h +index c9399366f9df..4516e8b7d776 100644 +--- a/fs/nfsd/state.h ++++ b/fs/nfsd/state.h +@@ -603,8 +603,8 @@ extern __be32 nfs4_preprocess_stateid_op(struct svc_rqst *rqstp, + __be32 nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate, + stateid_t *stateid, unsigned char typemask, + struct nfs4_stid **s, struct nfsd_net *nn); +-struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, +- struct kmem_cache *slab); ++struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab, ++ void (*sc_free)(struct nfs4_stid *)); + void nfs4_unhash_stid(struct nfs4_stid *s); + void nfs4_put_stid(struct nfs4_stid *s); + void nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid); +diff --git a/include/linux/irq.h b/include/linux/irq.h +index e79875574b39..39e3254e5769 100644 +--- a/include/linux/irq.h ++++ b/include/linux/irq.h +@@ -184,6 +184,7 @@ struct irq_data { + * + * IRQD_TRIGGER_MASK - Mask for the trigger type bits + * IRQD_SETAFFINITY_PENDING - Affinity setting is pending ++ * IRQD_ACTIVATED - Interrupt has already been activated + * IRQD_NO_BALANCING - Balancing disabled for this IRQ + * IRQD_PER_CPU - Interrupt is per cpu + * IRQD_AFFINITY_SET - Interrupt affinity was set +@@ -202,6 +203,7 @@ struct irq_data { + enum { + IRQD_TRIGGER_MASK = 0xf, + IRQD_SETAFFINITY_PENDING = (1 << 8), ++ IRQD_ACTIVATED = (1 << 9), + IRQD_NO_BALANCING = (1 << 10), + IRQD_PER_CPU = (1 << 11), + IRQD_AFFINITY_SET = (1 << 12), +@@ -312,6 +314,21 @@ static inline bool irqd_affinity_is_managed(struct irq_data *d) + return __irqd_to_state(d) & IRQD_AFFINITY_MANAGED; + } + ++static inline bool irqd_is_activated(struct irq_data *d) ++{ ++ return __irqd_to_state(d) & IRQD_ACTIVATED; ++} ++ ++static inline void irqd_set_activated(struct irq_data *d) ++{ ++ __irqd_to_state(d) |= IRQD_ACTIVATED; ++} ++ ++static inline void irqd_clr_activated(struct irq_data *d) ++{ ++ __irqd_to_state(d) &= ~IRQD_ACTIVATED; ++} ++ + #undef __irqd_to_state + + static inline irq_hw_number_t irqd_to_hwirq(struct irq_data *d) +diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h +index c1784c0b4f35..134a2f69c21a 100644 +--- a/include/linux/memory_hotplug.h ++++ b/include/linux/memory_hotplug.h +@@ -85,7 +85,8 @@ extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages); + extern int add_one_highpage(struct page *page, int pfn, int bad_ppro); + /* VM interface that may be used by firmware interface */ + extern int online_pages(unsigned long, unsigned long, int); +-extern int test_pages_in_a_zone(unsigned long, unsigned long); ++extern int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn, ++ unsigned long *valid_start, unsigned long *valid_end); + extern void __offline_isolated_pages(unsigned long, unsigned long); + + typedef void (*online_page_callback_t)(struct page *page); +diff --git a/include/linux/percpu-refcount.h b/include/linux/percpu-refcount.h +index 1c7eec09e5eb..3a481a49546e 100644 +--- a/include/linux/percpu-refcount.h ++++ b/include/linux/percpu-refcount.h +@@ -204,7 +204,7 @@ static inline void percpu_ref_get(struct percpu_ref *ref) + static inline bool percpu_ref_tryget(struct percpu_ref *ref) + { + unsigned long __percpu *percpu_count; +- int ret; ++ bool ret; + + rcu_read_lock_sched(); + +@@ -238,7 +238,7 @@ static inline bool percpu_ref_tryget(struct percpu_ref *ref) + static inline bool percpu_ref_tryget_live(struct percpu_ref *ref) + { + unsigned long __percpu *percpu_count; +- int ret = false; ++ bool ret = false; + + rcu_read_lock_sched(); + +diff --git a/kernel/cgroup.c b/kernel/cgroup.c +index 85bc9beb046d..4e2f3de0e40b 100644 +--- a/kernel/cgroup.c ++++ b/kernel/cgroup.c +@@ -5219,6 +5219,11 @@ static struct cgroup_subsys_state *css_create(struct cgroup *cgrp, + return ERR_PTR(err); + } + ++/* ++ * The returned cgroup is fully initialized including its control mask, but ++ * it isn't associated with its kernfs_node and doesn't have the control ++ * mask applied. ++ */ + static struct cgroup *cgroup_create(struct cgroup *parent) + { + struct cgroup_root *root = parent->root; +@@ -5283,11 +5288,6 @@ static struct cgroup *cgroup_create(struct cgroup *parent) + + cgroup_propagate_control(cgrp); + +- /* @cgrp doesn't have dir yet so the following will only create csses */ +- ret = cgroup_apply_control_enable(cgrp); +- if (ret) +- goto out_destroy; +- + return cgrp; + + out_cancel_ref: +@@ -5295,9 +5295,6 @@ static struct cgroup *cgroup_create(struct cgroup *parent) + out_free_cgrp: + kfree(cgrp); + return ERR_PTR(ret); +-out_destroy: +- cgroup_destroy_locked(cgrp); +- return ERR_PTR(ret); + } + + static int cgroup_mkdir(struct kernfs_node *parent_kn, const char *name, +diff --git a/kernel/events/core.c b/kernel/events/core.c +index e5a8839e7076..b1cfd7416db0 100644 +--- a/kernel/events/core.c ++++ b/kernel/events/core.c +@@ -1469,7 +1469,6 @@ ctx_group_list(struct perf_event *event, struct perf_event_context *ctx) + static void + list_add_event(struct perf_event *event, struct perf_event_context *ctx) + { +- + lockdep_assert_held(&ctx->lock); + + WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT); +@@ -1624,6 +1623,8 @@ static void perf_group_attach(struct perf_event *event) + { + struct perf_event *group_leader = event->group_leader, *pos; + ++ lockdep_assert_held(&event->ctx->lock); ++ + /* + * We can have double attach due to group movement in perf_event_open. + */ +@@ -1697,6 +1698,8 @@ static void perf_group_detach(struct perf_event *event) + struct perf_event *sibling, *tmp; + struct list_head *list = NULL; + ++ lockdep_assert_held(&event->ctx->lock); ++ + /* + * We can have double detach due to exit/hot-unplug + close. + */ +@@ -1895,9 +1898,29 @@ __perf_remove_from_context(struct perf_event *event, + */ + static void perf_remove_from_context(struct perf_event *event, unsigned long flags) + { +- lockdep_assert_held(&event->ctx->mutex); ++ struct perf_event_context *ctx = event->ctx; ++ ++ lockdep_assert_held(&ctx->mutex); + + event_function_call(event, __perf_remove_from_context, (void *)flags); ++ ++ /* ++ * The above event_function_call() can NO-OP when it hits ++ * TASK_TOMBSTONE. In that case we must already have been detached ++ * from the context (by perf_event_exit_event()) but the grouping ++ * might still be in-tact. ++ */ ++ WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT); ++ if ((flags & DETACH_GROUP) && ++ (event->attach_state & PERF_ATTACH_GROUP)) { ++ /* ++ * Since in that case we cannot possibly be scheduled, simply ++ * detach now. ++ */ ++ raw_spin_lock_irq(&ctx->lock); ++ perf_group_detach(event); ++ raw_spin_unlock_irq(&ctx->lock); ++ } + } + + /* +@@ -6583,6 +6606,27 @@ static void perf_event_mmap_event(struct perf_mmap_event *mmap_event) + char *buf = NULL; + char *name; + ++ if (vma->vm_flags & VM_READ) ++ prot |= PROT_READ; ++ if (vma->vm_flags & VM_WRITE) ++ prot |= PROT_WRITE; ++ if (vma->vm_flags & VM_EXEC) ++ prot |= PROT_EXEC; ++ ++ if (vma->vm_flags & VM_MAYSHARE) ++ flags = MAP_SHARED; ++ else ++ flags = MAP_PRIVATE; ++ ++ if (vma->vm_flags & VM_DENYWRITE) ++ flags |= MAP_DENYWRITE; ++ if (vma->vm_flags & VM_MAYEXEC) ++ flags |= MAP_EXECUTABLE; ++ if (vma->vm_flags & VM_LOCKED) ++ flags |= MAP_LOCKED; ++ if (vma->vm_flags & VM_HUGETLB) ++ flags |= MAP_HUGETLB; ++ + if (file) { + struct inode *inode; + dev_t dev; +@@ -6609,27 +6653,6 @@ static void perf_event_mmap_event(struct perf_mmap_event *mmap_event) + maj = MAJOR(dev); + min = MINOR(dev); + +- if (vma->vm_flags & VM_READ) +- prot |= PROT_READ; +- if (vma->vm_flags & VM_WRITE) +- prot |= PROT_WRITE; +- if (vma->vm_flags & VM_EXEC) +- prot |= PROT_EXEC; +- +- if (vma->vm_flags & VM_MAYSHARE) +- flags = MAP_SHARED; +- else +- flags = MAP_PRIVATE; +- +- if (vma->vm_flags & VM_DENYWRITE) +- flags |= MAP_DENYWRITE; +- if (vma->vm_flags & VM_MAYEXEC) +- flags |= MAP_EXECUTABLE; +- if (vma->vm_flags & VM_LOCKED) +- flags |= MAP_LOCKED; +- if (vma->vm_flags & VM_HUGETLB) +- flags |= MAP_HUGETLB; +- + goto got_name; + } else { + if (vma->vm_ops && vma->vm_ops->name) { +diff --git a/kernel/irq/irqdomain.c b/kernel/irq/irqdomain.c +index 8c0a0ae43521..b59e6768c5e9 100644 +--- a/kernel/irq/irqdomain.c ++++ b/kernel/irq/irqdomain.c +@@ -1346,6 +1346,30 @@ void irq_domain_free_irqs_parent(struct irq_domain *domain, + } + EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent); + ++static void __irq_domain_activate_irq(struct irq_data *irq_data) ++{ ++ if (irq_data && irq_data->domain) { ++ struct irq_domain *domain = irq_data->domain; ++ ++ if (irq_data->parent_data) ++ __irq_domain_activate_irq(irq_data->parent_data); ++ if (domain->ops->activate) ++ domain->ops->activate(domain, irq_data); ++ } ++} ++ ++static void __irq_domain_deactivate_irq(struct irq_data *irq_data) ++{ ++ if (irq_data && irq_data->domain) { ++ struct irq_domain *domain = irq_data->domain; ++ ++ if (domain->ops->deactivate) ++ domain->ops->deactivate(domain, irq_data); ++ if (irq_data->parent_data) ++ __irq_domain_deactivate_irq(irq_data->parent_data); ++ } ++} ++ + /** + * irq_domain_activate_irq - Call domain_ops->activate recursively to activate + * interrupt +@@ -1356,13 +1380,9 @@ EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent); + */ + void irq_domain_activate_irq(struct irq_data *irq_data) + { +- if (irq_data && irq_data->domain) { +- struct irq_domain *domain = irq_data->domain; +- +- if (irq_data->parent_data) +- irq_domain_activate_irq(irq_data->parent_data); +- if (domain->ops->activate) +- domain->ops->activate(domain, irq_data); ++ if (!irqd_is_activated(irq_data)) { ++ __irq_domain_activate_irq(irq_data); ++ irqd_set_activated(irq_data); + } + } + +@@ -1376,13 +1396,9 @@ void irq_domain_activate_irq(struct irq_data *irq_data) + */ + void irq_domain_deactivate_irq(struct irq_data *irq_data) + { +- if (irq_data && irq_data->domain) { +- struct irq_domain *domain = irq_data->domain; +- +- if (domain->ops->deactivate) +- domain->ops->deactivate(domain, irq_data); +- if (irq_data->parent_data) +- irq_domain_deactivate_irq(irq_data->parent_data); ++ if (irqd_is_activated(irq_data)) { ++ __irq_domain_deactivate_irq(irq_data); ++ irqd_clr_activated(irq_data); + } + } + +diff --git a/kernel/trace/trace_hwlat.c b/kernel/trace/trace_hwlat.c +index b97286c48735..f00b0131c8f9 100644 +--- a/kernel/trace/trace_hwlat.c ++++ b/kernel/trace/trace_hwlat.c +@@ -266,7 +266,7 @@ static int get_sample(void) + static struct cpumask save_cpumask; + static bool disable_migrate; + +-static void move_to_next_cpu(void) ++static void move_to_next_cpu(bool initmask) + { + static struct cpumask *current_mask; + int next_cpu; +@@ -275,7 +275,7 @@ static void move_to_next_cpu(void) + return; + + /* Just pick the first CPU on first iteration */ +- if (!current_mask) { ++ if (initmask) { + current_mask = &save_cpumask; + get_online_cpus(); + cpumask_and(current_mask, cpu_online_mask, tracing_buffer_mask); +@@ -330,10 +330,12 @@ static void move_to_next_cpu(void) + static int kthread_fn(void *data) + { + u64 interval; ++ bool initmask = true; + + while (!kthread_should_stop()) { + +- move_to_next_cpu(); ++ move_to_next_cpu(initmask); ++ initmask = false; + + local_irq_disable(); + get_sample(); +diff --git a/mm/filemap.c b/mm/filemap.c +index 779801092ef1..d8d7df82c69a 100644 +--- a/mm/filemap.c ++++ b/mm/filemap.c +@@ -1703,6 +1703,11 @@ static ssize_t do_generic_file_read(struct file *filp, loff_t *ppos, + + cond_resched(); + find_page: ++ if (fatal_signal_pending(current)) { ++ error = -EINTR; ++ goto out; ++ } ++ + page = find_get_page(mapping, index); + if (!page) { + page_cache_sync_readahead(mapping, +diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c +index c3a8141ac788..ede137345a99 100644 +--- a/mm/memory_hotplug.c ++++ b/mm/memory_hotplug.c +@@ -1483,17 +1483,20 @@ bool is_mem_section_removable(unsigned long start_pfn, unsigned long nr_pages) + } + + /* +- * Confirm all pages in a range [start, end) is belongs to the same zone. ++ * Confirm all pages in a range [start, end) belong to the same zone. ++ * When true, return its valid [start, end). + */ +-int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn) ++int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn, ++ unsigned long *valid_start, unsigned long *valid_end) + { + unsigned long pfn, sec_end_pfn; ++ unsigned long start, end; + struct zone *zone = NULL; + struct page *page; + int i; +- for (pfn = start_pfn, sec_end_pfn = SECTION_ALIGN_UP(start_pfn); ++ for (pfn = start_pfn, sec_end_pfn = SECTION_ALIGN_UP(start_pfn + 1); + pfn < end_pfn; +- pfn = sec_end_pfn + 1, sec_end_pfn += PAGES_PER_SECTION) { ++ pfn = sec_end_pfn, sec_end_pfn += PAGES_PER_SECTION) { + /* Make sure the memory section is present first */ + if (!present_section_nr(pfn_to_section_nr(pfn))) + continue; +@@ -1509,10 +1512,20 @@ int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn) + page = pfn_to_page(pfn + i); + if (zone && page_zone(page) != zone) + return 0; ++ if (!zone) ++ start = pfn + i; + zone = page_zone(page); ++ end = pfn + MAX_ORDER_NR_PAGES; + } + } +- return 1; ++ ++ if (zone) { ++ *valid_start = start; ++ *valid_end = end; ++ return 1; ++ } else { ++ return 0; ++ } + } + + /* +@@ -1859,6 +1872,7 @@ static int __ref __offline_pages(unsigned long start_pfn, + long offlined_pages; + int ret, drain, retry_max, node; + unsigned long flags; ++ unsigned long valid_start, valid_end; + struct zone *zone; + struct memory_notify arg; + +@@ -1869,10 +1883,10 @@ static int __ref __offline_pages(unsigned long start_pfn, + return -EINVAL; + /* This makes hotplug much easier...and readable. + we assume this for now. .*/ +- if (!test_pages_in_a_zone(start_pfn, end_pfn)) ++ if (!test_pages_in_a_zone(start_pfn, end_pfn, &valid_start, &valid_end)) + return -EINVAL; + +- zone = page_zone(pfn_to_page(start_pfn)); ++ zone = page_zone(pfn_to_page(valid_start)); + node = zone_to_nid(zone); + nr_pages = end_pfn - start_pfn; + +diff --git a/mm/zswap.c b/mm/zswap.c +index 275b22cc8df4..dbef27822a98 100644 +--- a/mm/zswap.c ++++ b/mm/zswap.c +@@ -78,7 +78,13 @@ static u64 zswap_duplicate_entry; + + /* Enable/disable zswap (disabled by default) */ + static bool zswap_enabled; +-module_param_named(enabled, zswap_enabled, bool, 0644); ++static int zswap_enabled_param_set(const char *, ++ const struct kernel_param *); ++static struct kernel_param_ops zswap_enabled_param_ops = { ++ .set = zswap_enabled_param_set, ++ .get = param_get_bool, ++}; ++module_param_cb(enabled, &zswap_enabled_param_ops, &zswap_enabled, 0644); + + /* Crypto compressor to use */ + #define ZSWAP_COMPRESSOR_DEFAULT "lzo" +@@ -176,6 +182,9 @@ static atomic_t zswap_pools_count = ATOMIC_INIT(0); + /* used by param callback function */ + static bool zswap_init_started; + ++/* fatal error during init */ ++static bool zswap_init_failed; ++ + /********************************* + * helpers and fwd declarations + **********************************/ +@@ -706,6 +715,11 @@ static int __zswap_param_set(const char *val, const struct kernel_param *kp, + char *s = strstrip((char *)val); + int ret; + ++ if (zswap_init_failed) { ++ pr_err("can't set param, initialization failed\n"); ++ return -ENODEV; ++ } ++ + /* no change required */ + if (!strcmp(s, *(char **)kp->arg)) + return 0; +@@ -785,6 +799,17 @@ static int zswap_zpool_param_set(const char *val, + return __zswap_param_set(val, kp, NULL, zswap_compressor); + } + ++static int zswap_enabled_param_set(const char *val, ++ const struct kernel_param *kp) ++{ ++ if (zswap_init_failed) { ++ pr_err("can't enable, initialization failed\n"); ++ return -ENODEV; ++ } ++ ++ return param_set_bool(val, kp); ++} ++ + /********************************* + * writeback code + **********************************/ +@@ -1271,6 +1296,9 @@ static int __init init_zswap(void) + dstmem_fail: + zswap_entry_cache_destroy(); + cache_fail: ++ /* if built-in, we aren't unloaded on failure; don't allow use */ ++ zswap_init_failed = true; ++ zswap_enabled = false; + return -ENOMEM; + } + /* must be late so crypto has time to come up */ +diff --git a/net/can/bcm.c b/net/can/bcm.c +index 436a7537e6a9..5e9ed5ec2860 100644 +--- a/net/can/bcm.c ++++ b/net/can/bcm.c +@@ -734,14 +734,23 @@ static struct bcm_op *bcm_find_op(struct list_head *ops, + + static void bcm_remove_op(struct bcm_op *op) + { +- hrtimer_cancel(&op->timer); +- hrtimer_cancel(&op->thrtimer); +- +- if (op->tsklet.func) +- tasklet_kill(&op->tsklet); ++ if (op->tsklet.func) { ++ while (test_bit(TASKLET_STATE_SCHED, &op->tsklet.state) || ++ test_bit(TASKLET_STATE_RUN, &op->tsklet.state) || ++ hrtimer_active(&op->timer)) { ++ hrtimer_cancel(&op->timer); ++ tasklet_kill(&op->tsklet); ++ } ++ } + +- if (op->thrtsklet.func) +- tasklet_kill(&op->thrtsklet); ++ if (op->thrtsklet.func) { ++ while (test_bit(TASKLET_STATE_SCHED, &op->thrtsklet.state) || ++ test_bit(TASKLET_STATE_RUN, &op->thrtsklet.state) || ++ hrtimer_active(&op->thrtimer)) { ++ hrtimer_cancel(&op->thrtimer); ++ tasklet_kill(&op->thrtsklet); ++ } ++ } + + if ((op->frames) && (op->frames != &op->sframe)) + kfree(op->frames); +diff --git a/net/sunrpc/auth_gss/gss_rpc_xdr.c b/net/sunrpc/auth_gss/gss_rpc_xdr.c +index dc6fb79a361f..25d9a9cf7b66 100644 +--- a/net/sunrpc/auth_gss/gss_rpc_xdr.c ++++ b/net/sunrpc/auth_gss/gss_rpc_xdr.c +@@ -260,7 +260,7 @@ static int gssx_dec_option_array(struct xdr_stream *xdr, + if (!oa->data) + return -ENOMEM; + +- creds = kmalloc(sizeof(struct svc_cred), GFP_KERNEL); ++ creds = kzalloc(sizeof(struct svc_cred), GFP_KERNEL); + if (!creds) { + kfree(oa->data); + return -ENOMEM;
