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

Pull two power management fixes from Rafael Wysocki:
 "This is the change making /proc/cpuinfo on x86 report current CPU
  frequency in "cpu MHz" again in all cases and an additional one
  dealing with an overzealous check in one of the helper routines in the
  runtime PM framework"

* tag 'pm-fixes-4.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm:
  PM / runtime: Drop children check from __pm_runtime_set_status()
  x86 / CPU: Always show current CPU frequency in /proc/cpuinfo

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,