75 files changed, 759 insertions, 319 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index ad9b965e5e44..8d4148406923 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -77,6 +77,7 @@ Descriptions of section entries:
         Q: Patchwork web based patch tracking system site
         T: SCM tree type and location.
            Type is one of: git, hg, quilt, stgit, topgit
+        B: Bug tracking system location.
         S: Status, one of the following:
            Supported:   Someone is actually paid to look after this.
            Maintained:  Someone actually looks after it.
@@ -281,6 +282,7 @@ L:	linux-acpi@vger.kernel.org
 W:      https://01.org/linux-acpi
 Q:      https://patchwork.kernel.org/project/linux-acpi/list/
 T:      git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
+B:      https://bugzilla.kernel.org
 S:      Supported
 F:      drivers/acpi/
 F:      drivers/pnp/pnpacpi/
@@ -304,6 +306,8 @@ W:	https://acpica.org/
 W:      https://github.com/acpica/acpica/
 Q:      https://patchwork.kernel.org/project/linux-acpi/list/
 T:      git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
+B:      https://bugzilla.kernel.org
+B:      https://bugs.acpica.org
 S:      Supported
 F:      drivers/acpi/acpica/
 F:      include/acpi/
@@ -313,6 +317,7 @@ ACPI FAN DRIVER
 M:      Zhang Rui <rui.zhang@intel.com>
 L:      linux-acpi@vger.kernel.org
 W:      https://01.org/linux-acpi
+B:      https://bugzilla.kernel.org
 S:      Supported
 F:      drivers/acpi/fan.c
 
@@ -328,6 +333,7 @@ ACPI THERMAL DRIVER
 M:      Zhang Rui <rui.zhang@intel.com>
 L:      linux-acpi@vger.kernel.org
 W:      https://01.org/linux-acpi
+B:      https://bugzilla.kernel.org
 S:      Supported
 F:      drivers/acpi/*thermal*
 
@@ -335,6 +341,7 @@ ACPI VIDEO DRIVER
 M:      Zhang Rui <rui.zhang@intel.com>
 L:      linux-acpi@vger.kernel.org
 W:      https://01.org/linux-acpi
+B:      https://bugzilla.kernel.org
 S:      Supported
 F:      drivers/acpi/acpi_video.c
 
@@ -5663,6 +5670,7 @@ HIBERNATION (aka Software Suspend, aka swsusp)
 M:      "Rafael J. Wysocki" <rjw@rjwysocki.net>
 M:      Pavel Machek <pavel@ucw.cz>
 L:      linux-pm@vger.kernel.org
+B:      https://bugzilla.kernel.org
 S:      Supported
 F:      arch/x86/power/
 F:      drivers/base/power/
@@ -9624,6 +9632,7 @@ POWER MANAGEMENT CORE
 M:      "Rafael J. Wysocki" <rjw@rjwysocki.net>
 L:      linux-pm@vger.kernel.org
 T:      git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
+B:      https://bugzilla.kernel.org
 S:      Supported
 F:      drivers/base/power/
 F:      include/linux/pm.h
@@ -11613,6 +11622,7 @@ M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
 M:      Len Brown <len.brown@intel.com>
 M:      Pavel Machek <pavel@ucw.cz>
 L:      linux-pm@vger.kernel.org
+B:      https://bugzilla.kernel.org
 S:      Supported
 F:      Documentation/power/
 F:      arch/x86/kernel/acpi/
diff --git a/arch/tile/kernel/time.c b/arch/tile/kernel/time.c
index 178989e6d3e3..ea960d660917 100644
--- a/arch/tile/kernel/time.c
+++ b/arch/tile/kernel/time.c
@@ -218,8 +218,8 @@ void do_timer_interrupt(struct pt_regs *regs, int fault_num)
  */
 unsigned long long sched_clock(void)
 {
-        return clocksource_cyc2ns(get_cycles(),
-                                  sched_clock_mult, SCHED_CLOCK_SHIFT);
+        return mult_frac(get_cycles(),
+                         sched_clock_mult, 1ULL << SCHED_CLOCK_SHIFT);
 }
 
 int setup_profiling_timer(unsigned int multiplier)
diff --git a/arch/x86/boot/compressed/Makefile b/arch/x86/boot/compressed/Makefile
index 536ccfcc01c6..34d9e15857c3 100644
--- a/arch/x86/boot/compressed/Makefile
+++ b/arch/x86/boot/compressed/Makefile
@@ -40,8 +40,8 @@ GCOV_PROFILE := n
 UBSAN_SANITIZE :=n
 
 LDFLAGS := -m elf_$(UTS_MACHINE)
-ifeq ($(CONFIG_RELOCATABLE),y)
-# If kernel is relocatable, build compressed kernel as PIE.
+# Compressed kernel should be built as PIE since it may be loaded at any
+# address by the bootloader.
 ifeq ($(CONFIG_X86_32),y)
 LDFLAGS += $(call ld-option, -pie) $(call ld-option, --no-dynamic-linker)
 else
@@ -51,7 +51,6 @@ else
 LDFLAGS += $(shell $(LD) --help 2>&1 | grep -q "\-z noreloc-overflow" \
         && echo "-z noreloc-overflow -pie --no-dynamic-linker")
 endif
-endif
 LDFLAGS_vmlinux := -T
 
 hostprogs-y     := mkpiggy
diff --git a/arch/x86/boot/cpu.c b/arch/x86/boot/cpu.c
index 26240dde081e..4224ede43b4e 100644
--- a/arch/x86/boot/cpu.c
+++ b/arch/x86/boot/cpu.c
@@ -87,6 +87,12 @@ int validate_cpu(void)
                 return -1;
         }
 
+        if (CONFIG_X86_MINIMUM_CPU_FAMILY <= 4 && !IS_ENABLED(CONFIG_M486) &&
+            !has_eflag(X86_EFLAGS_ID)) {
+                printf("This kernel requires a CPU with the CPUID instruction.  Build with CONFIG_M486=y to run on this CPU.\n");
+                return -1;
+        }
+
         if (err_flags) {
                 puts("This kernel requires the following features "
                      "not present on the CPU:\n");
diff --git a/arch/x86/events/amd/core.c b/arch/x86/events/amd/core.c
index f5f4b3fbbbc2..afb222b63cae 100644
--- a/arch/x86/events/amd/core.c
+++ b/arch/x86/events/amd/core.c
@@ -662,7 +662,13 @@ static int __init amd_core_pmu_init(void)
                 pr_cont("Fam15h ");
                 x86_pmu.get_event_constraints = amd_get_event_constraints_f15h;
                 break;
-
+        case 0x17:
+                pr_cont("Fam17h ");
+                /*
+                 * In family 17h, there are no event constraints in the PMC hardware.
+                 * We fallback to using default amd_get_event_constraints.
+                 */
+                break;
         default:
                 pr_err("core perfctr but no constraints; unknown hardware!\n");
                 return -ENODEV;
diff --git a/arch/x86/events/core.c b/arch/x86/events/core.c
index d31735f37ed7..9d4bf3ab049e 100644
--- a/arch/x86/events/core.c
+++ b/arch/x86/events/core.c
@@ -2352,7 +2352,7 @@ perf_callchain_user32(struct pt_regs *regs, struct perf_callchain_entry_ctx *ent
                 frame.next_frame     = 0;
                 frame.return_address = 0;
 
-                if (!access_ok(VERIFY_READ, fp, 8))
+                if (!valid_user_frame(fp, sizeof(frame)))
                         break;
 
                 bytes = __copy_from_user_nmi(&frame.next_frame, fp, 4);
@@ -2362,9 +2362,6 @@ perf_callchain_user32(struct pt_regs *regs, struct perf_callchain_entry_ctx *ent
                 if (bytes != 0)
                         break;
 
-                if (!valid_user_frame(fp, sizeof(frame)))
-                        break;
-
                 perf_callchain_store(entry, cs_base + frame.return_address);
                 fp = compat_ptr(ss_base + frame.next_frame);
         }
@@ -2413,7 +2410,7 @@ perf_callchain_user(struct perf_callchain_entry_ctx *entry, struct pt_regs *regs
                 frame.next_frame             = NULL;
                 frame.return_address = 0;
 
-                if (!access_ok(VERIFY_READ, fp, sizeof(*fp) * 2))
+                if (!valid_user_frame(fp, sizeof(frame)))
                         break;
 
                 bytes = __copy_from_user_nmi(&frame.next_frame, fp, sizeof(*fp));
@@ -2423,9 +2420,6 @@ perf_callchain_user(struct perf_callchain_entry_ctx *entry, struct pt_regs *regs
                 if (bytes != 0)
                         break;
 
-                if (!valid_user_frame(fp, sizeof(frame)))
-                        break;
-
                 perf_callchain_store(entry, frame.return_address);
                 fp = (void __user *)frame.next_frame;
         }
diff --git a/arch/x86/events/intel/ds.c b/arch/x86/events/intel/ds.c
index 0319311dbdbb..be202390bbd3 100644
--- a/arch/x86/events/intel/ds.c
+++ b/arch/x86/events/intel/ds.c
@@ -1108,20 +1108,20 @@ static void setup_pebs_sample_data(struct perf_event *event,
         }
 
         /*
-         * We use the interrupt regs as a base because the PEBS record
-         * does not contain a full regs set, specifically it seems to
-         * lack segment descriptors, which get used by things like
-         * user_mode().
+         * We use the interrupt regs as a base because the PEBS record does not
+         * contain a full regs set, specifically it seems to lack segment
+         * descriptors, which get used by things like user_mode().
          *
-         * In the simple case fix up only the IP and BP,SP regs, for
-         * PERF_SAMPLE_IP and PERF_SAMPLE_CALLCHAIN to function properly.
-         * A possible PERF_SAMPLE_REGS will have to transfer all regs.
+         * In the simple case fix up only the IP for PERF_SAMPLE_IP.
+         *
+         * We must however always use BP,SP from iregs for the unwinder to stay
+         * sane; the record BP,SP can point into thin air when the record is
+         * from a previous PMI context or an (I)RET happend between the record
+         * and PMI.
          */
         *regs = *iregs;
         regs->flags = pebs->flags;
         set_linear_ip(regs, pebs->ip);
-        regs->bp = pebs->bp;
-        regs->sp = pebs->sp;
 
         if (sample_type & PERF_SAMPLE_REGS_INTR) {
                 regs->ax = pebs->ax;
@@ -1130,10 +1130,21 @@ static void setup_pebs_sample_data(struct perf_event *event,
                 regs->dx = pebs->dx;
                 regs->si = pebs->si;
                 regs->di = pebs->di;
-                regs->bp = pebs->bp;
-                regs->sp = pebs->sp;
 
-                regs->flags = pebs->flags;
+                /*
+                 * Per the above; only set BP,SP if we don't need callchains.
+                 *
+                 * XXX: does this make sense?
+                 */
+                if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {
+                        regs->bp = pebs->bp;
+                        regs->sp = pebs->sp;
+                }
+
+                /*
+                 * Preserve PERF_EFLAGS_VM from set_linear_ip().
+                 */
+                regs->flags = pebs->flags | (regs->flags & PERF_EFLAGS_VM);
 #ifndef CONFIG_X86_32
                 regs->r8 = pebs->r8;
                 regs->r9 = pebs->r9;
diff --git a/arch/x86/events/intel/uncore.c b/arch/x86/events/intel/uncore.c
index efca2685d876..dbaaf7dc8373 100644
--- a/arch/x86/events/intel/uncore.c
+++ b/arch/x86/events/intel/uncore.c
@@ -319,9 +319,9 @@ static struct intel_uncore_box *uncore_alloc_box(struct intel_uncore_type *type,
  */
 static int uncore_pmu_event_init(struct perf_event *event);
 
-static bool is_uncore_event(struct perf_event *event)
+static bool is_box_event(struct intel_uncore_box *box, struct perf_event *event)
 {
-        return event->pmu->event_init == uncore_pmu_event_init;
+        return &box->pmu->pmu == event->pmu;
 }
 
 static int
@@ -340,7 +340,7 @@ uncore_collect_events(struct intel_uncore_box *box, struct perf_event *leader,
 
         n = box->n_events;
 
-        if (is_uncore_event(leader)) {
+        if (is_box_event(box, leader)) {
                 box->event_list[n] = leader;
                 n++;
         }
@@ -349,7 +349,7 @@ uncore_collect_events(struct intel_uncore_box *box, struct perf_event *leader,
                 return n;
 
         list_for_each_entry(event, &leader->sibling_list, group_entry) {
-                if (!is_uncore_event(event) ||
+                if (!is_box_event(box, event) ||
                     event->state <= PERF_EVENT_STATE_OFF)
                         continue;
 
diff --git a/arch/x86/events/intel/uncore_snb.c b/arch/x86/events/intel/uncore_snb.c
index 81195cca7eae..a3dcc12bef4a 100644
--- a/arch/x86/events/intel/uncore_snb.c
+++ b/arch/x86/events/intel/uncore_snb.c
@@ -490,24 +490,12 @@ static int snb_uncore_imc_event_add(struct perf_event *event, int flags)
 
         snb_uncore_imc_event_start(event, 0);
 
-        box->n_events++;
-
         return 0;
 }
 
 static void snb_uncore_imc_event_del(struct perf_event *event, int flags)
 {
-        struct intel_uncore_box *box = uncore_event_to_box(event);
-        int i;
-
         snb_uncore_imc_event_stop(event, PERF_EF_UPDATE);
-
-        for (i = 0; i < box->n_events; i++) {
-                if (event == box->event_list[i]) {
-                        --box->n_events;
-                        break;
-                }
-        }
 }
 
 int snb_pci2phy_map_init(int devid)
diff --git a/arch/x86/events/perf_event.h b/arch/x86/events/perf_event.h
index 5874d8de1f8d..a77ee026643d 100644
--- a/arch/x86/events/perf_event.h
+++ b/arch/x86/events/perf_event.h
@@ -113,7 +113,7 @@ struct debug_store {
  * Per register state.
  */
 struct er_account {
-        raw_spinlock_t          lock;   /* per-core: protect structure */
+        raw_spinlock_t      lock;       /* per-core: protect structure */
         u64                 config;     /* extra MSR config */
         u64                 reg;        /* extra MSR number */
         atomic_t            ref;        /* reference count */
diff --git a/arch/x86/kernel/dumpstack.c b/arch/x86/kernel/dumpstack.c
index 9b7cf5c28f5f..85f854b98a9d 100644
--- a/arch/x86/kernel/dumpstack.c
+++ b/arch/x86/kernel/dumpstack.c
@@ -112,7 +112,7 @@ void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
                 for (; stack < stack_info.end; stack++) {
                         unsigned long real_addr;
                         int reliable = 0;
-                        unsigned long addr = *stack;
+                        unsigned long addr = READ_ONCE_NOCHECK(*stack);
                         unsigned long *ret_addr_p =
                                 unwind_get_return_address_ptr(&state);
 
diff --git a/arch/x86/kernel/fpu/core.c b/arch/x86/kernel/fpu/core.c
index 47004010ad5d..ebb4e95fbd74 100644
--- a/arch/x86/kernel/fpu/core.c
+++ b/arch/x86/kernel/fpu/core.c
@@ -521,14 +521,14 @@ void fpu__clear(struct fpu *fpu)
 {
         WARN_ON_FPU(fpu != &current->thread.fpu); /* Almost certainly an anomaly */
 
-        if (!use_eager_fpu() || !static_cpu_has(X86_FEATURE_FPU)) {
-                /* FPU state will be reallocated lazily at the first use. */
-                fpu__drop(fpu);
-        } else {
-                if (!fpu->fpstate_active) {
-                        fpu__activate_curr(fpu);
-                        user_fpu_begin();
-                }
+        fpu__drop(fpu);
+
+        /*
+         * Make sure fpstate is cleared and initialized.
+         */
+        if (static_cpu_has(X86_FEATURE_FPU)) {
+                fpu__activate_curr(fpu);
+                user_fpu_begin();
                 copy_init_fpstate_to_fpregs();
         }
 }
diff --git a/arch/x86/kernel/head_32.S b/arch/x86/kernel/head_32.S
index b6b2f0264af3..2dabea46f039 100644
--- a/arch/x86/kernel/head_32.S
+++ b/arch/x86/kernel/head_32.S
@@ -665,14 +665,17 @@ __PAGE_ALIGNED_BSS
 initial_pg_pmd:
         .fill 1024*KPMDS,4,0
 #else
-ENTRY(initial_page_table)
+.globl initial_page_table
+initial_page_table:
         .fill 1024,4,0
 #endif
 initial_pg_fixmap:
         .fill 1024,4,0
-ENTRY(empty_zero_page)
+.globl empty_zero_page
+empty_zero_page:
         .fill 4096,1,0
-ENTRY(swapper_pg_dir)
+.globl swapper_pg_dir
+swapper_pg_dir:
         .fill 1024,4,0
 EXPORT_SYMBOL(empty_zero_page)
 
diff --git a/arch/x86/kernel/sysfb_simplefb.c b/arch/x86/kernel/sysfb_simplefb.c
index 764a29f84de7..85195d447a92 100644
--- a/arch/x86/kernel/sysfb_simplefb.c
+++ b/arch/x86/kernel/sysfb_simplefb.c
@@ -66,13 +66,36 @@ __init int create_simplefb(const struct screen_info *si,
 {
         struct platform_device *pd;
         struct resource res;
-        unsigned long len;
+        u64 base, size;
+        u32 length;
 
-        /* don't use lfb_size as it may contain the whole VMEM instead of only
-         * the part that is occupied by the framebuffer */
-        len = mode->height * mode->stride;
-        len = PAGE_ALIGN(len);
-        if (len > (u64)si->lfb_size << 16) {
+        /*
+         * If the 64BIT_BASE capability is set, ext_lfb_base will contain the
+         * upper half of the base address. Assemble the address, then make sure
+         * it is valid and we can actually access it.
+         */
+        base = si->lfb_base;
+        if (si->capabilities & VIDEO_CAPABILITY_64BIT_BASE)
+                base |= (u64)si->ext_lfb_base << 32;
+        if (!base || (u64)(resource_size_t)base != base) {
+                printk(KERN_DEBUG "sysfb: inaccessible VRAM base\n");
+                return -EINVAL;
+        }
+
+        /*
+         * Don't use lfb_size as IORESOURCE size, since it may contain the
+         * entire VMEM, and thus require huge mappings. Use just the part we
+         * need, that is, the part where the framebuffer is located. But verify
+         * that it does not exceed the advertised VMEM.
+         * Note that in case of VBE, the lfb_size is shifted by 16 bits for
+         * historical reasons.
+         */
+        size = si->lfb_size;
+        if (si->orig_video_isVGA == VIDEO_TYPE_VLFB)
+                size <<= 16;
+        length = mode->height * mode->stride;
+        length = PAGE_ALIGN(length);
+        if (length > size) {
                 printk(KERN_WARNING "sysfb: VRAM smaller than advertised\n");
                 return -EINVAL;
         }
@@ -81,8 +104,8 @@ __init int create_simplefb(const struct screen_info *si,
         memset(&res, 0, sizeof(res));
         res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
         res.name = simplefb_resname;
-        res.start = si->lfb_base;
-        res.end = si->lfb_base + len - 1;
+        res.start = base;
+        res.end = res.start + length - 1;
         if (res.end <= res.start)
                 return -EINVAL;
 
diff --git a/arch/x86/kernel/unwind_guess.c b/arch/x86/kernel/unwind_guess.c
index 2d721e533cf4..b80e8bf43cc6 100644
--- a/arch/x86/kernel/unwind_guess.c
+++ b/arch/x86/kernel/unwind_guess.c
@@ -7,11 +7,13 @@
 
 unsigned long unwind_get_return_address(struct unwind_state *state)
 {
+        unsigned long addr = READ_ONCE_NOCHECK(*state->sp);
+
         if (unwind_done(state))
                 return 0;
 
         return ftrace_graph_ret_addr(state->task, &state->graph_idx,
-                                     *state->sp, state->sp);
+                                     addr, state->sp);
 }
 EXPORT_SYMBOL_GPL(unwind_get_return_address);
 
@@ -23,8 +25,10 @@ bool unwind_next_frame(struct unwind_state *state)
                 return false;
 
         do {
+                unsigned long addr = READ_ONCE_NOCHECK(*state->sp);
+
                 for (state->sp++; state->sp < info->end; state->sp++)
-                        if (__kernel_text_address(*state->sp))
+                        if (__kernel_text_address(addr))
                                 return true;
 
                 state->sp = info->next_sp;
diff --git a/arch/x86/mm/extable.c b/arch/x86/mm/extable.c
index 79ae939970d3..fcd06f7526de 100644
--- a/arch/x86/mm/extable.c
+++ b/arch/x86/mm/extable.c
@@ -135,7 +135,12 @@ void __init early_fixup_exception(struct pt_regs *regs, int trapnr)
         if (early_recursion_flag > 2)
                 goto halt_loop;
 
-        if (regs->cs != __KERNEL_CS)
+        /*
+         * Old CPUs leave the high bits of CS on the stack
+         * undefined.  I'm not sure which CPUs do this, but at least
+         * the 486 DX works this way.
+         */
+        if ((regs->cs & 0xFFFF) != __KERNEL_CS)
                 goto fail;
 
         /*
diff --git a/arch/x86/platform/intel-mid/device_libs/Makefile b/arch/x86/platform/intel-mid/device_libs/Makefile
index 429d08be7848..dd6cfa4ad3ac 100644
--- a/arch/x86/platform/intel-mid/device_libs/Makefile
+++ b/arch/x86/platform/intel-mid/device_libs/Makefile
@@ -28,4 +28,4 @@ obj-$(subst m,y,$(CONFIG_GPIO_PCA953X)) += platform_pcal9555a.o
 obj-$(subst m,y,$(CONFIG_GPIO_PCA953X)) += platform_tca6416.o
 # MISC Devices
 obj-$(subst m,y,$(CONFIG_KEYBOARD_GPIO)) += platform_gpio_keys.o
-obj-$(subst m,y,$(CONFIG_INTEL_MID_WATCHDOG)) += platform_wdt.o
+obj-$(subst m,y,$(CONFIG_INTEL_MID_WATCHDOG)) += platform_mrfld_wdt.o
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_wdt.c b/arch/x86/platform/intel-mid/device_libs/platform_mrfld_wdt.c
index de734134bc8d..3f1f1c77d090 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_wdt.c
+++ b/arch/x86/platform/intel-mid/device_libs/platform_mrfld_wdt.c
@@ -1,5 +1,5 @@
 /*
- * platform_wdt.c: Watchdog platform library file
+ * Intel Merrifield watchdog platform device library file
  *
  * (C) Copyright 2014 Intel Corporation
  * Author: David Cohen <david.a.cohen@linux.intel.com>
@@ -14,7 +14,9 @@
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <linux/platform_data/intel-mid_wdt.h>
+
 #include <asm/intel-mid.h>
+#include <asm/intel_scu_ipc.h>
 #include <asm/io_apic.h>
 
 #define TANGIER_EXT_TIMER0_MSI 15
@@ -50,14 +52,34 @@ static struct intel_mid_wdt_pdata tangier_pdata = {
         .probe = tangier_probe,
 };
 
-static int __init register_mid_wdt(void)
+static int wdt_scu_status_change(struct notifier_block *nb,
+                                 unsigned long code, void *data)
 {
-        if (intel_mid_identify_cpu() == INTEL_MID_CPU_CHIP_TANGIER) {
-                wdt_dev.dev.platform_data = &tangier_pdata;
-                return platform_device_register(&wdt_dev);
+        if (code == SCU_DOWN) {
+                platform_device_unregister(&wdt_dev);
+                return 0;
         }
 
-        return -ENODEV;
+        return platform_device_register(&wdt_dev);
 }
 
+static struct notifier_block wdt_scu_notifier = {
+        .notifier_call  = wdt_scu_status_change,
+};
+
+static int __init register_mid_wdt(void)
+{
+        if (intel_mid_identify_cpu() != INTEL_MID_CPU_CHIP_TANGIER)
+                return -ENODEV;
+
+        wdt_dev.dev.platform_data = &tangier_pdata;
+
+        /*
+         * We need to be sure that the SCU IPC is ready before watchdog device
+         * can be registered:
+         */
+        intel_scu_notifier_add(&wdt_scu_notifier);
+
+        return 0;
+}
 rootfs_initcall(register_mid_wdt);
diff --git a/crypto/algif_hash.c b/crypto/algif_hash.c
index 05e21b464433..d19b09cdf284 100644
--- a/crypto/algif_hash.c
+++ b/crypto/algif_hash.c
@@ -214,7 +214,7 @@ static int hash_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
 
         ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0);
 
-        if (!result) {
+        if (!result && !ctx->more) {
                 err = af_alg_wait_for_completion(
                                 crypto_ahash_init(&ctx->req),
                                 &ctx->completion);
diff --git a/crypto/asymmetric_keys/x509_cert_parser.c b/crypto/asymmetric_keys/x509_cert_parser.c
index 865f46ea724f..c80765b211cf 100644
--- a/crypto/asymmetric_keys/x509_cert_parser.c
+++ b/crypto/asymmetric_keys/x509_cert_parser.c
@@ -133,7 +133,6 @@ struct x509_certificate *x509_cert_parse(const void *data, size_t datalen)
         return cert;
 
 error_decode:
-        kfree(cert->pub->key);
         kfree(ctx);
 error_no_ctx:
         x509_free_certificate(cert);
diff --git a/crypto/scatterwalk.c b/crypto/scatterwalk.c
index 52ce17a3dd63..c16c94f88733 100644
--- a/crypto/scatterwalk.c
+++ b/crypto/scatterwalk.c
@@ -68,10 +68,6 @@ void scatterwalk_map_and_copy(void *buf, struct scatterlist *sg,
 
         sg = scatterwalk_ffwd(tmp, sg, start);
 
-        if (sg_page(sg) == virt_to_page(buf) &&
-            sg->offset == offset_in_page(buf))
-                return;
-
         scatterwalk_start(&walk, sg);
         scatterwalk_copychunks(buf, &walk, nbytes, out);
         scatterwalk_done(&walk, out, 0);
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index deb0ff78eba8..54abb26b7366 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -47,32 +47,15 @@ static void acpi_sleep_tts_switch(u32 acpi_state)
         }
 }
 
-static void acpi_sleep_pts_switch(u32 acpi_state)
-{
-        acpi_status status;
-
-        status = acpi_execute_simple_method(NULL, "\\_PTS", acpi_state);
-        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
-                /*
-                 * OS can't evaluate the _PTS object correctly. Some warning
-                 * message will be printed. But it won't break anything.
-                 */
-                printk(KERN_NOTICE "Failure in evaluating _PTS object\n");
-        }
-}
-
-static int sleep_notify_reboot(struct notifier_block *this,
+static int tts_notify_reboot(struct notifier_block *this,
                         unsigned long code, void *x)
 {
         acpi_sleep_tts_switch(ACPI_STATE_S5);
-
-        acpi_sleep_pts_switch(ACPI_STATE_S5);
-
         return NOTIFY_DONE;
 }
 
-static struct notifier_block sleep_notifier = {
-        .notifier_call  = sleep_notify_reboot,
+static struct notifier_block tts_notifier = {
+        .notifier_call  = tts_notify_reboot,
         .next           = NULL,
         .priority       = 0,
 };
@@ -916,9 +899,9 @@ int __init acpi_sleep_init(void)
         pr_info(PREFIX "(supports%s)\n", supported);
 
         /*
-         * Register the sleep_notifier to reboot notifier list so that the _TTS
-         * and _PTS object can also be evaluated when the system enters S5.
+         * Register the tts_notifier to reboot notifier list so that the _TTS
+         * object can also be evaluated when the system enters S5.
          */
-        register_reboot_notifier(&sleep_notifier);
+        register_reboot_notifier(&tts_notifier);
         return 0;
 }
diff --git a/drivers/clk/berlin/bg2.c b/drivers/clk/berlin/bg2.c
index edf3b96b3b73..1d99292e2039 100644
--- a/drivers/clk/berlin/bg2.c
+++ b/drivers/clk/berlin/bg2.c
@@ -685,7 +685,7 @@ static void __init berlin2_clock_setup(struct device_node *np)
         }
 
         /* register clk-provider */
-        of_clk_add_hw_provider(np, of_clk_hw_onecell_get, &clk_data);
+        of_clk_add_hw_provider(np, of_clk_hw_onecell_get, clk_data);
 
         return;
 
diff --git a/drivers/clk/berlin/bg2q.c b/drivers/clk/berlin/bg2q.c
index 0718e831475f..3b784b593afd 100644
--- a/drivers/clk/berlin/bg2q.c
+++ b/drivers/clk/berlin/bg2q.c
@@ -382,7 +382,7 @@ static void __init berlin2q_clock_setup(struct device_node *np)
         }
 
         /* register clk-provider */
-        of_clk_add_hw_provider(np, of_clk_hw_onecell_get, &clk_data);
+        of_clk_add_hw_provider(np, of_clk_hw_onecell_get, clk_data);
 
         return;
 
diff --git a/drivers/clk/clk-efm32gg.c b/drivers/clk/clk-efm32gg.c
index 8802a2dd56ac..f674778fb3ac 100644
--- a/drivers/clk/clk-efm32gg.c
+++ b/drivers/clk/clk-efm32gg.c
@@ -82,6 +82,6 @@ static void __init efm32gg_cmu_init(struct device_node *np)
         hws[clk_HFPERCLKDAC0] = clk_hw_register_gate(NULL, "HFPERCLK.DAC0",
                         "HFXO", 0, base + CMU_HFPERCLKEN0, 17, 0, NULL);
 
-        of_clk_add_hw_provider(np, of_clk_hw_onecell_get, &clk_data);
+        of_clk_add_hw_provider(np, of_clk_hw_onecell_get, clk_data);
 }
 CLK_OF_DECLARE(efm32ggcmu, "efm32gg,cmu", efm32gg_cmu_init);
diff --git a/drivers/clk/sunxi-ng/ccu-sun6i-a31.c b/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
index 79596463e0d9..4a82a49cff5e 100644
--- a/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
+++ b/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
@@ -191,6 +191,8 @@ static struct clk_div_table axi_div_table[] = {
 static SUNXI_CCU_DIV_TABLE(axi_clk, "axi", "cpu",
                            0x050, 0, 3, axi_div_table, 0);
 
+#define SUN6I_A31_AHB1_REG  0x054
+
 static const char * const ahb1_parents[] = { "osc32k", "osc24M",
                                              "axi", "pll-periph" };
 
@@ -1230,6 +1232,16 @@ static void __init sun6i_a31_ccu_setup(struct device_node *node)
         val &= BIT(16);
         writel(val, reg + SUN6I_A31_PLL_MIPI_REG);
 
+        /* Force AHB1 to PLL6 / 3 */
+        val = readl(reg + SUN6I_A31_AHB1_REG);
+        /* set PLL6 pre-div = 3 */
+        val &= ~GENMASK(7, 6);
+        val |= 0x2 << 6;
+        /* select PLL6 / pre-div */
+        val &= ~GENMASK(13, 12);
+        val |= 0x3 << 12;
+        writel(val, reg + SUN6I_A31_AHB1_REG);
+
         sunxi_ccu_probe(node, reg, &sun6i_a31_ccu_desc);
 
         ccu_mux_notifier_register(pll_cpu_clk.common.hw.clk,
diff --git a/drivers/clk/sunxi/clk-sunxi.c b/drivers/clk/sunxi/clk-sunxi.c
index 838b22aa8b67..f2c9274b8bd5 100644
--- a/drivers/clk/sunxi/clk-sunxi.c
+++ b/drivers/clk/sunxi/clk-sunxi.c
@@ -373,7 +373,7 @@ static void sun4i_get_apb1_factors(struct factors_request *req)
         else
                 calcp = 3;
 
-        calcm = (req->parent_rate >> calcp) - 1;
+        calcm = (div >> calcp) - 1;
 
         req->rate = (req->parent_rate >> calcp) / (calcm + 1);
         req->m = calcm;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c
index dae35a96a694..02ca5dd978f6 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c
@@ -34,6 +34,7 @@ struct amdgpu_atpx {
 
 static struct amdgpu_atpx_priv {
         bool atpx_detected;
+        bool bridge_pm_usable;
         /* handle for device - and atpx */
         acpi_handle dhandle;
         acpi_handle other_handle;
@@ -205,7 +206,11 @@ static int amdgpu_atpx_validate(struct amdgpu_atpx *atpx)
         atpx->is_hybrid = false;
         if (valid_bits & ATPX_MS_HYBRID_GFX_SUPPORTED) {
                 printk("ATPX Hybrid Graphics\n");
-                atpx->functions.power_cntl = false;
+                /*
+                 * Disable legacy PM methods only when pcie port PM is usable,
+                 * otherwise the device might fail to power off or power on.
+                 */
+                atpx->functions.power_cntl = !amdgpu_atpx_priv.bridge_pm_usable;
                 atpx->is_hybrid = true;
         }
 
@@ -480,6 +485,7 @@ static int amdgpu_atpx_power_state(enum vga_switcheroo_client_id id,
  */
 static bool amdgpu_atpx_pci_probe_handle(struct pci_dev *pdev)
 {
+        struct pci_dev *parent_pdev = pci_upstream_bridge(pdev);
         acpi_handle dhandle, atpx_handle;
         acpi_status status;
 
@@ -494,6 +500,7 @@ static bool amdgpu_atpx_pci_probe_handle(struct pci_dev *pdev)
         }
         amdgpu_atpx_priv.dhandle = dhandle;
         amdgpu_atpx_priv.atpx.handle = atpx_handle;
+        amdgpu_atpx_priv.bridge_pm_usable = parent_pdev && parent_pdev->bridge_d3;
         return true;
 }
 
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c
index 13f2b705ea49..08cd0bd3ebe5 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c
@@ -2984,19 +2984,19 @@ static int smu7_get_pp_table_entry_callback_func_v0(struct pp_hwmgr *hwmgr,
         if (!(data->mc_micro_code_feature & DISABLE_MC_LOADMICROCODE) && memory_clock > data->highest_mclk)
                 data->highest_mclk = memory_clock;
 
-        performance_level = &(ps->performance_levels
-                        [ps->performance_level_count++]);
-
         PP_ASSERT_WITH_CODE(
                         (ps->performance_level_count < smum_get_mac_definition(hwmgr->smumgr, SMU_MAX_LEVELS_GRAPHICS)),
                         "Performance levels exceeds SMC limit!",
                         return -EINVAL);
 
         PP_ASSERT_WITH_CODE(
-                        (ps->performance_level_count <=
+                        (ps->performance_level_count <
                                         hwmgr->platform_descriptor.hardwareActivityPerformanceLevels),
-                        "Performance levels exceeds Driver limit!",
-                        return -EINVAL);
+                        "Performance levels exceeds Driver limit, Skip!",
+                        return 0);
+
+        performance_level = &(ps->performance_levels
+                        [ps->performance_level_count++]);
 
         /* Performance levels are arranged from low to high. */
         performance_level->memory_clock = memory_clock;
diff --git a/drivers/gpu/drm/arm/hdlcd_crtc.c b/drivers/gpu/drm/arm/hdlcd_crtc.c
index 48019ae22ddb..28341b32067f 100644
--- a/drivers/gpu/drm/arm/hdlcd_crtc.c
+++ b/drivers/gpu/drm/arm/hdlcd_crtc.c
@@ -150,15 +150,14 @@ static void hdlcd_crtc_enable(struct drm_crtc *crtc)
         clk_prepare_enable(hdlcd->clk);
         hdlcd_crtc_mode_set_nofb(crtc);
         hdlcd_write(hdlcd, HDLCD_REG_COMMAND, 1);
+        drm_crtc_vblank_on(crtc);
 }
 
 static void hdlcd_crtc_disable(struct drm_crtc *crtc)
 {
         struct hdlcd_drm_private *hdlcd = crtc_to_hdlcd_priv(crtc);
 
-        if (!crtc->state->active)
-                return;
-
+        drm_crtc_vblank_off(crtc);
         hdlcd_write(hdlcd, HDLCD_REG_COMMAND, 0);
         clk_disable_unprepare(hdlcd->clk);
 }
diff --git a/drivers/gpu/drm/exynos/exynos_hdmi.c b/drivers/gpu/drm/exynos/exynos_hdmi.c
index e8fb6ef947ee..38eaa63afb31 100644
--- a/drivers/gpu/drm/exynos/exynos_hdmi.c
+++ b/drivers/gpu/drm/exynos/exynos_hdmi.c
@@ -1907,6 +1907,8 @@ err_disable_pm_runtime:
 err_hdmiphy:
         if (hdata->hdmiphy_port)
                 put_device(&hdata->hdmiphy_port->dev);
+        if (hdata->regs_hdmiphy)
+                iounmap(hdata->regs_hdmiphy);
 err_ddc:
         put_device(&hdata->ddc_adpt->dev);
 
@@ -1929,6 +1931,9 @@ static int hdmi_remove(struct platform_device *pdev)
         if (hdata->hdmiphy_port)
                 put_device(&hdata->hdmiphy_port->dev);
 
+        if (hdata->regs_hdmiphy)
+                iounmap(hdata->regs_hdmiphy);
+
         put_device(&hdata->ddc_adpt->dev);
 
         return 0;
diff --git a/drivers/gpu/drm/mediatek/mtk_disp_ovl.c b/drivers/gpu/drm/mediatek/mtk_disp_ovl.c
index f75c5b5a536c..c70310206ac5 100644
--- a/drivers/gpu/drm/mediatek/mtk_disp_ovl.c
+++ b/drivers/gpu/drm/mediatek/mtk_disp_ovl.c
@@ -251,13 +251,6 @@ static int mtk_disp_ovl_probe(struct platform_device *pdev)
         if (irq < 0)
                 return irq;
 
-        ret = devm_request_irq(dev, irq, mtk_disp_ovl_irq_handler,
-                               IRQF_TRIGGER_NONE, dev_name(dev), priv);
-        if (ret < 0) {
-                dev_err(dev, "Failed to request irq %d: %d\n", irq, ret);
-                return ret;
-        }
-
         comp_id = mtk_ddp_comp_get_id(dev->of_node, MTK_DISP_OVL);
         if (comp_id < 0) {
                 dev_err(dev, "Failed to identify by alias: %d\n", comp_id);
@@ -273,6 +266,13 @@ static int mtk_disp_ovl_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, priv);
 
+        ret = devm_request_irq(dev, irq, mtk_disp_ovl_irq_handler,
+                               IRQF_TRIGGER_NONE, dev_name(dev), priv);
+        if (ret < 0) {
+                dev_err(dev, "Failed to request irq %d: %d\n", irq, ret);
+                return ret;
+        }
+
         ret = component_add(dev, &mtk_disp_ovl_component_ops);
         if (ret)
                 dev_err(dev, "Failed to add component: %d\n", ret);
diff --git a/drivers/gpu/drm/mediatek/mtk_drm_ddp_comp.c b/drivers/gpu/drm/mediatek/mtk_drm_ddp_comp.c
index df33b3ca6ffd..48cc01fd20c7 100644
--- a/drivers/gpu/drm/mediatek/mtk_drm_ddp_comp.c
+++ b/drivers/gpu/drm/mediatek/mtk_drm_ddp_comp.c
@@ -123,7 +123,7 @@ static void mtk_od_config(struct mtk_ddp_comp *comp, unsigned int w,
                           unsigned int bpc)
 {
         writel(w << 16 | h, comp->regs + DISP_OD_SIZE);
-        writel(OD_RELAYMODE, comp->regs + OD_RELAYMODE);
+        writel(OD_RELAYMODE, comp->regs + DISP_OD_CFG);
         mtk_dither_set(comp, bpc, DISP_OD_CFG);
 }
 
diff --git a/drivers/gpu/drm/mediatek/mtk_dsi.c b/drivers/gpu/drm/mediatek/mtk_dsi.c
index 28b2044ed9f2..eaa5a2240c0c 100644
--- a/drivers/gpu/drm/mediatek/mtk_dsi.c
+++ b/drivers/gpu/drm/mediatek/mtk_dsi.c
@@ -86,7 +86,7 @@
 
 #define DSI_PHY_TIMECON0        0x110
 #define LPX                             (0xff << 0)
-#define HS_PRPR                         (0xff << 8)
+#define HS_PREP                         (0xff << 8)
 #define HS_ZERO                         (0xff << 16)
 #define HS_TRAIL                        (0xff << 24)
 
@@ -102,10 +102,16 @@
 #define CLK_TRAIL                       (0xff << 24)
 
 #define DSI_PHY_TIMECON3        0x11c
-#define CLK_HS_PRPR                     (0xff << 0)
+#define CLK_HS_PREP                     (0xff << 0)
 #define CLK_HS_POST                     (0xff << 8)
 #define CLK_HS_EXIT                     (0xff << 16)
 
+#define T_LPX           5
+#define T_HS_PREP       6
+#define T_HS_TRAIL      8
+#define T_HS_EXIT       7
+#define T_HS_ZERO       10
+
 #define NS_TO_CYCLE(n, c)    ((n) / (c) + (((n) % (c)) ? 1 : 0))
 
 struct phy;
@@ -161,20 +167,18 @@ static void mtk_dsi_mask(struct mtk_dsi *dsi, u32 offset, u32 mask, u32 data)
 static void dsi_phy_timconfig(struct mtk_dsi *dsi)
 {
         u32 timcon0, timcon1, timcon2, timcon3;
-        unsigned int ui, cycle_time;
-        unsigned int lpx;
+        u32 ui, cycle_time;
 
         ui = 1000 / dsi->data_rate + 0x01;
         cycle_time = 8000 / dsi->data_rate + 0x01;
-        lpx = 5;
 
-        timcon0 = (8 << 24) | (0xa << 16) | (0x6 << 8) | lpx;
-        timcon1 = (7 << 24) | (5 * lpx << 16) | ((3 * lpx) / 2) << 8 |
-                  (4 * lpx);
+        timcon0 = T_LPX | T_HS_PREP << 8 | T_HS_ZERO << 16 | T_HS_TRAIL << 24;
+        timcon1 = 4 * T_LPX | (3 * T_LPX / 2) << 8 | 5 * T_LPX << 16 |
+                  T_HS_EXIT << 24;
         timcon2 = ((NS_TO_CYCLE(0x64, cycle_time) + 0xa) << 24) |
                   (NS_TO_CYCLE(0x150, cycle_time) << 16);
-        timcon3 = (2 * lpx) << 16 | NS_TO_CYCLE(80 + 52 * ui, cycle_time) << 8 |
-                   NS_TO_CYCLE(0x40, cycle_time);
+        timcon3 = NS_TO_CYCLE(0x40, cycle_time) | (2 * T_LPX) << 16 |
+                  NS_TO_CYCLE(80 + 52 * ui, cycle_time) << 8;
 
         writel(timcon0, dsi->regs + DSI_PHY_TIMECON0);
         writel(timcon1, dsi->regs + DSI_PHY_TIMECON1);
@@ -202,19 +206,47 @@ static int mtk_dsi_poweron(struct mtk_dsi *dsi)
 {
         struct device *dev = dsi->dev;
         int ret;
+        u64 pixel_clock, total_bits;
+        u32 htotal, htotal_bits, bit_per_pixel, overhead_cycles, overhead_bits;
 
         if (++dsi->refcount != 1)
                 return 0;
 
+        switch (dsi->format) {
+        case MIPI_DSI_FMT_RGB565:
+                bit_per_pixel = 16;
+                break;
+        case MIPI_DSI_FMT_RGB666_PACKED:
+                bit_per_pixel = 18;
+                break;
+        case MIPI_DSI_FMT_RGB666:
+        case MIPI_DSI_FMT_RGB888:
+        default:
+                bit_per_pixel = 24;
+                break;
+        }
+
         /**
-         * data_rate = (pixel_clock / 1000) * pixel_dipth * mipi_ratio;
-         * pixel_clock unit is Khz, data_rata unit is MHz, so need divide 1000.
-         * mipi_ratio is mipi clk coefficient for balance the pixel clk in mipi.
-         * we set mipi_ratio is 1.05.
+         * vm.pixelclock is in kHz, pixel_clock unit is Hz, so multiply by 1000
+         * htotal_time = htotal * byte_per_pixel / num_lanes
+         * overhead_time = lpx + hs_prepare + hs_zero + hs_trail + hs_exit
+         * mipi_ratio = (htotal_time + overhead_time) / htotal_time
+         * data_rate = pixel_clock * bit_per_pixel * mipi_ratio / num_lanes;
          */
-        dsi->data_rate = dsi->vm.pixelclock * 3 * 21 / (1 * 1000 * 10);
+        pixel_clock = dsi->vm.pixelclock * 1000;
+        htotal = dsi->vm.hactive + dsi->vm.hback_porch + dsi->vm.hfront_porch +
+                        dsi->vm.hsync_len;
+        htotal_bits = htotal * bit_per_pixel;
+
+        overhead_cycles = T_LPX + T_HS_PREP + T_HS_ZERO + T_HS_TRAIL +
+                        T_HS_EXIT;
+        overhead_bits = overhead_cycles * dsi->lanes * 8;
+        total_bits = htotal_bits + overhead_bits;
+
+        dsi->data_rate = DIV_ROUND_UP_ULL(pixel_clock * total_bits,
+                                          htotal * dsi->lanes);
 
-        ret = clk_set_rate(dsi->hs_clk, dsi->data_rate * 1000000);
+        ret = clk_set_rate(dsi->hs_clk, dsi->data_rate);
         if (ret < 0) {
                 dev_err(dev, "Failed to set data rate: %d\n", ret);
                 goto err_refcount;
diff --git a/drivers/gpu/drm/radeon/radeon_atpx_handler.c b/drivers/gpu/drm/radeon/radeon_atpx_handler.c
index 2fdcd04bc93f..4129b12521a6 100644
--- a/drivers/gpu/drm/radeon/radeon_atpx_handler.c
+++ b/drivers/gpu/drm/radeon/radeon_atpx_handler.c
@@ -34,6 +34,7 @@ struct radeon_atpx {
 
 static struct radeon_atpx_priv {
         bool atpx_detected;
+        bool bridge_pm_usable;
         /* handle for device - and atpx */
         acpi_handle dhandle;
         struct radeon_atpx atpx;
@@ -203,7 +204,11 @@ static int radeon_atpx_validate(struct radeon_atpx *atpx)
         atpx->is_hybrid = false;
         if (valid_bits & ATPX_MS_HYBRID_GFX_SUPPORTED) {
                 printk("ATPX Hybrid Graphics\n");
-                atpx->functions.power_cntl = false;
+                /*
+                 * Disable legacy PM methods only when pcie port PM is usable,
+                 * otherwise the device might fail to power off or power on.
+                 */
+                atpx->functions.power_cntl = !radeon_atpx_priv.bridge_pm_usable;
                 atpx->is_hybrid = true;
         }
 
@@ -474,6 +479,7 @@ static int radeon_atpx_power_state(enum vga_switcheroo_client_id id,
  */
 static bool radeon_atpx_pci_probe_handle(struct pci_dev *pdev)
 {
+        struct pci_dev *parent_pdev = pci_upstream_bridge(pdev);
         acpi_handle dhandle, atpx_handle;
         acpi_status status;
 
@@ -487,6 +493,7 @@ static bool radeon_atpx_pci_probe_handle(struct pci_dev *pdev)
 
         radeon_atpx_priv.dhandle = dhandle;
         radeon_atpx_priv.atpx.handle = atpx_handle;
+        radeon_atpx_priv.bridge_pm_usable = parent_pdev && parent_pdev->bridge_d3;
         return true;
 }
 
diff --git a/drivers/hid/hid-cp2112.c b/drivers/hid/hid-cp2112.c
index 086d8a507157..60d30203a5fa 100644
--- a/drivers/hid/hid-cp2112.c
+++ b/drivers/hid/hid-cp2112.c
@@ -32,6 +32,11 @@
 #include <linux/usb/ch9.h>
 #include "hid-ids.h"
 
+#define CP2112_REPORT_MAX_LENGTH                64
+#define CP2112_GPIO_CONFIG_LENGTH               5
+#define CP2112_GPIO_GET_LENGTH                  2
+#define CP2112_GPIO_SET_LENGTH                  3
+
 enum {
         CP2112_GPIO_CONFIG              = 0x02,
         CP2112_GPIO_GET                 = 0x03,
@@ -161,6 +166,8 @@ struct cp2112_device {
         atomic_t read_avail;
         atomic_t xfer_avail;
         struct gpio_chip gc;
+        u8 *in_out_buffer;
+        spinlock_t lock;
 };
 
 static int gpio_push_pull = 0xFF;
@@ -171,62 +178,86 @@ 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[5];
+        u8 *buf = dev->in_out_buffer;
+        unsigned long flags;
         int ret;
 
+        spin_lock_irqsave(&dev->lock, flags);
+
         ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
-                                       sizeof(buf), HID_FEATURE_REPORT,
-                                       HID_REQ_GET_REPORT);
-        if (ret != sizeof(buf)) {
+                                 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
+                                 HID_REQ_GET_REPORT);
+        if (ret != CP2112_GPIO_CONFIG_LENGTH) {
                 hid_err(hdev, "error requesting GPIO config: %d\n", ret);
-                return ret;
+                goto exit;
         }
 
         buf[1] &= ~(1 << offset);
         buf[2] = gpio_push_pull;
 
-        ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf, sizeof(buf),
-                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
+        ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
+                                 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
+                                 HID_REQ_SET_REPORT);
         if (ret < 0) {
                 hid_err(hdev, "error setting GPIO config: %d\n", ret);
-                return ret;
+                goto exit;
         }
 
-        return 0;
+        ret = 0;
+
+exit:
+        spin_unlock_irqrestore(&dev->lock, flags);
+        return ret <= 0 ? ret : -EIO;
 }
 
 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[3];
+        u8 *buf = dev->in_out_buffer;
+        unsigned long flags;
         int ret;
 
+        spin_lock_irqsave(&dev->lock, flags);
+
         buf[0] = CP2112_GPIO_SET;
         buf[1] = value ? 0xff : 0;
         buf[2] = 1 << offset;
 
-        ret = hid_hw_raw_request(hdev, CP2112_GPIO_SET, buf, sizeof(buf),
-                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
+        ret = hid_hw_raw_request(hdev, CP2112_GPIO_SET, buf,
+                                 CP2112_GPIO_SET_LENGTH, HID_FEATURE_REPORT,
+                                 HID_REQ_SET_REPORT);
         if (ret < 0)
                 hid_err(hdev, "error setting GPIO values: %d\n", ret);
+
+        spin_unlock_irqrestore(&dev->lock, flags);
 }
 
 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[2];
+        u8 *buf = dev->in_out_buffer;
+        unsigned long flags;
         int ret;
 
-        ret = hid_hw_raw_request(hdev, CP2112_GPIO_GET, buf, sizeof(buf),
-                                       HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
-        if (ret != sizeof(buf)) {
+        spin_lock_irqsave(&dev->lock, flags);
+
+        ret = hid_hw_raw_request(hdev, CP2112_GPIO_GET, buf,
+                                 CP2112_GPIO_GET_LENGTH, HID_FEATURE_REPORT,
+                                 HID_REQ_GET_REPORT);
+        if (ret != CP2112_GPIO_GET_LENGTH) {
                 hid_err(hdev, "error requesting GPIO values: %d\n", ret);
-                return ret;
+                ret = ret < 0 ? ret : -EIO;
+                goto exit;
         }
 
-        return (buf[1] >> offset) & 1;
+        ret = (buf[1] >> offset) & 1;
+
+exit:
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        return ret;
 }
 
 static int cp2112_gpio_direction_output(struct gpio_chip *chip,
@@ -234,27 +265,33 @@ 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[5];
+        u8 *buf = dev->in_out_buffer;
+        unsigned long flags;
         int ret;
 
+        spin_lock_irqsave(&dev->lock, flags);
+
         ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
-                                       sizeof(buf), HID_FEATURE_REPORT,
-                                       HID_REQ_GET_REPORT);
-        if (ret != sizeof(buf)) {
+                                 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
+                                 HID_REQ_GET_REPORT);
+        if (ret != CP2112_GPIO_CONFIG_LENGTH) {
                 hid_err(hdev, "error requesting GPIO config: %d\n", ret);
-                return ret;
+                goto fail;
         }
 
         buf[1] |= 1 << offset;
         buf[2] = gpio_push_pull;
 
-        ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf, sizeof(buf),
-                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
+        ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
+                                 CP2112_GPIO_CONFIG_LENGTH, HID_FEATURE_REPORT,
+                                 HID_REQ_SET_REPORT);
         if (ret < 0) {
                 hid_err(hdev, "error setting GPIO config: %d\n", ret);
-                return ret;
+                goto fail;
         }
 
+        spin_unlock_irqrestore(&dev->lock, flags);
+
         /*
          * Set gpio value when output direction is already set,
          * as specified in AN495, Rev. 0.2, cpt. 4.4
@@ -262,6 +299,10 @@ static int cp2112_gpio_direction_output(struct gpio_chip *chip,
         cp2112_gpio_set(chip, offset, value);
 
         return 0;
+
+fail:
+        spin_unlock_irqrestore(&dev->lock, flags);
+        return ret < 0 ? ret : -EIO;
 }
 
 static int cp2112_hid_get(struct hid_device *hdev, unsigned char report_number,
@@ -1007,6 +1048,17 @@ static int cp2112_probe(struct hid_device *hdev, const struct hid_device_id *id)
         struct cp2112_smbus_config_report config;
         int ret;
 
+        dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);
+        if (!dev)
+                return -ENOMEM;
+
+        dev->in_out_buffer = devm_kzalloc(&hdev->dev, CP2112_REPORT_MAX_LENGTH,
+                                          GFP_KERNEL);
+        if (!dev->in_out_buffer)
+                return -ENOMEM;
+
+        spin_lock_init(&dev->lock);
+
         ret = hid_parse(hdev);
         if (ret) {
                 hid_err(hdev, "parse failed\n");
@@ -1063,12 +1115,6 @@ static int cp2112_probe(struct hid_device *hdev, const struct hid_device_id *id)
                 goto err_power_normal;
         }
 
-        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
-        if (!dev) {
-                ret = -ENOMEM;
-                goto err_power_normal;
-        }
-
         hid_set_drvdata(hdev, (void *)dev);
         dev->hdev               = hdev;
         dev->adap.owner         = THIS_MODULE;
@@ -1087,7 +1133,7 @@ static int cp2112_probe(struct hid_device *hdev, const struct hid_device_id *id)
 
         if (ret) {
                 hid_err(hdev, "error registering i2c adapter\n");
-                goto err_free_dev;
+                goto err_power_normal;
         }
 
         hid_dbg(hdev, "adapter registered\n");
@@ -1123,8 +1169,6 @@ err_gpiochip_remove:
         gpiochip_remove(&dev->gc);
 err_free_i2c:
         i2c_del_adapter(&dev->adap);
-err_free_dev:
-        kfree(dev);
 err_power_normal:
         hid_hw_power(hdev, PM_HINT_NORMAL);
 err_hid_close:
@@ -1149,7 +1193,6 @@ static void cp2112_remove(struct hid_device *hdev)
          */
         hid_hw_close(hdev);
         hid_hw_stop(hdev);
-        kfree(dev);
 }
 
 static int cp2112_raw_event(struct hid_device *hdev, struct hid_report *report,
diff --git a/drivers/hid/hid-lg.c b/drivers/hid/hid-lg.c
index 76f644deb0a7..c5c5fbe9d605 100644
--- a/drivers/hid/hid-lg.c
+++ b/drivers/hid/hid-lg.c
@@ -756,11 +756,16 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
 
         /* Setup wireless link with Logitech Wii wheel */
         if (hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) {
-                unsigned char buf[] = { 0x00, 0xAF,  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+                const unsigned char cbuf[] = { 0x00, 0xAF,  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+                u8 *buf = kmemdup(cbuf, sizeof(cbuf), GFP_KERNEL);
 
-                ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
-                                        HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
+                if (!buf) {
+                        ret = -ENOMEM;
+                        goto err_free;
+                }
 
+                ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(cbuf),
+                                        HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
                 if (ret >= 0) {
                         /* insert a little delay of 10 jiffies ~ 40ms */
                         wait_queue_head_t wait;
@@ -772,9 +777,10 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
                         buf[1] = 0xB2;
                         get_random_bytes(&buf[2], 2);
 
-                        ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
+                        ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(cbuf),
                                         HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
                 }
+                kfree(buf);
         }
 
         if (drv_data->quirks & LG_FF)
diff --git a/drivers/hid/hid-magicmouse.c b/drivers/hid/hid-magicmouse.c
index d6fa496d0ca2..20b40ad26325 100644
--- a/drivers/hid/hid-magicmouse.c
+++ b/drivers/hid/hid-magicmouse.c
@@ -493,7 +493,8 @@ static int magicmouse_input_configured(struct hid_device *hdev,
 static int magicmouse_probe(struct hid_device *hdev,
         const struct hid_device_id *id)
 {
-        __u8 feature[] = { 0xd7, 0x01 };
+        const u8 feature[] = { 0xd7, 0x01 };
+        u8 *buf;
         struct magicmouse_sc *msc;
         struct hid_report *report;
         int ret;
@@ -544,6 +545,12 @@ static int magicmouse_probe(struct hid_device *hdev,
         }
         report->size = 6;
 
+        buf = kmemdup(feature, sizeof(feature), GFP_KERNEL);
+        if (!buf) {
+                ret = -ENOMEM;
+                goto err_stop_hw;
+        }
+
         /*
          * Some devices repond with 'invalid report id' when feature
          * report switching it into multitouch mode is sent to it.
@@ -552,8 +559,9 @@ static int magicmouse_probe(struct hid_device *hdev,
          * but there seems to be no other way of switching the mode.
          * Thus the super-ugly hacky success check below.
          */
-        ret = hid_hw_raw_request(hdev, feature[0], feature, sizeof(feature),
+        ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(feature),
                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
+        kfree(buf);
         if (ret != -EIO && ret != sizeof(feature)) {
                 hid_err(hdev, "unable to request touch data (%d)\n", ret);
                 goto err_stop_hw;
diff --git a/drivers/hid/hid-rmi.c b/drivers/hid/hid-rmi.c
index 9cd2ca34a6be..be89bcbf6a71 100644
--- a/drivers/hid/hid-rmi.c
+++ b/drivers/hid/hid-rmi.c
@@ -188,10 +188,16 @@ static int rmi_set_page(struct hid_device *hdev, u8 page)
 static int rmi_set_mode(struct hid_device *hdev, u8 mode)
 {
         int ret;
-        u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode};
+        const u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode};
+        u8 *buf;
 
-        ret = hid_hw_raw_request(hdev, RMI_SET_RMI_MODE_REPORT_ID, txbuf,
+        buf = kmemdup(txbuf, sizeof(txbuf), GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        ret = hid_hw_raw_request(hdev, RMI_SET_RMI_MODE_REPORT_ID, buf,
                         sizeof(txbuf), HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
+        kfree(buf);
         if (ret < 0) {
                 dev_err(&hdev->dev, "unable to set rmi mode to %d (%d)\n", mode,
                         ret);
diff --git a/drivers/hid/hid-sensor-hub.c b/drivers/hid/hid-sensor-hub.c
index c5c3d6111729..60875625cbdf 100644
--- a/drivers/hid/hid-sensor-hub.c
+++ b/drivers/hid/hid-sensor-hub.c
@@ -212,6 +212,7 @@ int sensor_hub_set_feature(struct hid_sensor_hub_device *hsdev, u32 report_id,
         __s32 value;
         int ret = 0;
 
+        memset(buffer, 0, buffer_size);
         mutex_lock(&data->mutex);
         report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);
         if (!report || (field_index >= report->maxfield)) {
diff --git a/drivers/media/tuners/tuner-xc2028.c b/drivers/media/tuners/tuner-xc2028.c
index 317ef63ee789..8d96a22647b3 100644
--- a/drivers/media/tuners/tuner-xc2028.c
+++ b/drivers/media/tuners/tuner-xc2028.c
@@ -281,6 +281,14 @@ static void free_firmware(struct xc2028_data *priv)
         int i;
         tuner_dbg("%s called\n", __func__);
 
+        /* free allocated f/w string */
+        if (priv->fname != firmware_name)
+                kfree(priv->fname);
+        priv->fname = NULL;
+
+        priv->state = XC2028_NO_FIRMWARE;
+        memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
+
         if (!priv->firm)
                 return;
 
@@ -291,9 +299,6 @@ static void free_firmware(struct xc2028_data *priv)
 
         priv->firm = NULL;
         priv->firm_size = 0;
-        priv->state = XC2028_NO_FIRMWARE;
-
-        memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
 }
 
 static int load_all_firmwares(struct dvb_frontend *fe,
@@ -884,9 +889,8 @@ read_not_reliable:
         return 0;
 
 fail:
-        priv->state = XC2028_NO_FIRMWARE;
+        free_firmware(priv);
 
-        memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
         if (retry_count < 8) {
                 msleep(50);
                 retry_count++;
@@ -1332,11 +1336,8 @@ static int xc2028_dvb_release(struct dvb_frontend *fe)
         mutex_lock(&xc2028_list_mutex);
 
         /* only perform final cleanup if this is the last instance */
-        if (hybrid_tuner_report_instance_count(priv) == 1) {
+        if (hybrid_tuner_report_instance_count(priv) == 1)
                 free_firmware(priv);
-                kfree(priv->ctrl.fname);
-                priv->ctrl.fname = NULL;
-        }
 
         if (priv)
                 hybrid_tuner_release_state(priv);
@@ -1399,19 +1400,8 @@ static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg)
 
         /*
          * Copy the config data.
-         * For the firmware name, keep a local copy of the string,
-         * in order to avoid troubles during device release.
          */
-        kfree(priv->ctrl.fname);
-        priv->ctrl.fname = NULL;
         memcpy(&priv->ctrl, p, sizeof(priv->ctrl));
-        if (p->fname) {
-                priv->ctrl.fname = kstrdup(p->fname, GFP_KERNEL);
-                if (priv->ctrl.fname == NULL) {
-                        rc = -ENOMEM;
-                        goto unlock;
-                }
-        }
 
         /*
          * If firmware name changed, frees firmware. As free_firmware will
@@ -1426,10 +1416,15 @@ static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg)
 
         if (priv->state == XC2028_NO_FIRMWARE) {
                 if (!firmware_name[0])
-                        priv->fname = priv->ctrl.fname;
+                        priv->fname = kstrdup(p->fname, GFP_KERNEL);
                 else
                         priv->fname = firmware_name;
 
+                if (!priv->fname) {
+                        rc = -ENOMEM;
+                        goto unlock;
+                }
+
                 rc = request_firmware_nowait(THIS_MODULE, 1,
                                              priv->fname,
                                              priv->i2c_props.adap->dev.parent,
diff --git a/drivers/mfd/syscon.c b/drivers/mfd/syscon.c
index 2f2225e845ef..b93fe4c4957a 100644
--- a/drivers/mfd/syscon.c
+++ b/drivers/mfd/syscon.c
@@ -73,8 +73,10 @@ static struct syscon *of_syscon_register(struct device_node *np)
         /* Parse the device's DT node for an endianness specification */
         if (of_property_read_bool(np, "big-endian"))
                 syscon_config.val_format_endian = REGMAP_ENDIAN_BIG;
-         else if (of_property_read_bool(np, "little-endian"))
+        else if (of_property_read_bool(np, "little-endian"))
                 syscon_config.val_format_endian = REGMAP_ENDIAN_LITTLE;
+        else if (of_property_read_bool(np, "native-endian"))
+                syscon_config.val_format_endian = REGMAP_ENDIAN_NATIVE;
 
         /*
          * search for reg-io-width property in DT. If it is not provided,
diff --git a/drivers/mfd/wm8994-core.c b/drivers/mfd/wm8994-core.c
index 7eec619a6023..8588dbad3301 100644
--- a/drivers/mfd/wm8994-core.c
+++ b/drivers/mfd/wm8994-core.c
@@ -393,8 +393,13 @@ static int wm8994_device_init(struct wm8994 *wm8994, int irq)
                 BUG();
                 goto err;
         }
-                
-        ret = devm_regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
+
+        /*
+         * Can't use devres helper here as some of the supplies are provided by
+         * wm8994->dev's children (regulators) and those regulators are
+         * unregistered by the devres core before the supplies are freed.
+         */
+        ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
                                  wm8994->supplies);
         if (ret != 0) {
                 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
@@ -405,7 +410,7 @@ static int wm8994_device_init(struct wm8994 *wm8994, int irq)
                                     wm8994->supplies);
         if (ret != 0) {
                 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
-                goto err;
+                goto err_regulator_free;
         }
 
         ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
@@ -596,6 +601,8 @@ err_irq:
 err_enable:
         regulator_bulk_disable(wm8994->num_supplies,
                                wm8994->supplies);
+err_regulator_free:
+        regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
 err:
         mfd_remove_devices(wm8994->dev);
         return ret;
@@ -604,10 +611,11 @@ err:
 static void wm8994_device_exit(struct wm8994 *wm8994)
 {
         pm_runtime_disable(wm8994->dev);
-        mfd_remove_devices(wm8994->dev);
         wm8994_irq_exit(wm8994);
         regulator_bulk_disable(wm8994->num_supplies,
                                wm8994->supplies);
+        regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
+        mfd_remove_devices(wm8994->dev);
 }
 
 static const struct of_device_id wm8994_of_match[] = {
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 50a674be6655..df478ae72e23 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -1058,6 +1058,7 @@ static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
         spin_unlock_irqrestore(&host->irq_lock, irqflags);
 
         if (host->dma_ops->start(host, sg_len)) {
+                host->dma_ops->stop(host);
                 /* We can't do DMA, try PIO for this one */
                 dev_dbg(host->dev,
                         "%s: fall back to PIO mode for current transfer\n",
diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c
index fb71c866eacc..1bb11e4a9fe5 100644
--- a/drivers/mmc/host/sdhci-of-esdhc.c
+++ b/drivers/mmc/host/sdhci-of-esdhc.c
@@ -66,6 +66,20 @@ static u32 esdhc_readl_fixup(struct sdhci_host *host,
                         return ret;
                 }
         }
+        /*
+         * The DAT[3:0] line signal levels and the CMD line signal level are
+         * not compatible with standard SDHC register. The line signal levels
+         * DAT[7:0] are at bits 31:24 and the command line signal level is at
+         * bit 23. All other bits are the same as in the standard SDHC
+         * register.
+         */
+        if (spec_reg == SDHCI_PRESENT_STATE) {
+                ret = value & 0x000fffff;
+                ret |= (value >> 4) & SDHCI_DATA_LVL_MASK;
+                ret |= (value << 1) & SDHCI_CMD_LVL;
+                return ret;
+        }
+
         ret = value;
         return ret;
 }
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 766df17fb7eb..2570455b219a 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -73,6 +73,7 @@
 #define  SDHCI_DATA_LVL_MASK    0x00F00000
 #define   SDHCI_DATA_LVL_SHIFT  20
 #define   SDHCI_DATA_0_LVL_MASK 0x00100000
+#define  SDHCI_CMD_LVL          0x01000000
 
 #define SDHCI_HOST_CONTROL      0x28
 #define  SDHCI_CTRL_LED         0x01
diff --git a/drivers/phy/phy-twl4030-usb.c b/drivers/phy/phy-twl4030-usb.c
index 87e6334eab93..547ca7b3f098 100644
--- a/drivers/phy/phy-twl4030-usb.c
+++ b/drivers/phy/phy-twl4030-usb.c
@@ -459,8 +459,6 @@ static int twl4030_phy_power_off(struct phy *phy)
         struct twl4030_usb *twl = phy_get_drvdata(phy);
 
         dev_dbg(twl->dev, "%s\n", __func__);
-        pm_runtime_mark_last_busy(twl->dev);
-        pm_runtime_put_autosuspend(twl->dev);
 
         return 0;
 }
@@ -472,6 +470,8 @@ static int twl4030_phy_power_on(struct phy *phy)
         dev_dbg(twl->dev, "%s\n", __func__);
         pm_runtime_get_sync(twl->dev);
         schedule_delayed_work(&twl->id_workaround_work, HZ);
+        pm_runtime_mark_last_busy(twl->dev);
+        pm_runtime_put_autosuspend(twl->dev);
 
         return 0;
 }
diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
index 8aa769a2d919..91b70bc46e7f 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
@@ -4010,7 +4010,10 @@ _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
             SAM_STAT_CHECK_CONDITION;
 }
 
-
+static inline bool ata_12_16_cmd(struct scsi_cmnd *scmd)
+{
+        return (scmd->cmnd[0] == ATA_12 || scmd->cmnd[0] == ATA_16);
+}
 
 /**
  * scsih_qcmd - main scsi request entry point
@@ -4038,6 +4041,13 @@ scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
         if (ioc->logging_level & MPT_DEBUG_SCSI)
                 scsi_print_command(scmd);
 
+        /*
+         * Lock the device for any subsequent command until command is
+         * done.
+         */
+        if (ata_12_16_cmd(scmd))
+                scsi_internal_device_block(scmd->device);
+
         sas_device_priv_data = scmd->device->hostdata;
         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
                 scmd->result = DID_NO_CONNECT << 16;
@@ -4613,6 +4623,9 @@ _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
         if (scmd == NULL)
                 return 1;
 
+        if (ata_12_16_cmd(scmd))
+                scsi_internal_device_unblock(scmd->device, SDEV_RUNNING);
+
         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
 
         if (mpi_reply == NULL) {
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 567fa080e261..56d6142852a5 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1456,15 +1456,20 @@ qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res)
                 for (cnt = 1; cnt < req->num_outstanding_cmds; cnt++) {
                         sp = req->outstanding_cmds[cnt];
                         if (sp) {
-                                /* Get a reference to the sp and drop the lock.
-                                 * The reference ensures this sp->done() call
-                                 * - and not the call in qla2xxx_eh_abort() -
-                                 * ends the SCSI command (with result 'res').
+                                /* Don't abort commands in adapter during EEH
+                                 * recovery as it's not accessible/responding.
                                  */
-                                sp_get(sp);
-                                spin_unlock_irqrestore(&ha->hardware_lock, flags);
-                                qla2xxx_eh_abort(GET_CMD_SP(sp));
-                                spin_lock_irqsave(&ha->hardware_lock, flags);
+                                if (!ha->flags.eeh_busy) {
+                                        /* Get a reference to the sp and drop the lock.
+                                         * The reference ensures this sp->done() call
+                                         * - and not the call in qla2xxx_eh_abort() -
+                                         * ends the SCSI command (with result 'res').
+                                         */
+                                        sp_get(sp);
+                                        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+                                        qla2xxx_eh_abort(GET_CMD_SP(sp));
+                                        spin_lock_irqsave(&ha->hardware_lock, flags);
+                                }
                                 req->outstanding_cmds[cnt] = NULL;
                                 sp->done(vha, sp, res);
                         }
diff --git a/drivers/thermal/intel_powerclamp.c b/drivers/thermal/intel_powerclamp.c
index 7a223074df3d..afada655f861 100644
--- a/drivers/thermal/intel_powerclamp.c
+++ b/drivers/thermal/intel_powerclamp.c
@@ -669,9 +669,16 @@ static struct thermal_cooling_device_ops powerclamp_cooling_ops = {
         .set_cur_state = powerclamp_set_cur_state,
 };
 
+static const struct x86_cpu_id __initconst intel_powerclamp_ids[] = {
+        { X86_VENDOR_INTEL, X86_FAMILY_ANY, X86_MODEL_ANY, X86_FEATURE_MWAIT },
+        {}
+};
+MODULE_DEVICE_TABLE(x86cpu, intel_powerclamp_ids);
+
 static int __init powerclamp_probe(void)
 {
-        if (!boot_cpu_has(X86_FEATURE_MWAIT)) {
+
+        if (!x86_match_cpu(intel_powerclamp_ids)) {
                 pr_err("CPU does not support MWAIT");
                 return -ENODEV;
         }
diff --git a/drivers/usb/chipidea/core.c b/drivers/usb/chipidea/core.c
index 69426e644d17..3dbb4a21ab44 100644
--- a/drivers/usb/chipidea/core.c
+++ b/drivers/usb/chipidea/core.c
@@ -914,6 +914,7 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         if (!ci)
                 return -ENOMEM;
 
+        spin_lock_init(&ci->lock);
         ci->dev = dev;
         ci->platdata = dev_get_platdata(dev);
         ci->imx28_write_fix = !!(ci->platdata->flags &
diff --git a/drivers/usb/chipidea/udc.c b/drivers/usb/chipidea/udc.c
index 661f43fe0f9e..c9e80ad48fdc 100644
--- a/drivers/usb/chipidea/udc.c
+++ b/drivers/usb/chipidea/udc.c
@@ -1889,8 +1889,6 @@ static int udc_start(struct ci_hdrc *ci)
         struct usb_otg_caps *otg_caps = &ci->platdata->ci_otg_caps;
         int retval = 0;
 
-        spin_lock_init(&ci->lock);
-
         ci->gadget.ops          = &usb_gadget_ops;
         ci->gadget.speed        = USB_SPEED_UNKNOWN;
         ci->gadget.max_speed    = USB_SPEED_HIGH;
diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c
index e40d47d47d82..17989b72cdae 100644
--- a/drivers/usb/gadget/function/f_fs.c
+++ b/drivers/usb/gadget/function/f_fs.c
@@ -3225,11 +3225,11 @@ static bool ffs_func_req_match(struct usb_function *f,
 
         switch (creq->bRequestType & USB_RECIP_MASK) {
         case USB_RECIP_INTERFACE:
-                return ffs_func_revmap_intf(func,
-                                            le16_to_cpu(creq->wIndex) >= 0);
+                return (ffs_func_revmap_intf(func,
+                                             le16_to_cpu(creq->wIndex)) >= 0);
         case USB_RECIP_ENDPOINT:
-                return ffs_func_revmap_ep(func,
-                                          le16_to_cpu(creq->wIndex) >= 0);
+                return (ffs_func_revmap_ep(func,
+                                           le16_to_cpu(creq->wIndex)) >= 0);
         default:
                 return (bool) (func->ffs->user_flags &
                                FUNCTIONFS_ALL_CTRL_RECIP);
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index e01116e4c067..c3e172e15ec3 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -986,7 +986,7 @@ b_host:
         }
 #endif
 
-        schedule_work(&musb->irq_work);
+        schedule_delayed_work(&musb->irq_work, 0);
 
         return handled;
 }
@@ -1855,14 +1855,23 @@ static void musb_pm_runtime_check_session(struct musb *musb)
                 MUSB_DEVCTL_HR;
         switch (devctl & ~s) {
         case MUSB_QUIRK_B_INVALID_VBUS_91:
-                if (!musb->session && !musb->quirk_invalid_vbus) {
-                        musb->quirk_invalid_vbus = true;
+                if (musb->quirk_retries--) {
                         musb_dbg(musb,
-                                 "First invalid vbus, assume no session");
+                                 "Poll devctl on invalid vbus, assume no session");
+                        schedule_delayed_work(&musb->irq_work,
+                                              msecs_to_jiffies(1000));
+
                         return;
                 }
-                break;
         case MUSB_QUIRK_A_DISCONNECT_19:
+                if (musb->quirk_retries--) {
+                        musb_dbg(musb,
+                                 "Poll devctl on possible host mode disconnect");
+                        schedule_delayed_work(&musb->irq_work,
+                                              msecs_to_jiffies(1000));
+
+                        return;
+                }
                 if (!musb->session)
                         break;
                 musb_dbg(musb, "Allow PM on possible host mode disconnect");
@@ -1886,9 +1895,9 @@ static void musb_pm_runtime_check_session(struct musb *musb)
                 if (error < 0)
                         dev_err(musb->controller, "Could not enable: %i\n",
                                 error);
+                musb->quirk_retries = 3;
         } else {
                 musb_dbg(musb, "Allow PM with no session: %02x", devctl);
-                musb->quirk_invalid_vbus = false;
                 pm_runtime_mark_last_busy(musb->controller);
                 pm_runtime_put_autosuspend(musb->controller);
         }
@@ -1899,7 +1908,7 @@ static void musb_pm_runtime_check_session(struct musb *musb)
 /* Only used to provide driver mode change events */
 static void musb_irq_work(struct work_struct *data)
 {
-        struct musb *musb = container_of(data, struct musb, irq_work);
+        struct musb *musb = container_of(data, struct musb, irq_work.work);
 
         musb_pm_runtime_check_session(musb);
 
@@ -1969,6 +1978,7 @@ static struct musb *allocate_instance(struct device *dev,
         INIT_LIST_HEAD(&musb->control);
         INIT_LIST_HEAD(&musb->in_bulk);
         INIT_LIST_HEAD(&musb->out_bulk);
+        INIT_LIST_HEAD(&musb->pending_list);
 
         musb->vbuserr_retry = VBUSERR_RETRY_COUNT;
         musb->a_wait_bcon = OTG_TIME_A_WAIT_BCON;
@@ -2018,6 +2028,84 @@ static void musb_free(struct musb *musb)
         musb_host_free(musb);
 }
 
+struct musb_pending_work {
+        int (*callback)(struct musb *musb, void *data);
+        void *data;
+        struct list_head node;
+};
+
+/*
+ * Called from musb_runtime_resume(), musb_resume(), and
+ * musb_queue_resume_work(). Callers must take musb->lock.
+ */
+static int musb_run_resume_work(struct musb *musb)
+{
+        struct musb_pending_work *w, *_w;
+        unsigned long flags;
+        int error = 0;
+
+        spin_lock_irqsave(&musb->list_lock, flags);
+        list_for_each_entry_safe(w, _w, &musb->pending_list, node) {
+                if (w->callback) {
+                        error = w->callback(musb, w->data);
+                        if (error < 0) {
+                                dev_err(musb->controller,
+                                        "resume callback %p failed: %i\n",
+                                        w->callback, error);
+                        }
+                }
+                list_del(&w->node);
+                devm_kfree(musb->controller, w);
+        }
+        spin_unlock_irqrestore(&musb->list_lock, flags);
+
+        return error;
+}
+
+/*
+ * Called to run work if device is active or else queue the work to happen
+ * on resume. Caller must take musb->lock and must hold an RPM reference.
+ *
+ * Note that we cowardly refuse queuing work after musb PM runtime
+ * resume is done calling musb_run_resume_work() and return -EINPROGRESS
+ * instead.
+ */
+int musb_queue_resume_work(struct musb *musb,
+                           int (*callback)(struct musb *musb, void *data),
+                           void *data)
+{
+        struct musb_pending_work *w;
+        unsigned long flags;
+        int error;
+
+        if (WARN_ON(!callback))
+                return -EINVAL;
+
+        if (pm_runtime_active(musb->controller))
+                return callback(musb, data);
+
+        w = devm_kzalloc(musb->controller, sizeof(*w), GFP_ATOMIC);
+        if (!w)
+                return -ENOMEM;
+
+        w->callback = callback;
+        w->data = data;
+        spin_lock_irqsave(&musb->list_lock, flags);
+        if (musb->is_runtime_suspended) {
+                list_add_tail(&w->node, &musb->pending_list);
+                error = 0;
+        } else {
+                dev_err(musb->controller, "could not add resume work %p\n",
+                        callback);
+                devm_kfree(musb->controller, w);
+                error = -EINPROGRESS;
+        }
+        spin_unlock_irqrestore(&musb->list_lock, flags);
+
+        return error;
+}
+EXPORT_SYMBOL_GPL(musb_queue_resume_work);
+
 static void musb_deassert_reset(struct work_struct *work)
 {
         struct musb *musb;
@@ -2065,6 +2153,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
         }
 
         spin_lock_init(&musb->lock);
+        spin_lock_init(&musb->list_lock);
         musb->board_set_power = plat->set_power;
         musb->min_power = plat->min_power;
         musb->ops = plat->platform_ops;
@@ -2208,7 +2297,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
         musb_generic_disable(musb);
 
         /* Init IRQ workqueue before request_irq */
-        INIT_WORK(&musb->irq_work, musb_irq_work);
+        INIT_DELAYED_WORK(&musb->irq_work, musb_irq_work);
         INIT_DELAYED_WORK(&musb->deassert_reset_work, musb_deassert_reset);
         INIT_DELAYED_WORK(&musb->finish_resume_work, musb_host_finish_resume);
 
@@ -2291,6 +2380,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
         if (status)
                 goto fail5;
 
+        musb->is_initialized = 1;
         pm_runtime_mark_last_busy(musb->controller);
         pm_runtime_put_autosuspend(musb->controller);
 
@@ -2304,7 +2394,7 @@ fail4:
         musb_host_cleanup(musb);
 
 fail3:
-        cancel_work_sync(&musb->irq_work);
+        cancel_delayed_work_sync(&musb->irq_work);
         cancel_delayed_work_sync(&musb->finish_resume_work);
         cancel_delayed_work_sync(&musb->deassert_reset_work);
         if (musb->dma_controller)
@@ -2371,7 +2461,7 @@ static int musb_remove(struct platform_device *pdev)
          */
         musb_exit_debugfs(musb);
 
-        cancel_work_sync(&musb->irq_work);
+        cancel_delayed_work_sync(&musb->irq_work);
         cancel_delayed_work_sync(&musb->finish_resume_work);
         cancel_delayed_work_sync(&musb->deassert_reset_work);
         pm_runtime_get_sync(musb->controller);
@@ -2557,6 +2647,7 @@ static int musb_suspend(struct device *dev)
 
         musb_platform_disable(musb);
         musb_generic_disable(musb);
+        WARN_ON(!list_empty(&musb->pending_list));
 
         spin_lock_irqsave(&musb->lock, flags);
 
@@ -2578,9 +2669,11 @@ static int musb_suspend(struct device *dev)
 
 static int musb_resume(struct device *dev)
 {
-        struct musb     *musb = dev_to_musb(dev);
-        u8              devctl;
-        u8              mask;
+        struct musb *musb = dev_to_musb(dev);
+        unsigned long flags;
+        int error;
+        u8 devctl;
+        u8 mask;
 
         /*
          * For static cmos like DaVinci, register values were preserved
@@ -2614,6 +2707,13 @@ static int musb_resume(struct device *dev)
 
         musb_start(musb);
 
+        spin_lock_irqsave(&musb->lock, flags);
+        error = musb_run_resume_work(musb);
+        if (error)
+                dev_err(musb->controller, "resume work failed with %i\n",
+                        error);
+        spin_unlock_irqrestore(&musb->lock, flags);
+
         return 0;
 }
 
@@ -2622,14 +2722,16 @@ static int musb_runtime_suspend(struct device *dev)
         struct musb     *musb = dev_to_musb(dev);
 
         musb_save_context(musb);
+        musb->is_runtime_suspended = 1;
 
         return 0;
 }
 
 static int musb_runtime_resume(struct device *dev)
 {
-        struct musb     *musb = dev_to_musb(dev);
-        static int      first = 1;
+        struct musb *musb = dev_to_musb(dev);
+        unsigned long flags;
+        int error;
 
         /*
          * When pm_runtime_get_sync called for the first time in driver
@@ -2640,9 +2742,10 @@ static int musb_runtime_resume(struct device *dev)
          * Also context restore without save does not make
          * any sense
          */
-        if (!first)
-                musb_restore_context(musb);
-        first = 0;
+        if (!musb->is_initialized)
+                return 0;
+
+        musb_restore_context(musb);
 
         if (musb->need_finish_resume) {
                 musb->need_finish_resume = 0;
@@ -2650,6 +2753,14 @@ static int musb_runtime_resume(struct device *dev)
                                 msecs_to_jiffies(USB_RESUME_TIMEOUT));
         }
 
+        spin_lock_irqsave(&musb->lock, flags);
+        error = musb_run_resume_work(musb);
+        if (error)
+                dev_err(musb->controller, "resume work failed with %i\n",
+                        error);
+        musb->is_runtime_suspended = 0;
+        spin_unlock_irqrestore(&musb->lock, flags);
+
         return 0;
 }
 
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 2cb88a498f8a..91817d77d59c 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -303,13 +303,14 @@ struct musb_context_registers {
 struct musb {
         /* device lock */
         spinlock_t              lock;
+        spinlock_t              list_lock;      /* resume work list lock */
 
         struct musb_io          io;
         const struct musb_platform_ops *ops;
         struct musb_context_registers context;
 
         irqreturn_t             (*isr)(int, void *);
-        struct work_struct      irq_work;
+        struct delayed_work     irq_work;
         struct delayed_work     deassert_reset_work;
         struct delayed_work     finish_resume_work;
         struct delayed_work     gadget_work;
@@ -337,6 +338,7 @@ struct musb {
         struct list_head        control;        /* of musb_qh */
         struct list_head        in_bulk;        /* of musb_qh */
         struct list_head        out_bulk;       /* of musb_qh */
+        struct list_head        pending_list;   /* pending work list */
 
         struct timer_list       otg_timer;
         struct notifier_block   nb;
@@ -379,12 +381,15 @@ struct musb {
 
         int                     port_mode;      /* MUSB_PORT_MODE_* */
         bool                    session;
-        bool                    quirk_invalid_vbus;
+        unsigned long           quirk_retries;
         bool                    is_host;
 
         int                     a_wait_bcon;    /* VBUS timeout in msecs */
         unsigned long           idle_timeout;   /* Next timeout in jiffies */
 
+        unsigned                is_initialized:1;
+        unsigned                is_runtime_suspended:1;
+
         /* active means connected and not suspended */
         unsigned                is_active:1;
 
@@ -540,6 +545,10 @@ extern irqreturn_t musb_interrupt(struct musb *);
 
 extern void musb_hnp_stop(struct musb *musb);
 
+int musb_queue_resume_work(struct musb *musb,
+                           int (*callback)(struct musb *musb, void *data),
+                           void *data);
+
 static inline void musb_platform_set_vbus(struct musb *musb, int is_on)
 {
         if (musb->ops->set_vbus)
diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c
index 0f17d2140db6..feae1561b9ab 100644
--- a/drivers/usb/musb/musb_dsps.c
+++ b/drivers/usb/musb/musb_dsps.c
@@ -185,24 +185,19 @@ static void dsps_musb_disable(struct musb *musb)
         musb_writel(reg_base, wrp->coreintr_clear, wrp->usb_bitmap);
         musb_writel(reg_base, wrp->epintr_clear,
                          wrp->txep_bitmap | wrp->rxep_bitmap);
+        del_timer_sync(&glue->timer);
         musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
 }
 
-static void otg_timer(unsigned long _musb)
+/* Caller must take musb->lock */
+static int dsps_check_status(struct musb *musb, void *unused)
 {
-        struct musb *musb = (void *)_musb;
         void __iomem *mregs = musb->mregs;
         struct device *dev = musb->controller;
         struct dsps_glue *glue = dev_get_drvdata(dev->parent);
         const struct dsps_musb_wrapper *wrp = glue->wrp;
         u8 devctl;
-        unsigned long flags;
         int skip_session = 0;
-        int err;
-
-        err = pm_runtime_get_sync(dev);
-        if (err < 0)
-                dev_err(dev, "Poll could not pm_runtime_get: %i\n", err);
 
         /*
          * We poll because DSPS IP's won't expose several OTG-critical
@@ -212,7 +207,6 @@ static void otg_timer(unsigned long _musb)
         dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,
                                 usb_otg_state_string(musb->xceiv->otg->state));
 
-        spin_lock_irqsave(&musb->lock, flags);
         switch (musb->xceiv->otg->state) {
         case OTG_STATE_A_WAIT_VRISE:
                 mod_timer(&glue->timer, jiffies +
@@ -245,8 +239,30 @@ static void otg_timer(unsigned long _musb)
         default:
                 break;
         }
-        spin_unlock_irqrestore(&musb->lock, flags);
 
+        return 0;
+}
+
+static void otg_timer(unsigned long _musb)
+{
+        struct musb *musb = (void *)_musb;
+        struct device *dev = musb->controller;
+        unsigned long flags;
+        int err;
+
+        err = pm_runtime_get(dev);
+        if ((err != -EINPROGRESS) && err < 0) {
+                dev_err(dev, "Poll could not pm_runtime_get: %i\n", err);
+                pm_runtime_put_noidle(dev);
+
+                return;
+        }
+
+        spin_lock_irqsave(&musb->lock, flags);
+        err = musb_queue_resume_work(musb, dsps_check_status, NULL);
+        if (err < 0)
+                dev_err(dev, "%s resume work: %i\n", __func__, err);
+        spin_unlock_irqrestore(&musb->lock, flags);
         pm_runtime_mark_last_busy(dev);
         pm_runtime_put_autosuspend(dev);
 }
@@ -767,28 +783,13 @@ static int dsps_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, glue);
         pm_runtime_enable(&pdev->dev);
-        pm_runtime_use_autosuspend(&pdev->dev);
-        pm_runtime_set_autosuspend_delay(&pdev->dev, 200);
-
-        ret = pm_runtime_get_sync(&pdev->dev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "pm_runtime_get_sync FAILED");
-                goto err2;
-        }
-
         ret = dsps_create_musb_pdev(glue, pdev);
         if (ret)
-                goto err3;
-
-        pm_runtime_mark_last_busy(&pdev->dev);
-        pm_runtime_put_autosuspend(&pdev->dev);
+                goto err;
 
         return 0;
 
-err3:
-        pm_runtime_put_sync(&pdev->dev);
-err2:
-        pm_runtime_dont_use_autosuspend(&pdev->dev);
+err:
         pm_runtime_disable(&pdev->dev);
         return ret;
 }
@@ -799,9 +800,6 @@ static int dsps_remove(struct platform_device *pdev)
 
         platform_device_unregister(glue->musb);
 
-        /* disable usbss clocks */
-        pm_runtime_dont_use_autosuspend(&pdev->dev);
-        pm_runtime_put_sync(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
 
         return 0;
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 4042ea017985..a55173c9e564 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1114,7 +1114,7 @@ static int musb_gadget_enable(struct usb_ep *ep,
                         musb_ep->dma ? "dma, " : "",
                         musb_ep->packet_sz);
 
-        schedule_work(&musb->irq_work);
+        schedule_delayed_work(&musb->irq_work, 0);
 
 fail:
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -1158,7 +1158,7 @@ static int musb_gadget_disable(struct usb_ep *ep)
         musb_ep->desc = NULL;
         musb_ep->end_point.desc = NULL;
 
-        schedule_work(&musb->irq_work);
+        schedule_delayed_work(&musb->irq_work, 0);
 
         spin_unlock_irqrestore(&(musb->lock), flags);
 
@@ -1222,13 +1222,22 @@ void musb_ep_restart(struct musb *musb, struct musb_request *req)
                 rxstate(musb, req);
 }
 
+static int musb_ep_restart_resume_work(struct musb *musb, void *data)
+{
+        struct musb_request *req = data;
+
+        musb_ep_restart(musb, req);
+
+        return 0;
+}
+
 static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
                         gfp_t gfp_flags)
 {
         struct musb_ep          *musb_ep;
         struct musb_request     *request;
         struct musb             *musb;
-        int                     status = 0;
+        int                     status;
         unsigned long           lockflags;
 
         if (!ep || !req)
@@ -1245,6 +1254,17 @@ static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
         if (request->ep != musb_ep)
                 return -EINVAL;
 
+        status = pm_runtime_get(musb->controller);
+        if ((status != -EINPROGRESS) && status < 0) {
+                dev_err(musb->controller,
+                        "pm runtime get failed in %s\n",
+                        __func__);
+                pm_runtime_put_noidle(musb->controller);
+
+                return status;
+        }
+        status = 0;
+
         trace_musb_req_enq(request);
 
         /* request is mine now... */
@@ -1255,7 +1275,6 @@ static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
 
         map_dma_buffer(request, musb, musb_ep);
 
-        pm_runtime_get_sync(musb->controller);
         spin_lock_irqsave(&musb->lock, lockflags);
 
         /* don't queue if the ep is down */
@@ -1271,8 +1290,14 @@ static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
         list_add_tail(&request->list, &musb_ep->req_list);
 
         /* it this is the head of the queue, start i/o ... */
-        if (!musb_ep->busy && &request->list == musb_ep->req_list.next)
-                musb_ep_restart(musb, request);
+        if (!musb_ep->busy && &request->list == musb_ep->req_list.next) {
+                status = musb_queue_resume_work(musb,
+                                                musb_ep_restart_resume_work,
+                                                request);
+                if (status < 0)
+                        dev_err(musb->controller, "%s resume work: %i\n",
+                                __func__, status);
+        }
 
 unlock:
         spin_unlock_irqrestore(&musb->lock, lockflags);
@@ -1969,7 +1994,7 @@ static int musb_gadget_stop(struct usb_gadget *g)
          */
 
         /* Force check of devctl register for PM runtime */
-        schedule_work(&musb->irq_work);
+        schedule_delayed_work(&musb->irq_work, 0);
 
         pm_runtime_mark_last_busy(musb->controller);
         pm_runtime_put_autosuspend(musb->controller);
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index cc1225485509..e8be8e39ab8f 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -513,17 +513,18 @@ static int omap2430_probe(struct platform_device *pdev)
         }
 
         pm_runtime_enable(glue->dev);
-        pm_runtime_use_autosuspend(glue->dev);
-        pm_runtime_set_autosuspend_delay(glue->dev, 100);
 
         ret = platform_device_add(musb);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register musb device\n");
-                goto err2;
+                goto err3;
         }
 
         return 0;
 
+err3:
+        pm_runtime_disable(glue->dev);
+
 err2:
         platform_device_put(musb);
 
@@ -535,10 +536,7 @@ static int omap2430_remove(struct platform_device *pdev)
 {
         struct omap2430_glue *glue = platform_get_drvdata(pdev);
 
-        pm_runtime_get_sync(glue->dev);
         platform_device_unregister(glue->musb);
-        pm_runtime_put_sync(glue->dev);
-        pm_runtime_dont_use_autosuspend(glue->dev);
         pm_runtime_disable(glue->dev);
 
         return 0;
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index df7c9f46be54..e85cc8e4e7a9 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -724,7 +724,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                         dev_dbg(musb->controller, "vbus change, %s, otg %03x\n",
                                 usb_otg_state_string(musb->xceiv->otg->state), otg_stat);
                         idle_timeout = jiffies + (1 * HZ);
-                        schedule_work(&musb->irq_work);
+                        schedule_delayed_work(&musb->irq_work, 0);
 
                 } else /* A-dev state machine */ {
                         dev_dbg(musb->controller, "vbus change, %s, otg %03x\n",
@@ -814,7 +814,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                         break;
                 }
         }
-        schedule_work(&musb->irq_work);
+        schedule_delayed_work(&musb->irq_work, 0);
 
         return idle_timeout;
 }
@@ -864,7 +864,7 @@ static irqreturn_t tusb_musb_interrupt(int irq, void *__hci)
                 musb_writel(tbase, TUSB_PRCM_WAKEUP_CLEAR, reg);
                 if (reg & ~TUSB_PRCM_WNORCS) {
                         musb->is_active = 1;
-                        schedule_work(&musb->irq_work);
+                        schedule_delayed_work(&musb->irq_work, 0);
                 }
                 dev_dbg(musb->controller, "wake %sactive %02x\n",
                                 musb->is_active ? "" : "in", reg);
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index f61477bed3a8..243ac5ebe46a 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -131,6 +131,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x10C4, 0x88A4) }, /* MMB Networks ZigBee USB Device */
         { USB_DEVICE(0x10C4, 0x88A5) }, /* Planet Innovation Ingeni ZigBee USB Device */
         { USB_DEVICE(0x10C4, 0x8946) }, /* Ketra N1 Wireless Interface */
+        { USB_DEVICE(0x10C4, 0x8962) }, /* Brim Brothers charging dock */
         { USB_DEVICE(0x10C4, 0x8977) }, /* CEL MeshWorks DevKit Device */
         { USB_DEVICE(0x10C4, 0x8998) }, /* KCF Technologies PRN */
         { USB_DEVICE(0x10C4, 0x8A2A) }, /* HubZ dual ZigBee and Z-Wave dongle */
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 0ff7f38d7800..6e9fc8bcc285 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -1012,6 +1012,8 @@ static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(ICPDAS_VID, ICPDAS_I7561U_PID) },
         { USB_DEVICE(ICPDAS_VID, ICPDAS_I7563U_PID) },
         { USB_DEVICE(WICED_VID, WICED_USB20706V2_PID) },
+        { USB_DEVICE(TI_VID, TI_CC3200_LAUNCHPAD_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         { }                                     /* Terminating entry */
 };
 
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 21011c0a4c64..48ee04c94a75 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -596,6 +596,12 @@
 #define STK541_PID              0x2109 /* Zigbee Controller */
 
 /*
+ * Texas Instruments
+ */
+#define TI_VID                  0x0451
+#define TI_CC3200_LAUNCHPAD_PID 0xC32A /* SimpleLink Wi-Fi CC3200 LaunchPad */
+
+/*
  * Blackfin gnICE JTAG
  * http://docs.blackfin.uclinux.org/doku.php?id=hw:jtag:gnice
  */
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index ffd086733421..1a59f335b063 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -954,10 +954,15 @@ int usb_stor_CB_transport(struct scsi_cmnd *srb, struct us_data *us)
 
         /* COMMAND STAGE */
         /* let's send the command via the control pipe */
+        /*
+         * Command is sometime (f.e. after scsi_eh_prep_cmnd) on the stack.
+         * Stack may be vmallocated.  So no DMA for us.  Make a copy.
+         */
+        memcpy(us->iobuf, srb->cmnd, srb->cmd_len);
         result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
                                       US_CBI_ADSC, 
                                       USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0, 
-                                      us->ifnum, srb->cmnd, srb->cmd_len);
+                                      us->ifnum, us->iobuf, srb->cmd_len);
 
         /* check the return code for the command */
         usb_stor_dbg(us, "Call to usb_stor_ctrl_transfer() returned %d\n",
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index fdd3228e0678..3eb58cb51e56 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -155,6 +155,7 @@ config TANGOX_WATCHDOG
 config WDAT_WDT
         tristate "ACPI Watchdog Action Table (WDAT)"
         depends on ACPI
+        select WATCHDOG_CORE
         select ACPI_WATCHDOG
         help
           This driver adds support for systems with ACPI Watchdog Action
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index 532d8e242d4d..484bebc20bca 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -197,7 +197,7 @@ static int nfs_callback_up_net(int minorversion, struct svc_serv *serv,
         }
 
         ret = -EPROTONOSUPPORT;
-        if (minorversion == 0)
+        if (!IS_ENABLED(CONFIG_NFS_V4_1) || minorversion == 0)
                 ret = nfs4_callback_up_net(serv, net);
         else if (xprt->ops->bc_up)
                 ret = xprt->ops->bc_up(serv, net);
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index 9b3a82abab07..1452177c822d 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -542,6 +542,13 @@ static inline bool nfs4_valid_open_stateid(const struct nfs4_state *state)
         return test_bit(NFS_STATE_RECOVERY_FAILED, &state->flags) == 0;
 }
 
+static inline bool nfs4_state_match_open_stateid_other(const struct nfs4_state *state,
+                const nfs4_stateid *stateid)
+{
+        return test_bit(NFS_OPEN_STATE, &state->flags) &&
+                nfs4_stateid_match_other(&state->open_stateid, stateid);
+}
+
 #else
 
 #define nfs4_close_state(a, b) do { } while (0)
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 7897826d7c51..241da19b7da4 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -1451,7 +1451,6 @@ static void nfs_resync_open_stateid_locked(struct nfs4_state *state)
 }
 
 static void nfs_clear_open_stateid_locked(struct nfs4_state *state,
-                nfs4_stateid *arg_stateid,
                 nfs4_stateid *stateid, fmode_t fmode)
 {
         clear_bit(NFS_O_RDWR_STATE, &state->flags);
@@ -1469,10 +1468,9 @@ static void nfs_clear_open_stateid_locked(struct nfs4_state *state,
         }
         if (stateid == NULL)
                 return;
-        /* Handle races with OPEN */
-        if (!nfs4_stateid_match_other(arg_stateid, &state->open_stateid) ||
-            (nfs4_stateid_match_other(stateid, &state->open_stateid) &&
-            !nfs4_stateid_is_newer(stateid, &state->open_stateid))) {
+        /* Handle OPEN+OPEN_DOWNGRADE races */
+        if (nfs4_stateid_match_other(stateid, &state->open_stateid) &&
+            !nfs4_stateid_is_newer(stateid, &state->open_stateid)) {
                 nfs_resync_open_stateid_locked(state);
                 return;
         }
@@ -1486,7 +1484,9 @@ static void nfs_clear_open_stateid(struct nfs4_state *state,
         nfs4_stateid *stateid, fmode_t fmode)
 {
         write_seqlock(&state->seqlock);
-        nfs_clear_open_stateid_locked(state, arg_stateid, stateid, fmode);
+        /* Ignore, if the CLOSE argment doesn't match the current stateid */
+        if (nfs4_state_match_open_stateid_other(state, arg_stateid))
+                nfs_clear_open_stateid_locked(state, stateid, fmode);
         write_sequnlock(&state->seqlock);
         if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags))
                 nfs4_schedule_state_manager(state->owner->so_server->nfs_client);
@@ -2564,15 +2564,23 @@ static void nfs41_check_delegation_stateid(struct nfs4_state *state)
 static int nfs41_check_expired_locks(struct nfs4_state *state)
 {
         int status, ret = NFS_OK;
-        struct nfs4_lock_state *lsp;
+        struct nfs4_lock_state *lsp, *prev = NULL;
         struct nfs_server *server = NFS_SERVER(state->inode);
 
         if (!test_bit(LK_STATE_IN_USE, &state->flags))
                 goto out;
+
+        spin_lock(&state->state_lock);
         list_for_each_entry(lsp, &state->lock_states, ls_locks) {
                 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
                         struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
 
+                        atomic_inc(&lsp->ls_count);
+                        spin_unlock(&state->state_lock);
+
+                        nfs4_put_lock_state(prev);
+                        prev = lsp;
+
                         status = nfs41_test_and_free_expired_stateid(server,
                                         &lsp->ls_stateid,
                                         cred);
@@ -2585,10 +2593,14 @@ static int nfs41_check_expired_locks(struct nfs4_state *state)
                                         set_bit(NFS_LOCK_LOST, &lsp->ls_flags);
                         } else if (status != NFS_OK) {
                                 ret = status;
-                                break;
+                                nfs4_put_lock_state(prev);
+                                goto out;
                         }
+                        spin_lock(&state->state_lock);
                 }
-        };
+        }
+        spin_unlock(&state->state_lock);
+        nfs4_put_lock_state(prev);
 out:
         return ret;
 }
@@ -3122,7 +3134,8 @@ static void nfs4_close_prepare(struct rpc_task *task, void *data)
         } else if (is_rdwr)
                 calldata->arg.fmode |= FMODE_READ|FMODE_WRITE;
 
-        if (!nfs4_valid_open_stateid(state))
+        if (!nfs4_valid_open_stateid(state) ||
+            test_bit(NFS_OPEN_STATE, &state->flags) == 0)
                 call_close = 0;
         spin_unlock(&state->owner->so_lock);
 
@@ -5569,6 +5582,7 @@ static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
         switch (task->tk_status) {
         case 0:
                 renew_lease(data->res.server, data->timestamp);
+                break;
         case -NFS4ERR_ADMIN_REVOKED:
         case -NFS4ERR_DELEG_REVOKED:
         case -NFS4ERR_EXPIRED:
@@ -5579,8 +5593,6 @@ static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
         case -NFS4ERR_OLD_STATEID:
         case -NFS4ERR_STALE_STATEID:
                 task->tk_status = 0;
-                if (data->roc)
-                        pnfs_roc_set_barrier(data->inode, data->roc_barrier);
                 break;
         default:
                 if (nfs4_async_handle_error(task, data->res.server,
@@ -5590,6 +5602,8 @@ static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
                 }
         }
         data->rpc_status = task->tk_status;
+        if (data->roc && data->rpc_status == 0)
+                pnfs_roc_set_barrier(data->inode, data->roc_barrier);
 }
 
 static void nfs4_delegreturn_release(void *calldata)
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 5f4281ec5f72..0959c9661662 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -1547,6 +1547,7 @@ restart:
                                 ssleep(1);
                         case -NFS4ERR_ADMIN_REVOKED:
                         case -NFS4ERR_STALE_STATEID:
+                        case -NFS4ERR_OLD_STATEID:
                         case -NFS4ERR_BAD_STATEID:
                         case -NFS4ERR_RECLAIM_BAD:
                         case -NFS4ERR_RECLAIM_CONFLICT:
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 348f51b0ec92..e9c009dc3a4a 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -2567,6 +2567,7 @@ extern void sched_autogroup_create_attach(struct task_struct *p);
 extern void sched_autogroup_detach(struct task_struct *p);
 extern void sched_autogroup_fork(struct signal_struct *sig);
 extern void sched_autogroup_exit(struct signal_struct *sig);
+extern void sched_autogroup_exit_task(struct task_struct *p);
 #ifdef CONFIG_PROC_FS
 extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);
 extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);
@@ -2576,6 +2577,7 @@ static inline void sched_autogroup_create_attach(struct task_struct *p) { }
 static inline void sched_autogroup_detach(struct task_struct *p) { }
 static inline void sched_autogroup_fork(struct signal_struct *sig) { }
 static inline void sched_autogroup_exit(struct signal_struct *sig) { }
+static inline void sched_autogroup_exit_task(struct task_struct *p) { }
 #endif
 
 extern int yield_to(struct task_struct *p, bool preempt);
diff --git a/init/Kconfig b/init/Kconfig
index 34407f15e6d3..c4fbc1e55c25 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -1945,6 +1945,7 @@ config MODULE_FORCE_UNLOAD
 
 config MODVERSIONS
         bool "Module versioning support"
+        depends on BROKEN
         help
           Usually, you have to use modules compiled with your kernel.
           Saying Y here makes it sometimes possible to use modules
diff --git a/init/do_mounts_rd.c b/init/do_mounts_rd.c
index 8a09b32e07d6..dd4104c9aa12 100644
--- a/init/do_mounts_rd.c
+++ b/init/do_mounts_rd.c
@@ -272,7 +272,7 @@ int __init rd_load_image(char *from)
                 sys_write(out_fd, buf, BLOCK_SIZE);
 #if !defined(CONFIG_S390)
                 if (!(i % 16)) {
-                        printk("%c\b", rotator[rotate & 0x3]);
+                        pr_cont("%c\b", rotator[rotate & 0x3]);
                         rotate++;
                 }
 #endif
diff --git a/kernel/events/core.c b/kernel/events/core.c
index 0e292132efac..6ee1febdf6ff 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -902,6 +902,17 @@ list_update_cgroup_event(struct perf_event *event,
          * this will always be called from the right CPU.
          */
         cpuctx = __get_cpu_context(ctx);
+
+        /* Only set/clear cpuctx->cgrp if current task uses event->cgrp. */
+        if (perf_cgroup_from_task(current, ctx) != event->cgrp) {
+                /*
+                 * We are removing the last cpu event in this context.
+                 * If that event is not active in this cpu, cpuctx->cgrp
+                 * should've been cleared by perf_cgroup_switch.
+                 */
+                WARN_ON_ONCE(!add && cpuctx->cgrp);
+                return;
+        }
         cpuctx->cgrp = add ? event->cgrp : NULL;
 }
 
@@ -8018,6 +8029,7 @@ restart:
  * if <size> is not specified, the range is treated as a single address.
  */
 enum {
+        IF_ACT_NONE = -1,
         IF_ACT_FILTER,
         IF_ACT_START,
         IF_ACT_STOP,
@@ -8041,6 +8053,7 @@ static const match_table_t if_tokens = {
         { IF_SRC_KERNEL,        "%u/%u" },
         { IF_SRC_FILEADDR,      "%u@%s" },
         { IF_SRC_KERNELADDR,    "%u" },
+        { IF_ACT_NONE,          NULL },
 };
 
 /*
diff --git a/kernel/exit.c b/kernel/exit.c
index 9d68c45ebbe3..3076f3089919 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -836,6 +836,7 @@ void __noreturn do_exit(long code)
          */
         perf_event_exit_task(tsk);
 
+        sched_autogroup_exit_task(tsk);
         cgroup_exit(tsk);
 
         /*
diff --git a/kernel/sched/auto_group.c b/kernel/sched/auto_group.c
index a5d966cb8891..f1c8fd566246 100644
--- a/kernel/sched/auto_group.c
+++ b/kernel/sched/auto_group.c
@@ -111,10 +111,13 @@ bool task_wants_autogroup(struct task_struct *p, struct task_group *tg)
 {
         if (tg != &root_task_group)
                 return false;
-
         /*
-         * We can only assume the task group can't go away on us if
-         * autogroup_move_group() can see us on ->thread_group list.
+         * If we race with autogroup_move_group() the caller can use the old
+         * value of signal->autogroup but in this case sched_move_task() will
+         * be called again before autogroup_kref_put().
+         *
+         * However, there is no way sched_autogroup_exit_task() could tell us
+         * to avoid autogroup->tg, so we abuse PF_EXITING flag for this case.
          */
         if (p->flags & PF_EXITING)
                 return false;
@@ -122,6 +125,16 @@ bool task_wants_autogroup(struct task_struct *p, struct task_group *tg)
         return true;
 }
 
+void sched_autogroup_exit_task(struct task_struct *p)
+{
+        /*
+         * We are going to call exit_notify() and autogroup_move_group() can't
+         * see this thread after that: we can no longer use signal->autogroup.
+         * See the PF_EXITING check in task_wants_autogroup().
+         */
+        sched_move_task(p);
+}
+
 static void
 autogroup_move_group(struct task_struct *p, struct autogroup *ag)
 {
@@ -138,13 +151,20 @@ autogroup_move_group(struct task_struct *p, struct autogroup *ag)
         }
 
         p->signal->autogroup = autogroup_kref_get(ag);
-
-        if (!READ_ONCE(sysctl_sched_autogroup_enabled))
-                goto out;
-
+        /*
+         * We can't avoid sched_move_task() after we changed signal->autogroup,
+         * this process can already run with task_group() == prev->tg or we can
+         * race with cgroup code which can read autogroup = prev under rq->lock.
+         * In the latter case for_each_thread() can not miss a migrating thread,
+         * cpu_cgroup_attach() must not be possible after cgroup_exit() and it
+         * can't be removed from thread list, we hold ->siglock.
+         *
+         * If an exiting thread was already removed from thread list we rely on
+         * sched_autogroup_exit_task().
+         */
         for_each_thread(p, t)
                 sched_move_task(t);
-out:
+
         unlock_task_sighand(p, &flags);
         autogroup_kref_put(prev);
 }
diff --git a/lib/mpi/mpi-pow.c b/lib/mpi/mpi-pow.c
index 5464c8744ea9..e24388a863a7 100644
--- a/lib/mpi/mpi-pow.c
+++ b/lib/mpi/mpi-pow.c
@@ -64,8 +64,13 @@ int mpi_powm(MPI res, MPI base, MPI exp, MPI mod)
         if (!esize) {
                 /* Exponent is zero, result is 1 mod MOD, i.e., 1 or 0
                  * depending on if MOD equals 1.  */
-                rp[0] = 1;
                 res->nlimbs = (msize == 1 && mod->d[0] == 1) ? 0 : 1;
+                if (res->nlimbs) {
+                        if (mpi_resize(res, 1) < 0)
+                                goto enomem;
+                        rp = res->d;
+                        rp[0] = 1;
+                }
                 res->sign = 0;
                 goto leave;
         }