Merge tag 'pm-5.2-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull power management updates from Rafael Wysocki:
 "These fix the (Intel-specific) Performance and Energy Bias Hint (EPB)
  handling and expose it to user space via sysfs, fix and clean up
  several cpufreq drivers, add support for two new chips to the qoriq
  cpufreq driver, fix, simplify and clean up the cpufreq core and the
  schedutil governor, add support for "CPU" domains to the generic power
  domains (genpd) framework and provide low-level PSCI firmware support
  for that feature, fix the exynos cpuidle driver and fix a couple of
  issues in the devfreq subsystem and clean it up.

  Specifics:

   - Fix the handling of Performance and Energy Bias Hint (EPB) on Intel
     processors and expose it to user space via sysfs to avoid having to
     access it through the generic MSR I/F (Rafael Wysocki).

   - Improve the handling of global turbo changes made by the platform
     firmware in the intel_pstate driver (Rafael Wysocki).

   - Convert some slow-path static_cpu_has() callers to boot_cpu_has()
     in cpufreq (Borislav Petkov).

   - Fix the frequency calculation loop in the armada-37xx cpufreq
     driver (Gregory CLEMENT).

   - Fix possible object reference leaks in multuple cpufreq drivers
     (Wen Yang).

   - Fix kerneldoc comment in the centrino cpufreq driver (dongjian).

   - Clean up the ACPI and maple cpufreq drivers (Viresh Kumar, Mohan
     Kumar).

   - Add support for lx2160a and ls1028a to the qoriq cpufreq driver
     (Vabhav Sharma, Yuantian Tang).

   - Fix kobject memory leak in the cpufreq core (Viresh Kumar).

   - Simplify the IOwait boosting in the schedutil cpufreq governor and
     rework the TSC cpufreq notifier on x86 (Rafael Wysocki).

   - Clean up the cpufreq core and statistics code (Yue Hu, Kyle Lin).

   - Improve the cpufreq documentation, add SPDX license tags to some PM
     documentation files and unify copyright notices in them (Rafael
     Wysocki).

   - Add support for "CPU" domains to the generic power domains (genpd)
     framework and provide low-level PSCI firmware support for that
     feature (Ulf Hansson).

   - Rearrange the PSCI firmware support code and add support for
     SYSTEM_RESET2 to it (Ulf Hansson, Sudeep Holla).

   - Improve genpd support for devices in multiple power domains (Ulf
     Hansson).

   - Unify target residency for the AFTR and coupled AFTR states in the
     exynos cpuidle driver (Marek Szyprowski).

   - Introduce new helper routine in the operating performance points
     (OPP) framework (Andrew-sh.Cheng).

   - Add support for passing on-die termination (ODT) and auto power
     down parameters from the kernel to Trusted Firmware-A (TF-A) to the
     rk3399_dmc devfreq driver (Enric Balletbo i Serra).

   - Add tracing to devfreq (Lukasz Luba).

   - Make the exynos-bus devfreq driver suspend all devices on system
     shutdown (Marek Szyprowski).

   - Fix a few minor issues in the devfreq subsystem and clean it up
     somewhat (Enric Balletbo i Serra, MyungJoo Ham, Rob Herring,
     Saravana Kannan, Yangtao Li).

   - Improve system wakeup diagnostics (Stephen Boyd).

   - Rework filesystem sync messages emitted during system suspend and
     hibernation (Harry Pan)"

* tag 'pm-5.2-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (72 commits)
  cpufreq: Fix kobject memleak
  cpufreq: armada-37xx: fix frequency calculation for opp
  cpufreq: centrino: Fix centrino_setpolicy() kerneldoc comment
  cpufreq: qoriq: add support for lx2160a
  x86: tsc: Rework time_cpufreq_notifier()
  PM / Domains: Allow to attach a CPU via genpd_dev_pm_attach_by_id|name()
  PM / Domains: Search for the CPU device outside the genpd lock
  PM / Domains: Drop unused in-parameter to some genpd functions
  PM / Domains: Use the base device for driver_deferred_probe_check_state()
  cpufreq: qoriq: Add ls1028a chip support
  PM / Domains: Enable genpd_dev_pm_attach_by_id|name() for single PM domain
  PM / Domains: Allow OF lookup for multi PM domain case from ->attach_dev()
  PM / Domains: Don't kfree() the virtual device in the error path
  cpufreq: Move ->get callback check outside of __cpufreq_get()
  PM / Domains: remove unnecessary unlikely()
  cpufreq: Remove needless bios_limit check in show_bios_limit()
  drivers/cpufreq/acpi-cpufreq.c: This fixes the following checkpatch warning
  firmware/psci: add support for SYSTEM_RESET2
  PM / devfreq: add tracing for scheduling work
  trace: events: add devfreq trace event file
  ...

40 files changed, 700 insertions, 262 deletions

diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c
index a303fd0e108c..c73d3a62799a 100644
--- a/drivers/acpi/processor_perflib.c
+++ b/drivers/acpi/processor_perflib.c
@@ -181,7 +181,7 @@ void acpi_processor_ppc_has_changed(struct acpi_processor *pr, int event_flag)
                         acpi_processor_ppc_ost(pr->handle, 0);
         }
         if (ret >= 0)
-                cpufreq_update_policy(pr->id);
+                cpufreq_update_limits(pr->id);
 }
 
 int acpi_processor_get_bios_limit(int cpu, unsigned int *limit)
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index 96a6dc9d305c..3d899e8abd58 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -22,6 +22,7 @@
 #include <linux/sched.h>
 #include <linux/suspend.h>
 #include <linux/export.h>
+#include <linux/cpu.h>
 
 #include "power.h"
 
@@ -128,6 +129,7 @@ static const struct genpd_lock_ops genpd_spin_ops = {
 #define genpd_is_irq_safe(genpd)        (genpd->flags & GENPD_FLAG_IRQ_SAFE)
 #define genpd_is_always_on(genpd)       (genpd->flags & GENPD_FLAG_ALWAYS_ON)
 #define genpd_is_active_wakeup(genpd)   (genpd->flags & GENPD_FLAG_ACTIVE_WAKEUP)
+#define genpd_is_cpu_domain(genpd)      (genpd->flags & GENPD_FLAG_CPU_DOMAIN)
 
 static inline bool irq_safe_dev_in_no_sleep_domain(struct device *dev,
                 const struct generic_pm_domain *genpd)
@@ -391,11 +393,9 @@ int dev_pm_genpd_set_performance_state(struct device *dev, unsigned int state)
         if (unlikely(!genpd->set_performance_state))
                 return -EINVAL;
 
-        if (unlikely(!dev->power.subsys_data ||
-                     !dev->power.subsys_data->domain_data)) {
-                WARN_ON(1);
+        if (WARN_ON(!dev->power.subsys_data ||
+                     !dev->power.subsys_data->domain_data))
                 return -EINVAL;
-        }
 
         genpd_lock(genpd);
 
@@ -1396,8 +1396,7 @@ EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweron);
 
 #endif /* CONFIG_PM_SLEEP */
 
-static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev,
-                                        struct gpd_timing_data *td)
+static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev)
 {
         struct generic_pm_domain_data *gpd_data;
         int ret;
@@ -1412,9 +1411,6 @@ static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev,
                 goto err_put;
         }
 
-        if (td)
-                gpd_data->td = *td;
-
         gpd_data->base.dev = dev;
         gpd_data->td.constraint_changed = true;
         gpd_data->td.effective_constraint_ns = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS;
@@ -1454,8 +1450,57 @@ static void genpd_free_dev_data(struct device *dev,
         dev_pm_put_subsys_data(dev);
 }
 
+static void genpd_update_cpumask(struct generic_pm_domain *genpd,
+                                 int cpu, bool set, unsigned int depth)
+{
+        struct gpd_link *link;
+
+        if (!genpd_is_cpu_domain(genpd))
+                return;
+
+        list_for_each_entry(link, &genpd->slave_links, slave_node) {
+                struct generic_pm_domain *master = link->master;
+
+                genpd_lock_nested(master, depth + 1);
+                genpd_update_cpumask(master, cpu, set, depth + 1);
+                genpd_unlock(master);
+        }
+
+        if (set)
+                cpumask_set_cpu(cpu, genpd->cpus);
+        else
+                cpumask_clear_cpu(cpu, genpd->cpus);
+}
+
+static void genpd_set_cpumask(struct generic_pm_domain *genpd, int cpu)
+{
+        if (cpu >= 0)
+                genpd_update_cpumask(genpd, cpu, true, 0);
+}
+
+static void genpd_clear_cpumask(struct generic_pm_domain *genpd, int cpu)
+{
+        if (cpu >= 0)
+                genpd_update_cpumask(genpd, cpu, false, 0);
+}
+
+static int genpd_get_cpu(struct generic_pm_domain *genpd, struct device *dev)
+{
+        int cpu;
+
+        if (!genpd_is_cpu_domain(genpd))
+                return -1;
+
+        for_each_possible_cpu(cpu) {
+                if (get_cpu_device(cpu) == dev)
+                        return cpu;
+        }
+
+        return -1;
+}
+
 static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
-                            struct gpd_timing_data *td)
+                            struct device *base_dev)
 {
         struct generic_pm_domain_data *gpd_data;
         int ret;
@@ -1465,16 +1510,19 @@ static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
                 return -EINVAL;
 
-        gpd_data = genpd_alloc_dev_data(dev, td);
+        gpd_data = genpd_alloc_dev_data(dev);
         if (IS_ERR(gpd_data))
                 return PTR_ERR(gpd_data);
 
+        gpd_data->cpu = genpd_get_cpu(genpd, base_dev);
+
         ret = genpd->attach_dev ? genpd->attach_dev(genpd, dev) : 0;
         if (ret)
                 goto out;
 
         genpd_lock(genpd);
 
+        genpd_set_cpumask(genpd, gpd_data->cpu);
         dev_pm_domain_set(dev, &genpd->domain);
 
         genpd->device_count++;
@@ -1502,7 +1550,7 @@ int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev)
         int ret;
 
         mutex_lock(&gpd_list_lock);
-        ret = genpd_add_device(genpd, dev, NULL);
+        ret = genpd_add_device(genpd, dev, dev);
         mutex_unlock(&gpd_list_lock);
 
         return ret;
@@ -1532,6 +1580,7 @@ static int genpd_remove_device(struct generic_pm_domain *genpd,
         genpd->device_count--;
         genpd->max_off_time_changed = true;
 
+        genpd_clear_cpumask(genpd, gpd_data->cpu);
         dev_pm_domain_set(dev, NULL);
 
         list_del_init(&pdd->list_node);
@@ -1686,6 +1735,12 @@ out:
 }
 EXPORT_SYMBOL_GPL(pm_genpd_remove_subdomain);
 
+static void genpd_free_default_power_state(struct genpd_power_state *states,
+                                           unsigned int state_count)
+{
+        kfree(states);
+}
+
 static int genpd_set_default_power_state(struct generic_pm_domain *genpd)
 {
         struct genpd_power_state *state;
@@ -1696,7 +1751,7 @@ static int genpd_set_default_power_state(struct generic_pm_domain *genpd)
 
         genpd->states = state;
         genpd->state_count = 1;
-        genpd->free = state;
+        genpd->free_states = genpd_free_default_power_state;
 
         return 0;
 }
@@ -1762,11 +1817,18 @@ int pm_genpd_init(struct generic_pm_domain *genpd,
         if (genpd_is_always_on(genpd) && !genpd_status_on(genpd))
                 return -EINVAL;
 
+        if (genpd_is_cpu_domain(genpd) &&
+            !zalloc_cpumask_var(&genpd->cpus, GFP_KERNEL))
+                return -ENOMEM;
+
         /* Use only one "off" state if there were no states declared */
         if (genpd->state_count == 0) {
                 ret = genpd_set_default_power_state(genpd);
-                if (ret)
+                if (ret) {
+                        if (genpd_is_cpu_domain(genpd))
+                                free_cpumask_var(genpd->cpus);
                         return ret;
+                }
         } else if (!gov && genpd->state_count > 1) {
                 pr_warn("%s: no governor for states\n", genpd->name);
         }
@@ -1812,7 +1874,11 @@ static int genpd_remove(struct generic_pm_domain *genpd)
         list_del(&genpd->gpd_list_node);
         genpd_unlock(genpd);
         cancel_work_sync(&genpd->power_off_work);
-        kfree(genpd->free);
+        if (genpd_is_cpu_domain(genpd))
+                free_cpumask_var(genpd->cpus);
+        if (genpd->free_states)
+                genpd->free_states(genpd->states, genpd->state_count);
+
         pr_debug("%s: removed %s\n", __func__, genpd->name);
 
         return 0;
@@ -2190,7 +2256,7 @@ int of_genpd_add_device(struct of_phandle_args *genpdspec, struct device *dev)
                 goto out;
         }
 
-        ret = genpd_add_device(genpd, dev, NULL);
+        ret = genpd_add_device(genpd, dev, dev);
 
 out:
         mutex_unlock(&gpd_list_lock);
@@ -2274,6 +2340,7 @@ EXPORT_SYMBOL_GPL(of_genpd_remove_last);
 
 static void genpd_release_dev(struct device *dev)
 {
+        of_node_put(dev->of_node);
         kfree(dev);
 }
 
@@ -2335,14 +2402,14 @@ static void genpd_dev_pm_sync(struct device *dev)
         genpd_queue_power_off_work(pd);
 }
 
-static int __genpd_dev_pm_attach(struct device *dev, struct device_node *np,
+static int __genpd_dev_pm_attach(struct device *dev, struct device *base_dev,
                                  unsigned int index, bool power_on)
 {
         struct of_phandle_args pd_args;
         struct generic_pm_domain *pd;
         int ret;
 
-        ret = of_parse_phandle_with_args(np, "power-domains",
+        ret = of_parse_phandle_with_args(dev->of_node, "power-domains",
                                 "#power-domain-cells", index, &pd_args);
         if (ret < 0)
                 return ret;
@@ -2354,12 +2421,12 @@ static int __genpd_dev_pm_attach(struct device *dev, struct device_node *np,
                 mutex_unlock(&gpd_list_lock);
                 dev_dbg(dev, "%s() failed to find PM domain: %ld\n",
                         __func__, PTR_ERR(pd));
-                return driver_deferred_probe_check_state(dev);
+                return driver_deferred_probe_check_state(base_dev);
         }
 
         dev_dbg(dev, "adding to PM domain %s\n", pd->name);
 
-        ret = genpd_add_device(pd, dev, NULL);
+        ret = genpd_add_device(pd, dev, base_dev);
         mutex_unlock(&gpd_list_lock);
 
         if (ret < 0) {
@@ -2410,7 +2477,7 @@ int genpd_dev_pm_attach(struct device *dev)
                                        "#power-domain-cells") != 1)
                 return 0;
 
-        return __genpd_dev_pm_attach(dev, dev->of_node, 0, true);
+        return __genpd_dev_pm_attach(dev, dev, 0, true);
 }
 EXPORT_SYMBOL_GPL(genpd_dev_pm_attach);
 
@@ -2440,10 +2507,10 @@ struct device *genpd_dev_pm_attach_by_id(struct device *dev,
         if (!dev->of_node)
                 return NULL;
 
-        /* Deal only with devices using multiple PM domains. */
+        /* Verify that the index is within a valid range. */
         num_domains = of_count_phandle_with_args(dev->of_node, "power-domains",
                                                  "#power-domain-cells");
-        if (num_domains < 2 || index >= num_domains)
+        if (index >= num_domains)
                 return NULL;
 
         /* Allocate and register device on the genpd bus. */
@@ -2454,15 +2521,16 @@ struct device *genpd_dev_pm_attach_by_id(struct device *dev,
         dev_set_name(virt_dev, "genpd:%u:%s", index, dev_name(dev));
         virt_dev->bus = &genpd_bus_type;
         virt_dev->release = genpd_release_dev;
+        virt_dev->of_node = of_node_get(dev->of_node);
 
         ret = device_register(virt_dev);
         if (ret) {
-                kfree(virt_dev);
+                put_device(virt_dev);
                 return ERR_PTR(ret);
         }
 
         /* Try to attach the device to the PM domain at the specified index. */
-        ret = __genpd_dev_pm_attach(virt_dev, dev->of_node, index, false);
+        ret = __genpd_dev_pm_attach(virt_dev, dev, index, false);
         if (ret < 1) {
                 device_unregister(virt_dev);
                 return ret ? ERR_PTR(ret) : NULL;
diff --git a/drivers/base/power/domain_governor.c b/drivers/base/power/domain_governor.c
index 4d07e38a8247..7912bc957244 100644
--- a/drivers/base/power/domain_governor.c
+++ b/drivers/base/power/domain_governor.c
@@ -10,6 +10,9 @@
 #include <linux/pm_domain.h>
 #include <linux/pm_qos.h>
 #include <linux/hrtimer.h>
+#include <linux/cpuidle.h>
+#include <linux/cpumask.h>
+#include <linux/ktime.h>
 
 static int dev_update_qos_constraint(struct device *dev, void *data)
 {
@@ -210,8 +213,10 @@ static bool default_power_down_ok(struct dev_pm_domain *pd)
         struct generic_pm_domain *genpd = pd_to_genpd(pd);
         struct gpd_link *link;
 
-        if (!genpd->max_off_time_changed)
+        if (!genpd->max_off_time_changed) {
+                genpd->state_idx = genpd->cached_power_down_state_idx;
                 return genpd->cached_power_down_ok;
+        }
 
         /*
          * We have to invalidate the cached results for the masters, so
@@ -236,6 +241,7 @@ static bool default_power_down_ok(struct dev_pm_domain *pd)
                 genpd->state_idx--;
         }
 
+        genpd->cached_power_down_state_idx = genpd->state_idx;
         return genpd->cached_power_down_ok;
 }
 
@@ -244,6 +250,65 @@ static bool always_on_power_down_ok(struct dev_pm_domain *domain)
         return false;
 }
 
+#ifdef CONFIG_CPU_IDLE
+static bool cpu_power_down_ok(struct dev_pm_domain *pd)
+{
+        struct generic_pm_domain *genpd = pd_to_genpd(pd);
+        struct cpuidle_device *dev;
+        ktime_t domain_wakeup, next_hrtimer;
+        s64 idle_duration_ns;
+        int cpu, i;
+
+        /* Validate dev PM QoS constraints. */
+        if (!default_power_down_ok(pd))
+                return false;
+
+        if (!(genpd->flags & GENPD_FLAG_CPU_DOMAIN))
+                return true;
+
+        /*
+         * Find the next wakeup for any of the online CPUs within the PM domain
+         * and its subdomains. Note, we only need the genpd->cpus, as it already
+         * contains a mask of all CPUs from subdomains.
+         */
+        domain_wakeup = ktime_set(KTIME_SEC_MAX, 0);
+        for_each_cpu_and(cpu, genpd->cpus, cpu_online_mask) {
+                dev = per_cpu(cpuidle_devices, cpu);
+                if (dev) {
+                        next_hrtimer = READ_ONCE(dev->next_hrtimer);
+                        if (ktime_before(next_hrtimer, domain_wakeup))
+                                domain_wakeup = next_hrtimer;
+                }
+        }
+
+        /* The minimum idle duration is from now - until the next wakeup. */
+        idle_duration_ns = ktime_to_ns(ktime_sub(domain_wakeup, ktime_get()));
+        if (idle_duration_ns <= 0)
+                return false;
+
+        /*
+         * Find the deepest idle state that has its residency value satisfied
+         * and by also taking into account the power off latency for the state.
+         * Start at the state picked by the dev PM QoS constraint validation.
+         */
+        i = genpd->state_idx;
+        do {
+                if (idle_duration_ns >= (genpd->states[i].residency_ns +
+                    genpd->states[i].power_off_latency_ns)) {
+                        genpd->state_idx = i;
+                        return true;
+                }
+        } while (--i >= 0);
+
+        return false;
+}
+
+struct dev_power_governor pm_domain_cpu_gov = {
+        .suspend_ok = default_suspend_ok,
+        .power_down_ok = cpu_power_down_ok,
+};
+#endif
+
 struct dev_power_governor simple_qos_governor = {
         .suspend_ok = default_suspend_ok,
         .power_down_ok = default_power_down_ok,
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index f80d298de3fa..43e863cc0c1b 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -478,7 +478,7 @@ struct dpm_watchdog {
 
 /**
  * dpm_watchdog_handler - Driver suspend / resume watchdog handler.
- * @data: Watchdog object address.
+ * @t: The timer that PM watchdog depends on.
  *
  * Called when a driver has timed out suspending or resuming.
  * There's not much we can do here to recover so panic() to
@@ -706,6 +706,19 @@ static bool is_async(struct device *dev)
                 && !pm_trace_is_enabled();
 }
 
+static bool dpm_async_fn(struct device *dev, async_func_t func)
+{
+        reinit_completion(&dev->power.completion);
+
+        if (is_async(dev)) {
+                get_device(dev);
+                async_schedule(func, dev);
+                return true;
+        }
+
+        return false;
+}
+
 static void async_resume_noirq(void *data, async_cookie_t cookie)
 {
         struct device *dev = (struct device *)data;
@@ -732,13 +745,8 @@ void dpm_noirq_resume_devices(pm_message_t state)
          * in case the starting of async threads is
          * delayed by non-async resuming devices.
          */
-        list_for_each_entry(dev, &dpm_noirq_list, power.entry) {
-                reinit_completion(&dev->power.completion);
-                if (is_async(dev)) {
-                        get_device(dev);
-                        async_schedule_dev(async_resume_noirq, dev);
-                }
-        }
+        list_for_each_entry(dev, &dpm_noirq_list, power.entry)
+                dpm_async_fn(dev, async_resume_noirq);
 
         while (!list_empty(&dpm_noirq_list)) {
                 dev = to_device(dpm_noirq_list.next);
@@ -889,13 +897,8 @@ void dpm_resume_early(pm_message_t state)
          * in case the starting of async threads is
          * delayed by non-async resuming devices.
          */
-        list_for_each_entry(dev, &dpm_late_early_list, power.entry) {
-                reinit_completion(&dev->power.completion);
-                if (is_async(dev)) {
-                        get_device(dev);
-                        async_schedule_dev(async_resume_early, dev);
-                }
-        }
+        list_for_each_entry(dev, &dpm_late_early_list, power.entry)
+                dpm_async_fn(dev, async_resume_early);
 
         while (!list_empty(&dpm_late_early_list)) {
                 dev = to_device(dpm_late_early_list.next);
@@ -1053,13 +1056,8 @@ void dpm_resume(pm_message_t state)
         pm_transition = state;
         async_error = 0;
 
-        list_for_each_entry(dev, &dpm_suspended_list, power.entry) {
-                reinit_completion(&dev->power.completion);
-                if (is_async(dev)) {
-                        get_device(dev);
-                        async_schedule_dev(async_resume, dev);
-                }
-        }
+        list_for_each_entry(dev, &dpm_suspended_list, power.entry)
+                dpm_async_fn(dev, async_resume);
 
         while (!list_empty(&dpm_suspended_list)) {
                 dev = to_device(dpm_suspended_list.next);
@@ -1373,13 +1371,9 @@ static void async_suspend_noirq(void *data, async_cookie_t cookie)
 
 static int device_suspend_noirq(struct device *dev)
 {
-        reinit_completion(&dev->power.completion);
-
-        if (is_async(dev)) {
-                get_device(dev);
-                async_schedule_dev(async_suspend_noirq, dev);
+        if (dpm_async_fn(dev, async_suspend_noirq))
                 return 0;
-        }
+
         return __device_suspend_noirq(dev, pm_transition, false);
 }
 
@@ -1576,13 +1570,8 @@ static void async_suspend_late(void *data, async_cookie_t cookie)
 
 static int device_suspend_late(struct device *dev)
 {
-        reinit_completion(&dev->power.completion);
-
-        if (is_async(dev)) {
-                get_device(dev);
-                async_schedule_dev(async_suspend_late, dev);
+        if (dpm_async_fn(dev, async_suspend_late))
                 return 0;
-        }
 
         return __device_suspend_late(dev, pm_transition, false);
 }
@@ -1747,6 +1736,10 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
         if (dev->power.syscore)
                 goto Complete;
 
+        /* Avoid direct_complete to let wakeup_path propagate. */
+        if (device_may_wakeup(dev) || dev->power.wakeup_path)
+                dev->power.direct_complete = false;
+
         if (dev->power.direct_complete) {
                 if (pm_runtime_status_suspended(dev)) {
                         pm_runtime_disable(dev);
@@ -1842,13 +1835,8 @@ static void async_suspend(void *data, async_cookie_t cookie)
 
 static int device_suspend(struct device *dev)
 {
-        reinit_completion(&dev->power.completion);
-
-        if (is_async(dev)) {
-                get_device(dev);
-                async_schedule_dev(async_suspend, dev);
+        if (dpm_async_fn(dev, async_suspend))
                 return 0;
-        }
 
         return __device_suspend(dev, pm_transition, false);
 }
@@ -2069,8 +2057,8 @@ EXPORT_SYMBOL_GPL(__suspend_report_result);
 
 /**
  * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
- * @dev: Device to wait for.
  * @subordinate: Device that needs to wait for @dev.
+ * @dev: Device to wait for.
  */
 int device_pm_wait_for_dev(struct device *subordinate, struct device *dev)
 {
diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
index bb1ae175fae1..23c243a4c675 100644
--- a/drivers/base/power/wakeup.c
+++ b/drivers/base/power/wakeup.c
@@ -804,7 +804,7 @@ void pm_print_active_wakeup_sources(void)
         srcuidx = srcu_read_lock(&wakeup_srcu);
         list_for_each_entry_rcu(ws, &wakeup_sources, entry) {
                 if (ws->active) {
-                        pr_debug("active wakeup source: %s\n", ws->name);
+                        pm_pr_dbg("active wakeup source: %s\n", ws->name);
                         active = 1;
                 } else if (!active &&
                            (!last_activity_ws ||
@@ -815,7 +815,7 @@ void pm_print_active_wakeup_sources(void)
         }
 
         if (!active && last_activity_ws)
-                pr_debug("last active wakeup source: %s\n",
+                pm_pr_dbg("last active wakeup source: %s\n",
                         last_activity_ws->name);
         srcu_read_unlock(&wakeup_srcu, srcuidx);
 }
@@ -845,7 +845,7 @@ bool pm_wakeup_pending(void)
         raw_spin_unlock_irqrestore(&events_lock, flags);
 
         if (ret) {
-                pr_debug("Wakeup pending, aborting suspend\n");
+                pm_pr_dbg("Wakeup pending, aborting suspend\n");
                 pm_print_active_wakeup_sources();
         }
 
diff --git a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig
index b22e6bba71f1..4d2b33a30292 100644
--- a/drivers/cpufreq/Kconfig
+++ b/drivers/cpufreq/Kconfig
@@ -26,10 +26,6 @@ config CPU_FREQ_GOV_COMMON
         select IRQ_WORK
         bool
 
-config CPU_FREQ_BOOST_SW
-        bool
-        depends on THERMAL
-
 config CPU_FREQ_STAT
         bool "CPU frequency transition statistics"
         help
diff --git a/drivers/cpufreq/acpi-cpufreq.c b/drivers/cpufreq/acpi-cpufreq.c
index c72258a44ba4..73bb2aafb1a8 100644
--- a/drivers/cpufreq/acpi-cpufreq.c
+++ b/drivers/cpufreq/acpi-cpufreq.c
@@ -366,7 +366,7 @@ static u32 get_cur_val(const struct cpumask *mask, struct acpi_cpufreq_data *dat
 
         val = drv_read(data, mask);
 
-        pr_debug("get_cur_val = %u\n", val);
+        pr_debug("%s = %u\n", __func__, val);
 
         return val;
 }
@@ -378,7 +378,7 @@ static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
         unsigned int freq;
         unsigned int cached_freq;
 
-        pr_debug("get_cur_freq_on_cpu (%d)\n", cpu);
+        pr_debug("%s (%d)\n", __func__, cpu);
 
         policy = cpufreq_cpu_get_raw(cpu);
         if (unlikely(!policy))
@@ -458,8 +458,7 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
         if (acpi_pstate_strict) {
                 if (!check_freqs(policy, mask,
                                  policy->freq_table[index].frequency)) {
-                        pr_debug("acpi_cpufreq_target failed (%d)\n",
-                                policy->cpu);
+                        pr_debug("%s (%d)\n", __func__, policy->cpu);
                         result = -EAGAIN;
                 }
         }
@@ -573,7 +572,7 @@ static int cpufreq_boost_down_prep(unsigned int cpu)
 static int __init acpi_cpufreq_early_init(void)
 {
         unsigned int i;
-        pr_debug("acpi_cpufreq_early_init\n");
+        pr_debug("%s\n", __func__);
 
         acpi_perf_data = alloc_percpu(struct acpi_processor_performance);
         if (!acpi_perf_data) {
@@ -657,7 +656,7 @@ static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
         static int blacklisted;
 #endif
 
-        pr_debug("acpi_cpufreq_cpu_init\n");
+        pr_debug("%s\n", __func__);
 
 #ifdef CONFIG_SMP
         if (blacklisted)
@@ -856,7 +855,7 @@ static int acpi_cpufreq_cpu_exit(struct cpufreq_policy *policy)
 {
         struct acpi_cpufreq_data *data = policy->driver_data;
 
-        pr_debug("acpi_cpufreq_cpu_exit\n");
+        pr_debug("%s\n", __func__);
 
         policy->fast_switch_possible = false;
         policy->driver_data = NULL;
@@ -881,7 +880,7 @@ static int acpi_cpufreq_resume(struct cpufreq_policy *policy)
 {
         struct acpi_cpufreq_data *data = policy->driver_data;
 
-        pr_debug("acpi_cpufreq_resume\n");
+        pr_debug("%s\n", __func__);
 
         data->resume = 1;
 
@@ -954,7 +953,7 @@ static int __init acpi_cpufreq_init(void)
         if (cpufreq_get_current_driver())
                 return -EEXIST;
 
-        pr_debug("acpi_cpufreq_init\n");
+        pr_debug("%s\n", __func__);
 
         ret = acpi_cpufreq_early_init();
         if (ret)
@@ -991,7 +990,7 @@ static int __init acpi_cpufreq_init(void)
 
 static void __exit acpi_cpufreq_exit(void)
 {
-        pr_debug("acpi_cpufreq_exit\n");
+        pr_debug("%s\n", __func__);
 
         acpi_cpufreq_boost_exit();
 
diff --git a/drivers/cpufreq/amd_freq_sensitivity.c b/drivers/cpufreq/amd_freq_sensitivity.c
index 4ac7c3cf34be..6927a8c0e748 100644
--- a/drivers/cpufreq/amd_freq_sensitivity.c
+++ b/drivers/cpufreq/amd_freq_sensitivity.c
@@ -124,7 +124,7 @@ static int __init amd_freq_sensitivity_init(void)
                         PCI_DEVICE_ID_AMD_KERNCZ_SMBUS, NULL);
 
         if (!pcidev) {
-                if (!static_cpu_has(X86_FEATURE_PROC_FEEDBACK))
+                if (!boot_cpu_has(X86_FEATURE_PROC_FEEDBACK))
                         return -ENODEV;
         }
 
diff --git a/drivers/cpufreq/armada-37xx-cpufreq.c b/drivers/cpufreq/armada-37xx-cpufreq.c
index 75491fc841a6..0df16eb1eb3c 100644
--- a/drivers/cpufreq/armada-37xx-cpufreq.c
+++ b/drivers/cpufreq/armada-37xx-cpufreq.c
@@ -359,11 +359,11 @@ static int __init armada37xx_cpufreq_driver_init(void)
         struct armada_37xx_dvfs *dvfs;
         struct platform_device *pdev;
         unsigned long freq;
-        unsigned int cur_frequency;
+        unsigned int cur_frequency, base_frequency;
         struct regmap *nb_pm_base, *avs_base;
         struct device *cpu_dev;
         int load_lvl, ret;
-        struct clk *clk;
+        struct clk *clk, *parent;
 
         nb_pm_base =
                 syscon_regmap_lookup_by_compatible("marvell,armada-3700-nb-pm");
@@ -399,6 +399,22 @@ static int __init armada37xx_cpufreq_driver_init(void)
                 return PTR_ERR(clk);
         }
 
+        parent = clk_get_parent(clk);
+        if (IS_ERR(parent)) {
+                dev_err(cpu_dev, "Cannot get parent clock for CPU0\n");
+                clk_put(clk);
+                return PTR_ERR(parent);
+        }
+
+        /* Get parent CPU frequency */
+        base_frequency =  clk_get_rate(parent);
+
+        if (!base_frequency) {
+                dev_err(cpu_dev, "Failed to get parent clock rate for CPU\n");
+                clk_put(clk);
+                return -EINVAL;
+        }
+
         /* Get nominal (current) CPU frequency */
         cur_frequency = clk_get_rate(clk);
         if (!cur_frequency) {
@@ -431,7 +447,7 @@ static int __init armada37xx_cpufreq_driver_init(void)
         for (load_lvl = ARMADA_37XX_DVFS_LOAD_0; load_lvl < LOAD_LEVEL_NR;
              load_lvl++) {
                 unsigned long u_volt = avs_map[dvfs->avs[load_lvl]] * 1000;
-                freq = cur_frequency / dvfs->divider[load_lvl];
+                freq = base_frequency / dvfs->divider[load_lvl];
                 ret = dev_pm_opp_add(cpu_dev, freq, u_volt);
                 if (ret)
                         goto remove_opp;
diff --git a/drivers/cpufreq/armada-8k-cpufreq.c b/drivers/cpufreq/armada-8k-cpufreq.c
index b3f4bd647e9b..988ebc326bdb 100644
--- a/drivers/cpufreq/armada-8k-cpufreq.c
+++ b/drivers/cpufreq/armada-8k-cpufreq.c
@@ -132,6 +132,7 @@ static int __init armada_8k_cpufreq_init(void)
                 of_node_put(node);
                 return -ENODEV;
         }
+        of_node_put(node);
 
         nb_cpus = num_possible_cpus();
         freq_tables = kcalloc(nb_cpus, sizeof(*freq_tables), GFP_KERNEL);
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index e10922709d13..7ea217c88c2e 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -34,11 +34,6 @@
 
 static LIST_HEAD(cpufreq_policy_list);
 
-static inline bool policy_is_inactive(struct cpufreq_policy *policy)
-{
-        return cpumask_empty(policy->cpus);
-}
-
 /* Macros to iterate over CPU policies */
 #define for_each_suitable_policy(__policy, __active)                     \
         list_for_each_entry(__policy, &cpufreq_policy_list, policy_list) \
@@ -250,6 +245,51 @@ void cpufreq_cpu_put(struct cpufreq_policy *policy)
 }
 EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
 
+/**
+ * cpufreq_cpu_release - Unlock a policy and decrement its usage counter.
+ * @policy: cpufreq policy returned by cpufreq_cpu_acquire().
+ */
+void cpufreq_cpu_release(struct cpufreq_policy *policy)
+{
+        if (WARN_ON(!policy))
+                return;
+
+        lockdep_assert_held(&policy->rwsem);
+
+        up_write(&policy->rwsem);
+
+        cpufreq_cpu_put(policy);
+}
+
+/**
+ * cpufreq_cpu_acquire - Find policy for a CPU, mark it as busy and lock it.
+ * @cpu: CPU to find the policy for.
+ *
+ * Call cpufreq_cpu_get() to get a reference on the cpufreq policy for @cpu and
+ * if the policy returned by it is not NULL, acquire its rwsem for writing.
+ * Return the policy if it is active or release it and return NULL otherwise.
+ *
+ * The policy returned by this function has to be released with the help of
+ * cpufreq_cpu_release() in order to release its rwsem and balance its usage
+ * counter properly.
+ */
+struct cpufreq_policy *cpufreq_cpu_acquire(unsigned int cpu)
+{
+        struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
+
+        if (!policy)
+                return NULL;
+
+        down_write(&policy->rwsem);
+
+        if (policy_is_inactive(policy)) {
+                cpufreq_cpu_release(policy);
+                return NULL;
+        }
+
+        return policy;
+}
+
 /*********************************************************************
  *            EXTERNALLY AFFECTING FREQUENCY CHANGES                 *
  *********************************************************************/
@@ -669,9 +709,6 @@ static ssize_t show_scaling_cur_freq(struct cpufreq_policy *policy, char *buf)
         return ret;
 }
 
-static int cpufreq_set_policy(struct cpufreq_policy *policy,
-                                struct cpufreq_policy *new_policy);
-
 /**
  * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
  */
@@ -857,11 +894,9 @@ static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
 {
         unsigned int limit;
         int ret;
-        if (cpufreq_driver->bios_limit) {
-                ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
-                if (!ret)
-                        return sprintf(buf, "%u\n", limit);
-        }
+        ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
+        if (!ret)
+                return sprintf(buf, "%u\n", limit);
         return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
 }
 
@@ -1098,6 +1133,7 @@ static struct cpufreq_policy *cpufreq_policy_alloc(unsigned int cpu)
                                    cpufreq_global_kobject, "policy%u", cpu);
         if (ret) {
                 pr_err("%s: failed to init policy->kobj: %d\n", __func__, ret);
+                kobject_put(&policy->kobj);
                 goto err_free_real_cpus;
         }
 
@@ -1550,7 +1586,7 @@ static unsigned int __cpufreq_get(struct cpufreq_policy *policy)
 {
         unsigned int ret_freq = 0;
 
-        if (unlikely(policy_is_inactive(policy)) || !cpufreq_driver->get)
+        if (unlikely(policy_is_inactive(policy)))
                 return ret_freq;
 
         ret_freq = cpufreq_driver->get(policy->cpu);
@@ -1588,7 +1624,8 @@ unsigned int cpufreq_get(unsigned int cpu)
 
         if (policy) {
                 down_read(&policy->rwsem);
-                ret_freq = __cpufreq_get(policy);
+                if (cpufreq_driver->get)
+                        ret_freq = __cpufreq_get(policy);
                 up_read(&policy->rwsem);
 
                 cpufreq_cpu_put(policy);
@@ -2229,8 +2266,8 @@ EXPORT_SYMBOL(cpufreq_get_policy);
  *
  * The cpuinfo part of @policy is not updated by this function.
  */
-static int cpufreq_set_policy(struct cpufreq_policy *policy,
-                              struct cpufreq_policy *new_policy)
+int cpufreq_set_policy(struct cpufreq_policy *policy,
+                       struct cpufreq_policy *new_policy)
 {
         struct cpufreq_governor *old_gov;
         int ret;
@@ -2337,17 +2374,12 @@ static int cpufreq_set_policy(struct cpufreq_policy *policy,
  */
 void cpufreq_update_policy(unsigned int cpu)
 {
-        struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
+        struct cpufreq_policy *policy = cpufreq_cpu_acquire(cpu);
         struct cpufreq_policy new_policy;
 
         if (!policy)
                 return;
 
-        down_write(&policy->rwsem);
-
-        if (policy_is_inactive(policy))
-                goto unlock;
-
         /*
          * BIOS might change freq behind our back
          * -> ask driver for current freq and notify governors about a change
@@ -2364,12 +2396,26 @@ void cpufreq_update_policy(unsigned int cpu)
         cpufreq_set_policy(policy, &new_policy);
 
 unlock:
-        up_write(&policy->rwsem);
-
-        cpufreq_cpu_put(policy);
+        cpufreq_cpu_release(policy);
 }
 EXPORT_SYMBOL(cpufreq_update_policy);
 
+/**
+ * cpufreq_update_limits - Update policy limits for a given CPU.
+ * @cpu: CPU to update the policy limits for.
+ *
+ * Invoke the driver's ->update_limits callback if present or call
+ * cpufreq_update_policy() for @cpu.
+ */
+void cpufreq_update_limits(unsigned int cpu)
+{
+        if (cpufreq_driver->update_limits)
+                cpufreq_driver->update_limits(cpu);
+        else
+                cpufreq_update_policy(cpu);
+}
+EXPORT_SYMBOL_GPL(cpufreq_update_limits);
+
 /*********************************************************************
  *               BOOST                                               *
  *********************************************************************/
@@ -2426,7 +2472,7 @@ int cpufreq_boost_trigger_state(int state)
 
 static bool cpufreq_boost_supported(void)
 {
-        return likely(cpufreq_driver) && cpufreq_driver->set_boost;
+        return cpufreq_driver->set_boost;
 }
 
 static int create_boost_sysfs_file(void)
diff --git a/drivers/cpufreq/cpufreq_governor.c b/drivers/cpufreq/cpufreq_governor.c
index ffa9adeaba31..9d1d9bf02710 100644
--- a/drivers/cpufreq/cpufreq_governor.c
+++ b/drivers/cpufreq/cpufreq_governor.c
@@ -459,6 +459,8 @@ int cpufreq_dbs_governor_init(struct cpufreq_policy *policy)
         /* Failure, so roll back. */
         pr_err("initialization failed (dbs_data kobject init error %d)\n", ret);
 
+        kobject_put(&dbs_data->attr_set.kobj);
+
         policy->governor_data = NULL;
 
         if (!have_governor_per_policy())
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index e2db5581489a..08b192eb22c6 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -14,7 +14,6 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 
-static DEFINE_SPINLOCK(cpufreq_stats_lock);
 
 struct cpufreq_stats {
         unsigned int total_trans;
@@ -23,6 +22,7 @@ struct cpufreq_stats {
         unsigned int state_num;
         unsigned int last_index;
         u64 *time_in_state;
+        spinlock_t lock;
         unsigned int *freq_table;
         unsigned int *trans_table;
 };
@@ -39,12 +39,12 @@ static void cpufreq_stats_clear_table(struct cpufreq_stats *stats)
 {
         unsigned int count = stats->max_state;
 
-        spin_lock(&cpufreq_stats_lock);
+        spin_lock(&stats->lock);
         memset(stats->time_in_state, 0, count * sizeof(u64));
         memset(stats->trans_table, 0, count * count * sizeof(int));
         stats->last_time = get_jiffies_64();
         stats->total_trans = 0;
-        spin_unlock(&cpufreq_stats_lock);
+        spin_unlock(&stats->lock);
 }
 
 static ssize_t show_total_trans(struct cpufreq_policy *policy, char *buf)
@@ -62,9 +62,9 @@ static ssize_t show_time_in_state(struct cpufreq_policy *policy, char *buf)
         if (policy->fast_switch_enabled)
                 return 0;
 
-        spin_lock(&cpufreq_stats_lock);
+        spin_lock(&stats->lock);
         cpufreq_stats_update(stats);
-        spin_unlock(&cpufreq_stats_lock);
+        spin_unlock(&stats->lock);
 
         for (i = 0; i < stats->state_num; i++) {
                 len += sprintf(buf + len, "%u %llu\n", stats->freq_table[i],
@@ -211,6 +211,7 @@ void cpufreq_stats_create_table(struct cpufreq_policy *policy)
         stats->state_num = i;
         stats->last_time = get_jiffies_64();
         stats->last_index = freq_table_get_index(stats, policy->cur);
+        spin_lock_init(&stats->lock);
 
         policy->stats = stats;
         ret = sysfs_create_group(&policy->kobj, &stats_attr_group);
@@ -242,11 +243,11 @@ void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
         if (old_index == -1 || new_index == -1 || old_index == new_index)
                 return;
 
-        spin_lock(&cpufreq_stats_lock);
+        spin_lock(&stats->lock);
         cpufreq_stats_update(stats);
 
         stats->last_index = new_index;
         stats->trans_table[old_index * stats->max_state + new_index]++;
         stats->total_trans++;
-        spin_unlock(&cpufreq_stats_lock);
+        spin_unlock(&stats->lock);
 }
diff --git a/drivers/cpufreq/freq_table.c b/drivers/cpufreq/freq_table.c
index 3a8cc99e6815..e7be0af3199f 100644
--- a/drivers/cpufreq/freq_table.c
+++ b/drivers/cpufreq/freq_table.c
@@ -290,9 +290,6 @@ EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_boost_freqs);
 
 struct freq_attr *cpufreq_generic_attr[] = {
         &cpufreq_freq_attr_scaling_available_freqs,
-#ifdef CONFIG_CPU_FREQ_BOOST_SW
-        &cpufreq_freq_attr_scaling_boost_freqs,
-#endif
         NULL,
 };
 EXPORT_SYMBOL_GPL(cpufreq_generic_attr);
diff --git a/drivers/cpufreq/imx6q-cpufreq.c b/drivers/cpufreq/imx6q-cpufreq.c
index a4ff09f91c8f..3e17560b1efe 100644
--- a/drivers/cpufreq/imx6q-cpufreq.c
+++ b/drivers/cpufreq/imx6q-cpufreq.c
@@ -388,11 +388,11 @@ static int imx6q_cpufreq_probe(struct platform_device *pdev)
                 ret = imx6ul_opp_check_speed_grading(cpu_dev);
                 if (ret) {
                         if (ret == -EPROBE_DEFER)
-                                return ret;
+                                goto put_node;
 
                         dev_err(cpu_dev, "failed to read ocotp: %d\n",
                                 ret);
-                        return ret;
+                        goto put_node;
                 }
         } else {
                 imx6q_opp_check_speed_grading(cpu_dev);
diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
index 2986119dd31f..34b54df41aaa 100644
--- a/drivers/cpufreq/intel_pstate.c
+++ b/drivers/cpufreq/intel_pstate.c
@@ -179,6 +179,7 @@ struct vid_data {
  *                      based on the MSR_IA32_MISC_ENABLE value and whether or
  *                      not the maximum reported turbo P-state is different from
  *                      the maximum reported non-turbo one.
+ * @turbo_disabled_mf:  The @turbo_disabled value reflected by cpuinfo.max_freq.
  * @min_perf_pct:       Minimum capacity limit in percent of the maximum turbo
  *                      P-state capacity.
  * @max_perf_pct:       Maximum capacity limit in percent of the maximum turbo
@@ -187,6 +188,7 @@ struct vid_data {
 struct global_params {
         bool no_turbo;
         bool turbo_disabled;
+        bool turbo_disabled_mf;
         int max_perf_pct;
         int min_perf_pct;
 };
@@ -525,7 +527,7 @@ static s16 intel_pstate_get_epb(struct cpudata *cpu_data)
         u64 epb;
         int ret;
 
-        if (!static_cpu_has(X86_FEATURE_EPB))
+        if (!boot_cpu_has(X86_FEATURE_EPB))
                 return -ENXIO;
 
         ret = rdmsrl_on_cpu(cpu_data->cpu, MSR_IA32_ENERGY_PERF_BIAS, &epb);
@@ -539,7 +541,7 @@ static s16 intel_pstate_get_epp(struct cpudata *cpu_data, u64 hwp_req_data)
 {
         s16 epp;
 
-        if (static_cpu_has(X86_FEATURE_HWP_EPP)) {
+        if (boot_cpu_has(X86_FEATURE_HWP_EPP)) {
                 /*
                  * When hwp_req_data is 0, means that caller didn't read
                  * MSR_HWP_REQUEST, so need to read and get EPP.
@@ -564,7 +566,7 @@ static int intel_pstate_set_epb(int cpu, s16 pref)
         u64 epb;
         int ret;
 
-        if (!static_cpu_has(X86_FEATURE_EPB))
+        if (!boot_cpu_has(X86_FEATURE_EPB))
                 return -ENXIO;
 
         ret = rdmsrl_on_cpu(cpu, MSR_IA32_ENERGY_PERF_BIAS, &epb);
@@ -612,7 +614,7 @@ static int intel_pstate_get_energy_pref_index(struct cpudata *cpu_data)
         if (epp < 0)
                 return epp;
 
-        if (static_cpu_has(X86_FEATURE_HWP_EPP)) {
+        if (boot_cpu_has(X86_FEATURE_HWP_EPP)) {
                 if (epp == HWP_EPP_PERFORMANCE)
                         return 1;
                 if (epp <= HWP_EPP_BALANCE_PERFORMANCE)
@@ -621,7 +623,7 @@ static int intel_pstate_get_energy_pref_index(struct cpudata *cpu_data)
                         return 3;
                 else
                         return 4;
-        } else if (static_cpu_has(X86_FEATURE_EPB)) {
+        } else if (boot_cpu_has(X86_FEATURE_EPB)) {
                 /*
                  * Range:
                  *      0x00-0x03       :       Performance
@@ -649,7 +651,7 @@ static int intel_pstate_set_energy_pref_index(struct cpudata *cpu_data,
 
         mutex_lock(&intel_pstate_limits_lock);
 
-        if (static_cpu_has(X86_FEATURE_HWP_EPP)) {
+        if (boot_cpu_has(X86_FEATURE_HWP_EPP)) {
                 u64 value;
 
                 ret = rdmsrl_on_cpu(cpu_data->cpu, MSR_HWP_REQUEST, &value);
@@ -824,7 +826,7 @@ static void intel_pstate_hwp_set(unsigned int cpu)
                 epp = cpu_data->epp_powersave;
         }
 update_epp:
-        if (static_cpu_has(X86_FEATURE_HWP_EPP)) {
+        if (boot_cpu_has(X86_FEATURE_HWP_EPP)) {
                 value &= ~GENMASK_ULL(31, 24);
                 value |= (u64)epp << 24;
         } else {
@@ -849,7 +851,7 @@ static void intel_pstate_hwp_force_min_perf(int cpu)
         value |= HWP_MIN_PERF(min_perf);
 
         /* Set EPP/EPB to min */
-        if (static_cpu_has(X86_FEATURE_HWP_EPP))
+        if (boot_cpu_has(X86_FEATURE_HWP_EPP))
                 value |= HWP_ENERGY_PERF_PREFERENCE(HWP_EPP_POWERSAVE);
         else
                 intel_pstate_set_epb(cpu, HWP_EPP_BALANCE_POWERSAVE);
@@ -897,6 +899,48 @@ static void intel_pstate_update_policies(void)
                 cpufreq_update_policy(cpu);
 }
 
+static void intel_pstate_update_max_freq(unsigned int cpu)
+{
+        struct cpufreq_policy *policy = cpufreq_cpu_acquire(cpu);
+        struct cpufreq_policy new_policy;
+        struct cpudata *cpudata;
+
+        if (!policy)
+                return;
+
+        cpudata = all_cpu_data[cpu];
+        policy->cpuinfo.max_freq = global.turbo_disabled_mf ?
+                        cpudata->pstate.max_freq : cpudata->pstate.turbo_freq;
+
+        memcpy(&new_policy, policy, sizeof(*policy));
+        new_policy.max = min(policy->user_policy.max, policy->cpuinfo.max_freq);
+        new_policy.min = min(policy->user_policy.min, new_policy.max);
+
+        cpufreq_set_policy(policy, &new_policy);
+
+        cpufreq_cpu_release(policy);
+}
+
+static void intel_pstate_update_limits(unsigned int cpu)
+{
+        mutex_lock(&intel_pstate_driver_lock);
+
+        update_turbo_state();
+        /*
+         * If turbo has been turned on or off globally, policy limits for
+         * all CPUs need to be updated to reflect that.
+         */
+        if (global.turbo_disabled_mf != global.turbo_disabled) {
+                global.turbo_disabled_mf = global.turbo_disabled;
+                for_each_possible_cpu(cpu)
+                        intel_pstate_update_max_freq(cpu);
+        } else {
+                cpufreq_update_policy(cpu);
+        }
+
+        mutex_unlock(&intel_pstate_driver_lock);
+}
+
 /************************** sysfs begin ************************/
 #define show_one(file_name, object)                                     \
         static ssize_t show_##file_name                                 \
@@ -1197,7 +1241,7 @@ static void __init intel_pstate_sysfs_expose_params(void)
 static void intel_pstate_hwp_enable(struct cpudata *cpudata)
 {
         /* First disable HWP notification interrupt as we don't process them */
-        if (static_cpu_has(X86_FEATURE_HWP_NOTIFY))
+        if (boot_cpu_has(X86_FEATURE_HWP_NOTIFY))
                 wrmsrl_on_cpu(cpudata->cpu, MSR_HWP_INTERRUPT, 0x00);
 
         wrmsrl_on_cpu(cpudata->cpu, MSR_PM_ENABLE, 0x1);
@@ -2138,6 +2182,7 @@ static int __intel_pstate_cpu_init(struct cpufreq_policy *policy)
         /* cpuinfo and default policy values */
         policy->cpuinfo.min_freq = cpu->pstate.min_pstate * cpu->pstate.scaling;
         update_turbo_state();
+        global.turbo_disabled_mf = global.turbo_disabled;
         policy->cpuinfo.max_freq = global.turbo_disabled ?
                         cpu->pstate.max_pstate : cpu->pstate.turbo_pstate;
         policy->cpuinfo.max_freq *= cpu->pstate.scaling;
@@ -2182,6 +2227,7 @@ static struct cpufreq_driver intel_pstate = {
         .init           = intel_pstate_cpu_init,
         .exit           = intel_pstate_cpu_exit,
         .stop_cpu       = intel_pstate_stop_cpu,
+        .update_limits  = intel_pstate_update_limits,
         .name           = "intel_pstate",
 };
 
@@ -2316,6 +2362,7 @@ static struct cpufreq_driver intel_cpufreq = {
         .init           = intel_cpufreq_cpu_init,
         .exit           = intel_pstate_cpu_exit,
         .stop_cpu       = intel_cpufreq_stop_cpu,
+        .update_limits  = intel_pstate_update_limits,
         .name           = "intel_cpufreq",
 };
 
diff --git a/drivers/cpufreq/kirkwood-cpufreq.c b/drivers/cpufreq/kirkwood-cpufreq.c
index c2dd43f3f5d8..8d63a6dc8383 100644
--- a/drivers/cpufreq/kirkwood-cpufreq.c
+++ b/drivers/cpufreq/kirkwood-cpufreq.c
@@ -124,13 +124,14 @@ static int kirkwood_cpufreq_probe(struct platform_device *pdev)
         priv.cpu_clk = of_clk_get_by_name(np, "cpu_clk");
         if (IS_ERR(priv.cpu_clk)) {
                 dev_err(priv.dev, "Unable to get cpuclk\n");
-                return PTR_ERR(priv.cpu_clk);
+                err = PTR_ERR(priv.cpu_clk);
+                goto out_node;
         }
 
         err = clk_prepare_enable(priv.cpu_clk);
         if (err) {
                 dev_err(priv.dev, "Unable to prepare cpuclk\n");
-                return err;
+                goto out_node;
         }
 
         kirkwood_freq_table[0].frequency = clk_get_rate(priv.cpu_clk) / 1000;
@@ -161,20 +162,22 @@ static int kirkwood_cpufreq_probe(struct platform_device *pdev)
                 goto out_ddr;
         }
 
-        of_node_put(np);
-        np = NULL;
-
         err = cpufreq_register_driver(&kirkwood_cpufreq_driver);
-        if (!err)
-                return 0;
+        if (err) {
+                dev_err(priv.dev, "Failed to register cpufreq driver\n");
+                goto out_powersave;
+        }
 
-        dev_err(priv.dev, "Failed to register cpufreq driver\n");
+        of_node_put(np);
+        return 0;
 
+out_powersave:
         clk_disable_unprepare(priv.powersave_clk);
 out_ddr:
         clk_disable_unprepare(priv.ddr_clk);
 out_cpu:
         clk_disable_unprepare(priv.cpu_clk);
+out_node:
         of_node_put(np);
 
         return err;
diff --git a/drivers/cpufreq/maple-cpufreq.c b/drivers/cpufreq/maple-cpufreq.c
index d9df89392b84..a94355723ef8 100644
--- a/drivers/cpufreq/maple-cpufreq.c
+++ b/drivers/cpufreq/maple-cpufreq.c
@@ -210,7 +210,7 @@ static int __init maple_cpufreq_init(void)
          */
         valp = of_get_property(cpunode, "clock-frequency", NULL);
         if (!valp)
-                return -ENODEV;
+                goto bail_noprops;
         max_freq = (*valp)/1000;
         maple_cpu_freqs[0].frequency = max_freq;
         maple_cpu_freqs[1].frequency = max_freq/2;
@@ -231,10 +231,6 @@ static int __init maple_cpufreq_init(void)
 
         rc = cpufreq_register_driver(&maple_cpufreq_driver);
 
-        of_node_put(cpunode);
-
-        return rc;
-
 bail_noprops:
         of_node_put(cpunode);
 
diff --git a/drivers/cpufreq/pasemi-cpufreq.c b/drivers/cpufreq/pasemi-cpufreq.c
index 75dfbd2a58ea..c7710c149de8 100644
--- a/drivers/cpufreq/pasemi-cpufreq.c
+++ b/drivers/cpufreq/pasemi-cpufreq.c
@@ -146,6 +146,7 @@ static int pas_cpufreq_cpu_init(struct cpufreq_policy *policy)
 
         cpu = of_get_cpu_node(policy->cpu, NULL);
 
+        of_node_put(cpu);
         if (!cpu)
                 goto out;
 
diff --git a/drivers/cpufreq/pmac32-cpufreq.c b/drivers/cpufreq/pmac32-cpufreq.c
index 52f0d91d30c1..9b4ce2eb8222 100644
--- a/drivers/cpufreq/pmac32-cpufreq.c
+++ b/drivers/cpufreq/pmac32-cpufreq.c
@@ -552,6 +552,7 @@ static int pmac_cpufreq_init_7447A(struct device_node *cpunode)
         volt_gpio_np = of_find_node_by_name(NULL, "cpu-vcore-select");
         if (volt_gpio_np)
                 voltage_gpio = read_gpio(volt_gpio_np);
+        of_node_put(volt_gpio_np);
         if (!voltage_gpio){
                 pr_err("missing cpu-vcore-select gpio\n");
                 return 1;
@@ -588,6 +589,7 @@ static int pmac_cpufreq_init_750FX(struct device_node *cpunode)
         if (volt_gpio_np)
                 voltage_gpio = read_gpio(volt_gpio_np);
 
+        of_node_put(volt_gpio_np);
         pvr = mfspr(SPRN_PVR);
         has_cpu_l2lve = !((pvr & 0xf00) == 0x100);
 
diff --git a/drivers/cpufreq/powernow-k8.c b/drivers/cpufreq/powernow-k8.c
index fb77b39a4ce3..3c12e03fa343 100644
--- a/drivers/cpufreq/powernow-k8.c
+++ b/drivers/cpufreq/powernow-k8.c
@@ -1178,7 +1178,7 @@ static int powernowk8_init(void)
         unsigned int i, supported_cpus = 0;
         int ret;
 
-        if (static_cpu_has(X86_FEATURE_HW_PSTATE)) {
+        if (boot_cpu_has(X86_FEATURE_HW_PSTATE)) {
                 __request_acpi_cpufreq();
                 return -ENODEV;
         }
diff --git a/drivers/cpufreq/ppc_cbe_cpufreq.c b/drivers/cpufreq/ppc_cbe_cpufreq.c
index 41a0f0be3f9f..8414c3a4ea08 100644
--- a/drivers/cpufreq/ppc_cbe_cpufreq.c
+++ b/drivers/cpufreq/ppc_cbe_cpufreq.c
@@ -86,6 +86,7 @@ static int cbe_cpufreq_cpu_init(struct cpufreq_policy *policy)
         if (!cbe_get_cpu_pmd_regs(policy->cpu) ||
             !cbe_get_cpu_mic_tm_regs(policy->cpu)) {
                 pr_info("invalid CBE regs pointers for cpufreq\n");
+                of_node_put(cpu);
                 return -EINVAL;
         }
 
diff --git a/drivers/cpufreq/qoriq-cpufreq.c b/drivers/cpufreq/qoriq-cpufreq.c
index 4295e5476264..71b640c8c1a5 100644
--- a/drivers/cpufreq/qoriq-cpufreq.c
+++ b/drivers/cpufreq/qoriq-cpufreq.c
@@ -280,10 +280,12 @@ static const struct of_device_id node_matches[] __initconst = {
 
         { .compatible = "fsl,ls1012a-clockgen", },
         { .compatible = "fsl,ls1021a-clockgen", },
+        { .compatible = "fsl,ls1028a-clockgen", },
         { .compatible = "fsl,ls1043a-clockgen", },
         { .compatible = "fsl,ls1046a-clockgen", },
         { .compatible = "fsl,ls1088a-clockgen", },
         { .compatible = "fsl,ls2080a-clockgen", },
+        { .compatible = "fsl,lx2160a-clockgen", },
         { .compatible = "fsl,p4080-clockgen", },
         { .compatible = "fsl,qoriq-clockgen-1.0", },
         { .compatible = "fsl,qoriq-clockgen-2.0", },
diff --git a/drivers/cpufreq/speedstep-centrino.c b/drivers/cpufreq/speedstep-centrino.c
index a1fb735685db..e086b2dd4072 100644
--- a/drivers/cpufreq/speedstep-centrino.c
+++ b/drivers/cpufreq/speedstep-centrino.c
@@ -412,7 +412,7 @@ static int centrino_cpu_exit(struct cpufreq_policy *policy)
 }
 
 /**
- * centrino_setpolicy - set a new CPUFreq policy
+ * centrino_target - set a new CPUFreq policy
  * @policy: new policy
  * @index: index of target frequency
  *
diff --git a/drivers/cpuidle/cpuidle-exynos.c b/drivers/cpuidle/cpuidle-exynos.c
index 0171a6e190d7..f7199a35cbb6 100644
--- a/drivers/cpuidle/cpuidle-exynos.c
+++ b/drivers/cpuidle/cpuidle-exynos.c
@@ -84,7 +84,7 @@ static struct cpuidle_driver exynos_idle_driver = {
                 [1] = {
                         .enter                  = exynos_enter_lowpower,
                         .exit_latency           = 300,
-                        .target_residency       = 100000,
+                        .target_residency       = 10000,
                         .name                   = "C1",
                         .desc                   = "ARM power down",
                 },
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index 7f108309e871..0f4b7c45df3e 100644
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -328,9 +328,23 @@ int cpuidle_select(struct cpuidle_driver *drv, struct cpuidle_device *dev,
 int cpuidle_enter(struct cpuidle_driver *drv, struct cpuidle_device *dev,
                   int index)
 {
+        int ret = 0;
+
+        /*
+         * Store the next hrtimer, which becomes either next tick or the next
+         * timer event, whatever expires first. Additionally, to make this data
+         * useful for consumers outside cpuidle, we rely on that the governor's
+         * ->select() callback have decided, whether to stop the tick or not.
+         */
+        WRITE_ONCE(dev->next_hrtimer, tick_nohz_get_next_hrtimer());
+
         if (cpuidle_state_is_coupled(drv, index))
-                return cpuidle_enter_state_coupled(dev, drv, index);
-        return cpuidle_enter_state(dev, drv, index);
+                ret = cpuidle_enter_state_coupled(dev, drv, index);
+        else
+                ret = cpuidle_enter_state(dev, drv, index);
+
+        WRITE_ONCE(dev->next_hrtimer, 0);
+        return ret;
 }
 
 /**
@@ -511,6 +525,7 @@ static void __cpuidle_device_init(struct cpuidle_device *dev)
 {
         memset(dev->states_usage, 0, sizeof(dev->states_usage));
         dev->last_residency = 0;
+        dev->next_hrtimer = 0;
 }
 
 /**
diff --git a/drivers/devfreq/devfreq-event.c b/drivers/devfreq/devfreq-event.c
index d67242d87744..87e93406d7cd 100644
--- a/drivers/devfreq/devfreq-event.c
+++ b/drivers/devfreq/devfreq-event.c
@@ -240,7 +240,7 @@ struct devfreq_event_dev *devfreq_event_get_edev_by_phandle(struct device *dev,
         }
 
         list_for_each_entry(edev, &devfreq_event_list, node) {
-                if (!strcmp(edev->desc->name, node->name))
+                if (of_node_name_eq(node, edev->desc->name))
                         goto out;
         }
         edev = NULL;
diff --git a/drivers/devfreq/devfreq.c b/drivers/devfreq/devfreq.c
index 0ae3de76833b..6b6991f0e873 100644
--- a/drivers/devfreq/devfreq.c
+++ b/drivers/devfreq/devfreq.c
@@ -29,6 +29,9 @@
 #include <linux/of.h>
 #include "governor.h"
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/devfreq.h>
+
 static struct class *devfreq_class;
 
 /*
@@ -228,7 +231,7 @@ static struct devfreq_governor *find_devfreq_governor(const char *name)
  * if is not found. This can happen when both drivers (the governor driver
  * and the driver that call devfreq_add_device) are built as modules.
  * devfreq_list_lock should be held by the caller. Returns the matched
- * governor's pointer.
+ * governor's pointer or an error pointer.
  */
 static struct devfreq_governor *try_then_request_governor(const char *name)
 {
@@ -254,7 +257,7 @@ static struct devfreq_governor *try_then_request_governor(const char *name)
                 /* Restore previous state before return */
                 mutex_lock(&devfreq_list_lock);
                 if (err)
-                        return NULL;
+                        return ERR_PTR(err);
 
                 governor = find_devfreq_governor(name);
         }
@@ -394,6 +397,8 @@ static void devfreq_monitor(struct work_struct *work)
         queue_delayed_work(devfreq_wq, &devfreq->work,
                                 msecs_to_jiffies(devfreq->profile->polling_ms));
         mutex_unlock(&devfreq->lock);
+
+        trace_devfreq_monitor(devfreq);
 }
 
 /**
@@ -528,7 +533,7 @@ void devfreq_interval_update(struct devfreq *devfreq, unsigned int *delay)
                 mutex_lock(&devfreq->lock);
                 if (!devfreq->stop_polling)
                         queue_delayed_work(devfreq_wq, &devfreq->work,
-                              msecs_to_jiffies(devfreq->profile->polling_ms));
+                                msecs_to_jiffies(devfreq->profile->polling_ms));
         }
 out:
         mutex_unlock(&devfreq->lock);
@@ -537,7 +542,7 @@ EXPORT_SYMBOL(devfreq_interval_update);
 
 /**
  * devfreq_notifier_call() - Notify that the device frequency requirements
- *                         has been changed out of devfreq framework.
+ *                           has been changed out of devfreq framework.
  * @nb:         the notifier_block (supposed to be devfreq->nb)
  * @type:       not used
  * @devp:       not used
@@ -651,7 +656,7 @@ struct devfreq *devfreq_add_device(struct device *dev,
                 mutex_unlock(&devfreq->lock);
                 err = set_freq_table(devfreq);
                 if (err < 0)
-                        goto err_out;
+                        goto err_dev;
                 mutex_lock(&devfreq->lock);
         }
 
@@ -683,16 +688,27 @@ struct devfreq *devfreq_add_device(struct device *dev,
                 goto err_out;
         }
 
-        devfreq->trans_table =
-                devm_kzalloc(&devfreq->dev,
-                             array3_size(sizeof(unsigned int),
-                                         devfreq->profile->max_state,
-                                         devfreq->profile->max_state),
-                             GFP_KERNEL);
+        devfreq->trans_table = devm_kzalloc(&devfreq->dev,
+                        array3_size(sizeof(unsigned int),
+                                    devfreq->profile->max_state,
+                                    devfreq->profile->max_state),
+                        GFP_KERNEL);
+        if (!devfreq->trans_table) {
+                mutex_unlock(&devfreq->lock);
+                err = -ENOMEM;
+                goto err_devfreq;
+        }
+
         devfreq->time_in_state = devm_kcalloc(&devfreq->dev,
-                                                devfreq->profile->max_state,
-                                                sizeof(unsigned long),
-                                                GFP_KERNEL);
+                        devfreq->profile->max_state,
+                        sizeof(unsigned long),
+                        GFP_KERNEL);
+        if (!devfreq->time_in_state) {
+                mutex_unlock(&devfreq->lock);
+                err = -ENOMEM;
+                goto err_devfreq;
+        }
+
         devfreq->last_stat_updated = jiffies;
 
         srcu_init_notifier_head(&devfreq->transition_notifier_list);
@@ -726,7 +742,7 @@ struct devfreq *devfreq_add_device(struct device *dev,
 
 err_init:
         mutex_unlock(&devfreq_list_lock);
-
+err_devfreq:
         devfreq_remove_device(devfreq);
         devfreq = NULL;
 err_dev:
@@ -1113,7 +1129,7 @@ static ssize_t governor_store(struct device *dev, struct device_attribute *attr,
         struct devfreq *df = to_devfreq(dev);
         int ret;
         char str_governor[DEVFREQ_NAME_LEN + 1];
-        struct devfreq_governor *governor;
+        const struct devfreq_governor *governor, *prev_governor;
 
         ret = sscanf(buf, "%" __stringify(DEVFREQ_NAME_LEN) "s", str_governor);
         if (ret != 1)
@@ -1142,12 +1158,24 @@ static ssize_t governor_store(struct device *dev, struct device_attribute *attr,
                         goto out;
                 }
         }
+        prev_governor = df->governor;
         df->governor = governor;
         strncpy(df->governor_name, governor->name, DEVFREQ_NAME_LEN);
         ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
-        if (ret)
+        if (ret) {
                 dev_warn(dev, "%s: Governor %s not started(%d)\n",
                          __func__, df->governor->name, ret);
+                df->governor = prev_governor;
+                strncpy(df->governor_name, prev_governor->name,
+                        DEVFREQ_NAME_LEN);
+                ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
+                if (ret) {
+                        dev_err(dev,
+                                "%s: reverting to Governor %s failed (%d)\n",
+                                __func__, df->governor_name, ret);
+                        df->governor = NULL;
+                }
+        }
 out:
         mutex_unlock(&devfreq_list_lock);
 
@@ -1172,7 +1200,7 @@ static ssize_t available_governors_show(struct device *d,
          */
         if (df->governor->immutable) {
                 count = scnprintf(&buf[count], DEVFREQ_NAME_LEN,
-                                   "%s ", df->governor_name);
+                                  "%s ", df->governor_name);
         /*
          * The devfreq device shows the registered governor except for
          * immutable governors such as passive governor .
@@ -1485,8 +1513,8 @@ EXPORT_SYMBOL(devfreq_recommended_opp);
 
 /**
  * devfreq_register_opp_notifier() - Helper function to get devfreq notified
- *                                 for any changes in the OPP availability
- *                                 changes
+ *                                   for any changes in the OPP availability
+ *                                   changes
  * @dev:        The devfreq user device. (parent of devfreq)
  * @devfreq:    The devfreq object.
  */
@@ -1498,8 +1526,8 @@ EXPORT_SYMBOL(devfreq_register_opp_notifier);
 
 /**
  * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq
- *                                   notified for any changes in the OPP
- *                                   availability changes anymore.
+ *                                     notified for any changes in the OPP
+ *                                     availability changes anymore.
  * @dev:        The devfreq user device. (parent of devfreq)
  * @devfreq:    The devfreq object.
  *
@@ -1518,8 +1546,8 @@ static void devm_devfreq_opp_release(struct device *dev, void *res)
 }
 
 /**
- * devm_ devfreq_register_opp_notifier()
- *              - Resource-managed devfreq_register_opp_notifier()
+ * devm_devfreq_register_opp_notifier() - Resource-managed
+ *                                        devfreq_register_opp_notifier()
  * @dev:        The devfreq user device. (parent of devfreq)
  * @devfreq:    The devfreq object.
  */
@@ -1547,8 +1575,8 @@ int devm_devfreq_register_opp_notifier(struct device *dev,
 EXPORT_SYMBOL(devm_devfreq_register_opp_notifier);
 
 /**
- * devm_devfreq_unregister_opp_notifier()
- *              - Resource-managed devfreq_unregister_opp_notifier()
+ * devm_devfreq_unregister_opp_notifier() - Resource-managed
+ *                                          devfreq_unregister_opp_notifier()
  * @dev:        The devfreq user device. (parent of devfreq)
  * @devfreq:    The devfreq object.
  */
@@ -1567,8 +1595,8 @@ EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier);
  * @list:       DEVFREQ_TRANSITION_NOTIFIER.
  */
 int devfreq_register_notifier(struct devfreq *devfreq,
-                                struct notifier_block *nb,
-                                unsigned int list)
+                              struct notifier_block *nb,
+                              unsigned int list)
 {
         int ret = 0;
 
@@ -1674,9 +1702,9 @@ EXPORT_SYMBOL(devm_devfreq_register_notifier);
  * @list:       DEVFREQ_TRANSITION_NOTIFIER.
  */
 void devm_devfreq_unregister_notifier(struct device *dev,
-                                struct devfreq *devfreq,
-                                struct notifier_block *nb,
-                                unsigned int list)
+                                      struct devfreq *devfreq,
+                                      struct notifier_block *nb,
+                                      unsigned int list)
 {
         WARN_ON(devres_release(dev, devm_devfreq_notifier_release,
                                devm_devfreq_dev_match, devfreq));
diff --git a/drivers/devfreq/event/exynos-ppmu.c b/drivers/devfreq/event/exynos-ppmu.c
index c61de0bdf053..c2ea94957501 100644
--- a/drivers/devfreq/event/exynos-ppmu.c
+++ b/drivers/devfreq/event/exynos-ppmu.c
@@ -529,7 +529,7 @@ static int of_get_devfreq_events(struct device_node *np,
                         if (!ppmu_events[i].name)
                                 continue;
 
-                        if (!of_node_cmp(node->name, ppmu_events[i].name))
+                        if (of_node_name_eq(node, ppmu_events[i].name))
                                 break;
                 }
 
diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 22b113363ffc..a436ec4901bb 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -26,6 +26,8 @@
 #include <linux/list.h>
 #include <linux/of.h>
 
+#include <soc/rockchip/rk3399_grf.h>
+
 #define RK3399_DMC_NUM_CH       2
 
 /* DDRMON_CTRL */
@@ -43,18 +45,6 @@
 #define DDRMON_CH1_COUNT_NUM            0x3c
 #define DDRMON_CH1_DFI_ACCESS_NUM       0x40
 
-/* pmu grf */
-#define PMUGRF_OS_REG2  0x308
-#define DDRTYPE_SHIFT   13
-#define DDRTYPE_MASK    7
-
-enum {
-        DDR3 = 3,
-        LPDDR3 = 6,
-        LPDDR4 = 7,
-        UNUSED = 0xFF
-};
-
 struct dmc_usage {
         u32 access;
         u32 total;
@@ -83,16 +73,17 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
         u32 ddr_type;
 
         /* get ddr type */
-        regmap_read(info->regmap_pmu, PMUGRF_OS_REG2, &val);
-        ddr_type = (val >> DDRTYPE_SHIFT) & DDRTYPE_MASK;
+        regmap_read(info->regmap_pmu, RK3399_PMUGRF_OS_REG2, &val);
+        ddr_type = (val >> RK3399_PMUGRF_DDRTYPE_SHIFT) &
+                    RK3399_PMUGRF_DDRTYPE_MASK;
 
         /* clear DDRMON_CTRL setting */
         writel_relaxed(CLR_DDRMON_CTRL, dfi_regs + DDRMON_CTRL);
 
         /* set ddr type to dfi */
-        if (ddr_type == LPDDR3)
+        if (ddr_type == RK3399_PMUGRF_DDRTYPE_LPDDR3)
                 writel_relaxed(LPDDR3_EN, dfi_regs + DDRMON_CTRL);
-        else if (ddr_type == LPDDR4)
+        else if (ddr_type == RK3399_PMUGRF_DDRTYPE_LPDDR4)
                 writel_relaxed(LPDDR4_EN, dfi_regs + DDRMON_CTRL);
 
         /* enable count, use software mode */
@@ -211,7 +202,7 @@ static int rockchip_dfi_probe(struct platform_device *pdev)
         if (IS_ERR(data->clk)) {
                 dev_err(dev, "Cannot get the clk dmc_clk\n");
                 return PTR_ERR(data->clk);
-        };
+        }
 
         /* try to find the optional reference to the pmu syscon */
         node = of_parse_phandle(np, "rockchip,pmu", 0);
diff --git a/drivers/devfreq/exynos-bus.c b/drivers/devfreq/exynos-bus.c
index c25658b26598..486cc5b422f1 100644
--- a/drivers/devfreq/exynos-bus.c
+++ b/drivers/devfreq/exynos-bus.c
@@ -514,6 +514,13 @@ err:
         return ret;
 }
 
+static void exynos_bus_shutdown(struct platform_device *pdev)
+{
+        struct exynos_bus *bus = dev_get_drvdata(&pdev->dev);
+
+        devfreq_suspend_device(bus->devfreq);
+}
+
 #ifdef CONFIG_PM_SLEEP
 static int exynos_bus_resume(struct device *dev)
 {
@@ -556,6 +563,7 @@ MODULE_DEVICE_TABLE(of, exynos_bus_of_match);
 
 static struct platform_driver exynos_bus_platdrv = {
         .probe          = exynos_bus_probe,
+        .shutdown       = exynos_bus_shutdown,
         .driver = {
                 .name   = "exynos-bus",
                 .pm     = &exynos_bus_pm,
diff --git a/drivers/devfreq/rk3399_dmc.c b/drivers/devfreq/rk3399_dmc.c
index e795ad2b3f6b..567c034d0301 100644
--- a/drivers/devfreq/rk3399_dmc.c
+++ b/drivers/devfreq/rk3399_dmc.c
@@ -18,14 +18,17 @@
 #include <linux/devfreq.h>
 #include <linux/devfreq-event.h>
 #include <linux/interrupt.h>
+#include <linux/mfd/syscon.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/pm_opp.h>
+#include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
 #include <linux/rwsem.h>
 #include <linux/suspend.h>
 
+#include <soc/rockchip/rk3399_grf.h>
 #include <soc/rockchip/rockchip_sip.h>
 
 struct dram_timing {
@@ -69,8 +72,11 @@ struct rk3399_dmcfreq {
         struct mutex lock;
         struct dram_timing timing;
         struct regulator *vdd_center;
+        struct regmap *regmap_pmu;
         unsigned long rate, target_rate;
         unsigned long volt, target_volt;
+        unsigned int odt_dis_freq;
+        int odt_pd_arg0, odt_pd_arg1;
 };
 
 static int rk3399_dmcfreq_target(struct device *dev, unsigned long *freq,
@@ -80,6 +86,8 @@ static int rk3399_dmcfreq_target(struct device *dev, unsigned long *freq,
         struct dev_pm_opp *opp;
         unsigned long old_clk_rate = dmcfreq->rate;
         unsigned long target_volt, target_rate;
+        struct arm_smccc_res res;
+        bool odt_enable = false;
         int err;
 
         opp = devfreq_recommended_opp(dev, freq, flags);
@@ -95,6 +103,19 @@ static int rk3399_dmcfreq_target(struct device *dev, unsigned long *freq,
 
         mutex_lock(&dmcfreq->lock);
 
+        if (target_rate >= dmcfreq->odt_dis_freq)
+                odt_enable = true;
+
+        /*
+         * This makes a SMC call to the TF-A to set the DDR PD (power-down)
+         * timings and to enable or disable the ODT (on-die termination)
+         * resistors.
+         */
+        arm_smccc_smc(ROCKCHIP_SIP_DRAM_FREQ, dmcfreq->odt_pd_arg0,
+                      dmcfreq->odt_pd_arg1,
+                      ROCKCHIP_SIP_CONFIG_DRAM_SET_ODT_PD,
+                      odt_enable, 0, 0, 0, &res);
+
         /*
          * If frequency scaling from low to high, adjust voltage first.
          * If frequency scaling from high to low, adjust frequency first.
@@ -294,11 +315,13 @@ static int rk3399_dmcfreq_probe(struct platform_device *pdev)
 {
         struct arm_smccc_res res;
         struct device *dev = &pdev->dev;
-        struct device_node *np = pdev->dev.of_node;
+        struct device_node *np = pdev->dev.of_node, *node;
         struct rk3399_dmcfreq *data;
         int ret, index, size;
         uint32_t *timing;
         struct dev_pm_opp *opp;
+        u32 ddr_type;
+        u32 val;
 
         data = devm_kzalloc(dev, sizeof(struct rk3399_dmcfreq), GFP_KERNEL);
         if (!data)
@@ -322,7 +345,7 @@ static int rk3399_dmcfreq_probe(struct platform_device *pdev)
 
                 dev_err(dev, "Cannot get the clk dmc_clk\n");
                 return PTR_ERR(data->dmc_clk);
-        };
+        }
 
         data->edev = devfreq_event_get_edev_by_phandle(dev, 0);
         if (IS_ERR(data->edev))
@@ -354,11 +377,57 @@ static int rk3399_dmcfreq_probe(struct platform_device *pdev)
                 }
         }
 
+        node = of_parse_phandle(np, "rockchip,pmu", 0);
+        if (node) {
+                data->regmap_pmu = syscon_node_to_regmap(node);
+                if (IS_ERR(data->regmap_pmu))
+                        return PTR_ERR(data->regmap_pmu);
+        }
+
+        regmap_read(data->regmap_pmu, RK3399_PMUGRF_OS_REG2, &val);
+        ddr_type = (val >> RK3399_PMUGRF_DDRTYPE_SHIFT) &
+                    RK3399_PMUGRF_DDRTYPE_MASK;
+
+        switch (ddr_type) {
+        case RK3399_PMUGRF_DDRTYPE_DDR3:
+                data->odt_dis_freq = data->timing.ddr3_odt_dis_freq;
+                break;
+        case RK3399_PMUGRF_DDRTYPE_LPDDR3:
+                data->odt_dis_freq = data->timing.lpddr3_odt_dis_freq;
+                break;
+        case RK3399_PMUGRF_DDRTYPE_LPDDR4:
+                data->odt_dis_freq = data->timing.lpddr4_odt_dis_freq;
+                break;
+        default:
+                return -EINVAL;
+        };
+
         arm_smccc_smc(ROCKCHIP_SIP_DRAM_FREQ, 0, 0,
                       ROCKCHIP_SIP_CONFIG_DRAM_INIT,
                       0, 0, 0, 0, &res);
 
         /*
+         * In TF-A there is a platform SIP call to set the PD (power-down)
+         * timings and to enable or disable the ODT (on-die termination).
+         * This call needs three arguments as follows:
+         *
+         * arg0:
+         *     bit[0-7]   : sr_idle
+         *     bit[8-15]  : sr_mc_gate_idle
+         *     bit[16-31] : standby idle
+         * arg1:
+         *     bit[0-11]  : pd_idle
+         *     bit[16-27] : srpd_lite_idle
+         * arg2:
+         *     bit[0]     : odt enable
+         */
+        data->odt_pd_arg0 = (data->timing.sr_idle & 0xff) |
+                            ((data->timing.sr_mc_gate_idle & 0xff) << 8) |
+                            ((data->timing.standby_idle & 0xffff) << 16);
+        data->odt_pd_arg1 = (data->timing.pd_idle & 0xfff) |
+                            ((data->timing.srpd_lite_idle & 0xfff) << 16);
+
+        /*
          * We add a devfreq driver to our parent since it has a device tree node
          * with operating points.
          */
diff --git a/drivers/devfreq/tegra-devfreq.c b/drivers/devfreq/tegra-devfreq.c
index c59d2eee5d30..c89ba7b834ff 100644
--- a/drivers/devfreq/tegra-devfreq.c
+++ b/drivers/devfreq/tegra-devfreq.c
@@ -573,10 +573,7 @@ static int tegra_governor_get_target(struct devfreq *devfreq,
 static int tegra_governor_event_handler(struct devfreq *devfreq,
                                         unsigned int event, void *data)
 {
-        struct tegra_devfreq *tegra;
-        int ret = 0;
-
-        tegra = dev_get_drvdata(devfreq->dev.parent);
+        struct tegra_devfreq *tegra = dev_get_drvdata(devfreq->dev.parent);
 
         switch (event) {
         case DEVFREQ_GOV_START:
@@ -600,7 +597,7 @@ static int tegra_governor_event_handler(struct devfreq *devfreq,
                 break;
         }
 
-        return ret;
+        return 0;
 }
 
 static struct devfreq_governor tegra_devfreq_governor = {
diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index cac16c4b0df3..7b655f6156fb 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -5,20 +5,6 @@
 
 menu "Firmware Drivers"
 
-config ARM_PSCI_FW
-        bool
-
-config ARM_PSCI_CHECKER
-        bool "ARM PSCI checker"
-        depends on ARM_PSCI_FW && HOTPLUG_CPU && CPU_IDLE && !TORTURE_TEST
-        help
-          Run the PSCI checker during startup. This checks that hotplug and
-          suspend operations work correctly when using PSCI.
-
-          The torture tests may interfere with the PSCI checker by turning CPUs
-          on and off through hotplug, so for now torture tests and PSCI checker
-          are mutually exclusive.
-
 config ARM_SCMI_PROTOCOL
         bool "ARM System Control and Management Interface (SCMI) Message Protocol"
         depends on ARM || ARM64 || COMPILE_TEST
@@ -270,6 +256,7 @@ config TI_SCI_PROTOCOL
 config HAVE_ARM_SMCCC
         bool
 
+source "drivers/firmware/psci/Kconfig"
 source "drivers/firmware/broadcom/Kconfig"
 source "drivers/firmware/google/Kconfig"
 source "drivers/firmware/efi/Kconfig"
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 80feb635120f..9a3909a22682 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -2,8 +2,6 @@
 #
 # Makefile for the linux kernel.
 #
-obj-$(CONFIG_ARM_PSCI_FW)       += psci.o
-obj-$(CONFIG_ARM_PSCI_CHECKER)  += psci_checker.o
 obj-$(CONFIG_ARM_SCPI_PROTOCOL) += arm_scpi.o
 obj-$(CONFIG_ARM_SCPI_POWER_DOMAIN) += scpi_pm_domain.o
 obj-$(CONFIG_ARM_SDE_INTERFACE) += arm_sdei.o
@@ -25,6 +23,7 @@ CFLAGS_qcom_scm-32.o :=$(call as-instr,.arch armv7-a\n.arch_extension sec,-DREQU
 obj-$(CONFIG_TI_SCI_PROTOCOL)   += ti_sci.o
 
 obj-$(CONFIG_ARM_SCMI_PROTOCOL) += arm_scmi/
+obj-y                           += psci/
 obj-y                           += broadcom/
 obj-y                           += meson/
 obj-$(CONFIG_GOOGLE_FIRMWARE)   += google/
diff --git a/drivers/firmware/psci/Kconfig b/drivers/firmware/psci/Kconfig
new file mode 100644
index 000000000000..26a3b32bf7ab
--- /dev/null
+++ b/drivers/firmware/psci/Kconfig
@@ -0,0 +1,13 @@
+config ARM_PSCI_FW
+        bool
+
+config ARM_PSCI_CHECKER
+        bool "ARM PSCI checker"
+        depends on ARM_PSCI_FW && HOTPLUG_CPU && CPU_IDLE && !TORTURE_TEST
+        help
+          Run the PSCI checker during startup. This checks that hotplug and
+          suspend operations work correctly when using PSCI.
+
+          The torture tests may interfere with the PSCI checker by turning CPUs
+          on and off through hotplug, so for now torture tests and PSCI checker
+          are mutually exclusive.
diff --git a/drivers/firmware/psci/Makefile b/drivers/firmware/psci/Makefile
new file mode 100644
index 000000000000..1956b882470f
--- /dev/null
+++ b/drivers/firmware/psci/Makefile
@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+obj-$(CONFIG_ARM_PSCI_FW)       += psci.o
+obj-$(CONFIG_ARM_PSCI_CHECKER)  += psci_checker.o
diff --git a/drivers/firmware/psci.c b/drivers/firmware/psci/psci.c
index c80ec1d03274..fe090ef43d28 100644
--- a/drivers/firmware/psci.c
+++ b/drivers/firmware/psci/psci.c
@@ -88,6 +88,7 @@ static u32 psci_function_id[PSCI_FN_MAX];
                                 PSCI_1_0_EXT_POWER_STATE_TYPE_MASK)
 
 static u32 psci_cpu_suspend_feature;
+static bool psci_system_reset2_supported;
 
 static inline bool psci_has_ext_power_state(void)
 {
@@ -95,6 +96,11 @@ static inline bool psci_has_ext_power_state(void)
                                 PSCI_1_0_FEATURES_CPU_SUSPEND_PF_MASK;
 }
 
+static inline bool psci_has_osi_support(void)
+{
+        return psci_cpu_suspend_feature & PSCI_1_0_OS_INITIATED;
+}
+
 static inline bool psci_power_state_loses_context(u32 state)
 {
         const u32 mask = psci_has_ext_power_state() ?
@@ -253,7 +259,17 @@ static int get_set_conduit_method(struct device_node *np)
 
 static void psci_sys_reset(enum reboot_mode reboot_mode, const char *cmd)
 {
-        invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET, 0, 0, 0);
+        if ((reboot_mode == REBOOT_WARM || reboot_mode == REBOOT_SOFT) &&
+            psci_system_reset2_supported) {
+                /*
+                 * reset_type[31] = 0 (architectural)
+                 * reset_type[30:0] = 0 (SYSTEM_WARM_RESET)
+                 * cookie = 0 (ignored by the implementation)
+                 */
+                invoke_psci_fn(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2), 0, 0, 0);
+        } else {
+                invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET, 0, 0, 0);
+        }
 }
 
 static void psci_sys_poweroff(void)
@@ -270,9 +286,26 @@ static int __init psci_features(u32 psci_func_id)
 #ifdef CONFIG_CPU_IDLE
 static DEFINE_PER_CPU_READ_MOSTLY(u32 *, psci_power_state);
 
+static int psci_dt_parse_state_node(struct device_node *np, u32 *state)
+{
+        int err = of_property_read_u32(np, "arm,psci-suspend-param", state);
+
+        if (err) {
+                pr_warn("%pOF missing arm,psci-suspend-param property\n", np);
+                return err;
+        }
+
+        if (!psci_power_state_is_valid(*state)) {
+                pr_warn("Invalid PSCI power state %#x\n", *state);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static int psci_dt_cpu_init_idle(struct device_node *cpu_node, int cpu)
 {
-        int i, ret, count = 0;
+        int i, ret = 0, count = 0;
         u32 *psci_states;
         struct device_node *state_node;
 
@@ -291,29 +324,16 @@ static int psci_dt_cpu_init_idle(struct device_node *cpu_node, int cpu)
                 return -ENOMEM;
 
         for (i = 0; i < count; i++) {
-                u32 state;
-
                 state_node = of_parse_phandle(cpu_node, "cpu-idle-states", i);
+                ret = psci_dt_parse_state_node(state_node, &psci_states[i]);
+                of_node_put(state_node);
 
-                ret = of_property_read_u32(state_node,
-                                           "arm,psci-suspend-param",
-                                           &state);
-                if (ret) {
-                        pr_warn(" * %pOF missing arm,psci-suspend-param property\n",
-                                state_node);
-                        of_node_put(state_node);
+                if (ret)
                         goto free_mem;
-                }
 
-                of_node_put(state_node);
-                pr_debug("psci-power-state %#x index %d\n", state, i);
-                if (!psci_power_state_is_valid(state)) {
-                        pr_warn("Invalid PSCI power state %#x\n", state);
-                        ret = -EINVAL;
-                        goto free_mem;
-                }
-                psci_states[i] = state;
+                pr_debug("psci-power-state %#x index %d\n", psci_states[i], i);
         }
+
         /* Idle states parsed correctly, initialize per-cpu pointer */
         per_cpu(psci_power_state, cpu) = psci_states;
         return 0;
@@ -451,6 +471,16 @@ static const struct platform_suspend_ops psci_suspend_ops = {
         .enter          = psci_system_suspend_enter,
 };
 
+static void __init psci_init_system_reset2(void)
+{
+        int ret;
+
+        ret = psci_features(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2));
+
+        if (ret != PSCI_RET_NOT_SUPPORTED)
+                psci_system_reset2_supported = true;
+}
+
 static void __init psci_init_system_suspend(void)
 {
         int ret;
@@ -588,6 +618,7 @@ static int __init psci_probe(void)
                 psci_init_smccc();
                 psci_init_cpu_suspend();
                 psci_init_system_suspend();
+                psci_init_system_reset2();
         }
 
         return 0;
@@ -605,9 +636,9 @@ static int __init psci_0_2_init(struct device_node *np)
         int err;
 
         err = get_set_conduit_method(np);
-
         if (err)
-                goto out_put_node;
+                return err;
+
         /*
          * Starting with v0.2, the PSCI specification introduced a call
          * (PSCI_VERSION) that allows probing the firmware version, so
@@ -615,11 +646,7 @@ static int __init psci_0_2_init(struct device_node *np)
          * can be carried out according to the specific version reported
          * by firmware
          */
-        err = psci_probe();
-
-out_put_node:
-        of_node_put(np);
-        return err;
+        return psci_probe();
 }
 
 /*
@@ -631,9 +658,8 @@ static int __init psci_0_1_init(struct device_node *np)
         int err;
 
         err = get_set_conduit_method(np);
-
         if (err)
-                goto out_put_node;
+                return err;
 
         pr_info("Using PSCI v0.1 Function IDs from DT\n");
 
@@ -657,15 +683,27 @@ static int __init psci_0_1_init(struct device_node *np)
                 psci_ops.migrate = psci_migrate;
         }
 
-out_put_node:
-        of_node_put(np);
-        return err;
+        return 0;
+}
+
+static int __init psci_1_0_init(struct device_node *np)
+{
+        int err;
+
+        err = psci_0_2_init(np);
+        if (err)
+                return err;
+
+        if (psci_has_osi_support())
+                pr_info("OSI mode supported.\n");
+
+        return 0;
 }
 
 static const struct of_device_id psci_of_match[] __initconst = {
         { .compatible = "arm,psci",     .data = psci_0_1_init},
         { .compatible = "arm,psci-0.2", .data = psci_0_2_init},
-        { .compatible = "arm,psci-1.0", .data = psci_0_2_init},
+        { .compatible = "arm,psci-1.0", .data = psci_1_0_init},
         {},
 };
 
@@ -674,6 +712,7 @@ int __init psci_dt_init(void)
         struct device_node *np;
         const struct of_device_id *matched_np;
         psci_initcall_t init_fn;
+        int ret;
 
         np = of_find_matching_node_and_match(NULL, psci_of_match, &matched_np);
 
@@ -681,7 +720,10 @@ int __init psci_dt_init(void)
                 return -ENODEV;
 
         init_fn = (psci_initcall_t)matched_np->data;
-        return init_fn(np);
+        ret = init_fn(np);
+
+        of_node_put(np);
+        return ret;
 }
 
 #ifdef CONFIG_ACPI
diff --git a/drivers/firmware/psci_checker.c b/drivers/firmware/psci/psci_checker.c
index 346943657962..346943657962 100644
--- a/drivers/firmware/psci_checker.c
+++ b/drivers/firmware/psci/psci_checker.c
diff --git a/drivers/opp/core.c b/drivers/opp/core.c
index 0420f7e8ad5b..0e7703fe733f 100644
--- a/drivers/opp/core.c
+++ b/drivers/opp/core.c
@@ -526,6 +526,60 @@ struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
 }
 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
 
+/**
+ * dev_pm_opp_find_freq_ceil_by_volt() - Find OPP with highest frequency for
+ *                                       target voltage.
+ * @dev:        Device for which we do this operation.
+ * @u_volt:     Target voltage.
+ *
+ * Search for OPP with highest (ceil) frequency and has voltage <= u_volt.
+ *
+ * Return: matching *opp, else returns ERR_PTR in case of error which should be
+ * handled using IS_ERR.
+ *
+ * Error return values can be:
+ * EINVAL:      bad parameters
+ *
+ * The callers are required to call dev_pm_opp_put() for the returned OPP after
+ * use.
+ */
+struct dev_pm_opp *dev_pm_opp_find_freq_ceil_by_volt(struct device *dev,
+                                                     unsigned long u_volt)
+{
+        struct opp_table *opp_table;
+        struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
+
+        if (!dev || !u_volt) {
+                dev_err(dev, "%s: Invalid argument volt=%lu\n", __func__,
+                        u_volt);
+                return ERR_PTR(-EINVAL);
+        }
+
+        opp_table = _find_opp_table(dev);
+        if (IS_ERR(opp_table))
+                return ERR_CAST(opp_table);
+
+        mutex_lock(&opp_table->lock);
+
+        list_for_each_entry(temp_opp, &opp_table->opp_list, node) {
+                if (temp_opp->available) {
+                        if (temp_opp->supplies[0].u_volt > u_volt)
+                                break;
+                        opp = temp_opp;
+                }
+        }
+
+        /* Increment the reference count of OPP */
+        if (!IS_ERR(opp))
+                dev_pm_opp_get(opp);
+
+        mutex_unlock(&opp_table->lock);
+        dev_pm_opp_put_opp_table(opp_table);
+
+        return opp;
+}
+EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil_by_volt);
+
 static int _set_opp_voltage(struct device *dev, struct regulator *reg,
                             struct dev_pm_opp_supply *supply)
 {