8 files changed, 80 insertions, 46 deletions

diff --git a/Documentation/power/runtime_pm.txt b/Documentation/power/runtime_pm.txt
index 57af2f7963ee..937e33c46211 100644
--- a/Documentation/power/runtime_pm.txt
+++ b/Documentation/power/runtime_pm.txt
@@ -435,8 +435,7 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
       PM status to 'suspended' and update its parent's counter of 'active'
       children as appropriate (it is only valid to use this function if
       'power.runtime_error' is set or 'power.disable_depth' is greater than
-      zero); it will fail and return an error code if the device has a child
-      which is active and the 'power.ignore_children' flag is unset
+      zero)
 
   bool pm_runtime_active(struct device *dev);
     - return true if the device's runtime PM status is 'active' or its
diff --git a/arch/x86/kernel/cpu/Makefile b/arch/x86/kernel/cpu/Makefile
index 90cb82dbba57..570e8bb1f386 100644
--- a/arch/x86/kernel/cpu/Makefile
+++ b/arch/x86/kernel/cpu/Makefile
@@ -22,7 +22,7 @@ obj-y			+= common.o
 obj-y                   += rdrand.o
 obj-y                   += match.o
 obj-y                   += bugs.o
-obj-$(CONFIG_CPU_FREQ)  += aperfmperf.o
+obj-y                   += aperfmperf.o
 obj-y                   += cpuid-deps.o
 
 obj-$(CONFIG_PROC_FS)   += proc.o
diff --git a/arch/x86/kernel/cpu/aperfmperf.c b/arch/x86/kernel/cpu/aperfmperf.c
index 957813e0180d..7eba34df54c3 100644
--- a/arch/x86/kernel/cpu/aperfmperf.c
+++ b/arch/x86/kernel/cpu/aperfmperf.c
@@ -14,6 +14,8 @@
 #include <linux/percpu.h>
 #include <linux/smp.h>
 
+#include "cpu.h"
+
 struct aperfmperf_sample {
         unsigned int    khz;
         ktime_t time;
@@ -24,7 +26,7 @@ struct aperfmperf_sample {
 static DEFINE_PER_CPU(struct aperfmperf_sample, samples);
 
 #define APERFMPERF_CACHE_THRESHOLD_MS   10
-#define APERFMPERF_REFRESH_DELAY_MS     20
+#define APERFMPERF_REFRESH_DELAY_MS     10
 #define APERFMPERF_STALE_THRESHOLD_MS   1000
 
 /*
@@ -38,8 +40,6 @@ static void aperfmperf_snapshot_khz(void *dummy)
         u64 aperf, aperf_delta;
         u64 mperf, mperf_delta;
         struct aperfmperf_sample *s = this_cpu_ptr(&samples);
-        ktime_t now = ktime_get();
-        s64 time_delta = ktime_ms_delta(now, s->time);
         unsigned long flags;
 
         local_irq_save(flags);
@@ -57,38 +57,68 @@ static void aperfmperf_snapshot_khz(void *dummy)
         if (mperf_delta == 0)
                 return;
 
-        s->time = now;
+        s->time = ktime_get();
         s->aperf = aperf;
         s->mperf = mperf;
-
-        /* If the previous iteration was too long ago, discard it. */
-        if (time_delta > APERFMPERF_STALE_THRESHOLD_MS)
-                s->khz = 0;
-        else
-                s->khz = div64_u64((cpu_khz * aperf_delta), mperf_delta);
+        s->khz = div64_u64((cpu_khz * aperf_delta), mperf_delta);
 }
 
-unsigned int arch_freq_get_on_cpu(int cpu)
+static bool aperfmperf_snapshot_cpu(int cpu, ktime_t now, bool wait)
 {
-        s64 time_delta;
-        unsigned int khz;
+        s64 time_delta = ktime_ms_delta(now, per_cpu(samples.time, cpu));
+
+        /* Don't bother re-computing within the cache threshold time. */
+        if (time_delta < APERFMPERF_CACHE_THRESHOLD_MS)
+                return true;
+
+        smp_call_function_single(cpu, aperfmperf_snapshot_khz, NULL, wait);
+
+        /* Return false if the previous iteration was too long ago. */
+        return time_delta <= APERFMPERF_STALE_THRESHOLD_MS;
+}
 
+unsigned int aperfmperf_get_khz(int cpu)
+{
         if (!cpu_khz)
                 return 0;
 
         if (!static_cpu_has(X86_FEATURE_APERFMPERF))
                 return 0;
 
-        /* Don't bother re-computing within the cache threshold time. */
-        time_delta = ktime_ms_delta(ktime_get(), per_cpu(samples.time, cpu));
-        khz = per_cpu(samples.khz, cpu);
-        if (khz && time_delta < APERFMPERF_CACHE_THRESHOLD_MS)
-                return khz;
+        aperfmperf_snapshot_cpu(cpu, ktime_get(), true);
+        return per_cpu(samples.khz, cpu);
+}
 
-        smp_call_function_single(cpu, aperfmperf_snapshot_khz, NULL, 1);
-        khz = per_cpu(samples.khz, cpu);
-        if (khz)
-                return khz;
+void arch_freq_prepare_all(void)
+{
+        ktime_t now = ktime_get();
+        bool wait = false;
+        int cpu;
+
+        if (!cpu_khz)
+                return;
+
+        if (!static_cpu_has(X86_FEATURE_APERFMPERF))
+                return;
+
+        for_each_online_cpu(cpu)
+                if (!aperfmperf_snapshot_cpu(cpu, now, false))
+                        wait = true;
+
+        if (wait)
+                msleep(APERFMPERF_REFRESH_DELAY_MS);
+}
+
+unsigned int arch_freq_get_on_cpu(int cpu)
+{
+        if (!cpu_khz)
+                return 0;
+
+        if (!static_cpu_has(X86_FEATURE_APERFMPERF))
+                return 0;
+
+        if (aperfmperf_snapshot_cpu(cpu, ktime_get(), true))
+                return per_cpu(samples.khz, cpu);
 
         msleep(APERFMPERF_REFRESH_DELAY_MS);
         smp_call_function_single(cpu, aperfmperf_snapshot_khz, NULL, 1);
diff --git a/arch/x86/kernel/cpu/cpu.h b/arch/x86/kernel/cpu/cpu.h
index f52a370b6c00..e806b11a99af 100644
--- a/arch/x86/kernel/cpu/cpu.h
+++ b/arch/x86/kernel/cpu/cpu.h
@@ -47,4 +47,7 @@ extern const struct cpu_dev *const __x86_cpu_dev_start[],
 
 extern void get_cpu_cap(struct cpuinfo_x86 *c);
 extern void cpu_detect_cache_sizes(struct cpuinfo_x86 *c);
+
+unsigned int aperfmperf_get_khz(int cpu);
+
 #endif /* ARCH_X86_CPU_H */
diff --git a/arch/x86/kernel/cpu/proc.c b/arch/x86/kernel/cpu/proc.c
index 6b7e17bf0b71..e7ecedafa1c8 100644
--- a/arch/x86/kernel/cpu/proc.c
+++ b/arch/x86/kernel/cpu/proc.c
@@ -5,6 +5,8 @@
 #include <linux/seq_file.h>
 #include <linux/cpufreq.h>
 
+#include "cpu.h"
+
 /*
  *      Get CPU information for use by the procfs.
  */
@@ -78,9 +80,11 @@ static int show_cpuinfo(struct seq_file *m, void *v)
                 seq_printf(m, "microcode\t: 0x%x\n", c->microcode);
 
         if (cpu_has(c, X86_FEATURE_TSC)) {
-                unsigned int freq = cpufreq_quick_get(cpu);
+                unsigned int freq = aperfmperf_get_khz(cpu);
 
                 if (!freq)
+                        freq = cpufreq_quick_get(cpu);
+                if (!freq)
                         freq = cpu_khz;
                 seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
                            freq / 1000, (freq % 1000));
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 2362b9e9701e..027d159ac381 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -1101,29 +1101,13 @@ int __pm_runtime_set_status(struct device *dev, unsigned int status)
                 goto out;
         }
 
-        if (dev->power.runtime_status == status)
+        if (dev->power.runtime_status == status || !parent)
                 goto out_set;
 
         if (status == RPM_SUSPENDED) {
-                /*
-                 * It is invalid to suspend a device with an active child,
-                 * unless it has been set to ignore its children.
-                 */
-                if (!dev->power.ignore_children &&
-                        atomic_read(&dev->power.child_count)) {
-                        dev_err(dev, "runtime PM trying to suspend device but active child\n");
-                        error = -EBUSY;
-                        goto out;
-                }
-
-                if (parent) {
-                        atomic_add_unless(&parent->power.child_count, -1, 0);
-                        notify_parent = !parent->power.ignore_children;
-                }
-                goto out_set;
-        }
-
-        if (parent) {
+                atomic_add_unless(&parent->power.child_count, -1, 0);
+                notify_parent = !parent->power.ignore_children;
+        } else {
                 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING);
 
                 /*
@@ -1307,6 +1291,13 @@ void pm_runtime_enable(struct device *dev)
         else
                 dev_warn(dev, "Unbalanced %s!\n", __func__);
 
+        WARN(!dev->power.disable_depth &&
+             dev->power.runtime_status == RPM_SUSPENDED &&
+             !dev->power.ignore_children &&
+             atomic_read(&dev->power.child_count) > 0,
+             "Enabling runtime PM for inactive device (%s) with active children\n",
+             dev_name(dev));
+
         spin_unlock_irqrestore(&dev->power.lock, flags);
 }
 EXPORT_SYMBOL_GPL(pm_runtime_enable);
diff --git a/fs/proc/cpuinfo.c b/fs/proc/cpuinfo.c
index e0f867cd8553..96f1087e372c 100644
--- a/fs/proc/cpuinfo.c
+++ b/fs/proc/cpuinfo.c
@@ -1,12 +1,18 @@
 // SPDX-License-Identifier: GPL-2.0
+#include <linux/cpufreq.h>
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 
+__weak void arch_freq_prepare_all(void)
+{
+}
+
 extern const struct seq_operations cpuinfo_op;
 static int cpuinfo_open(struct inode *inode, struct file *file)
 {
+        arch_freq_prepare_all();
         return seq_open(file, &cpuinfo_op);
 }
 
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 28734ee185a7..065f3a8eb486 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -917,6 +917,7 @@ static inline bool policy_has_boost_freq(struct cpufreq_policy *policy)
 }
 #endif
 
+extern void arch_freq_prepare_all(void);
 extern unsigned int arch_freq_get_on_cpu(int cpu);
 
 extern void arch_set_freq_scale(struct cpumask *cpus, unsigned long cur_freq,