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

Pull power management updates from Rafael Wysocki:
 "The big ticket items here are the rework of suspend-to-idle in order
  to add proper support for power button wakeup from it on recent Dell
  laptops and the rework of interfaces exporting the current CPU
  frequency on x86.

  In addition to that, support for a few new pieces of hardware is
  added, the PCI/ACPI device wakeup infrastructure is simplified
  significantly and the wakeup IRQ framework is fixed to unbreak the IRQ
  bus locking infrastructure.

  Also, there are some functional improvements for intel_pstate, tools
  updates and small fixes and cleanups all over.

  Specifics:

   - Rework suspend-to-idle to allow it to take wakeup events signaled
     by the EC into account on ACPI-based platforms in order to properly
     support power button wakeup from suspend-to-idle on recent Dell
     laptops (Rafael Wysocki).

     That includes the core suspend-to-idle code rework, support for the
     Low Power S0 _DSM interface, and support for the ACPI INT0002
     Virtual GPIO device from Hans de Goede (required for USB keyboard
     wakeup from suspend-to-idle to work on some machines).

   - Stop trying to export the current CPU frequency via /proc/cpuinfo
     on x86 as that is inaccurate and confusing (Len Brown).

   - Rework the way in which the current CPU frequency is exported by
     the kernel (over the cpufreq sysfs interface) on x86 systems with
     the APERF and MPERF registers by always using values read from
     these registers, when available, to compute the current frequency
     regardless of which cpufreq driver is in use (Len Brown).

   - Rework the PCI/ACPI device wakeup infrastructure to remove the
     questionable and artificial distinction between "devices that can
     wake up the system from sleep states" and "devices that can
     generate wakeup signals in the working state" from it, which allows
     the code to be simplified quite a bit (Rafael Wysocki).

   - Fix the wakeup IRQ framework by making it use SRCU instead of RCU
     which doesn't allow sleeping in the read-side critical sections,
     but which in turn is expected to be allowed by the IRQ bus locking
     infrastructure (Thomas Gleixner).

   - Modify some computations in the intel_pstate driver to avoid
     rounding errors resulting from them (Srinivas Pandruvada).

   - Reduce the overhead of the intel_pstate driver in the HWP
     (hardware-managed P-states) mode and when the "performance" P-state
     selection algorithm is in use by making it avoid registering
     scheduler callbacks in those cases (Len Brown).

   - Rework the energy_performance_preference sysfs knob in intel_pstate
     by changing the values that correspond to different symbolic hint
     names used by it (Len Brown).

   - Make it possible to use more than one cpuidle driver at the same
     time on ARM (Daniel Lezcano).

   - Make it possible to prevent the cpuidle menu governor from using
     the 0 state by disabling it via sysfs (Nicholas Piggin).

   - Add support for FFH (Fixed Functional Hardware) MWAIT in ACPI C1 on
     AMD systems (Yazen Ghannam).

   - Make the CPPC cpufreq driver take the lowest nonlinear performance
     information into account (Prashanth Prakash).

   - Add support for hi3660 to the cpufreq-dt driver, fix the imx6q
     driver and clean up the sfi, exynos5440 and intel_pstate drivers
     (Colin Ian King, Krzysztof Kozlowski, Octavian Purdila, Rafael
     Wysocki, Tao Wang).

   - Fix a few minor issues in the generic power domains (genpd)
     framework and clean it up somewhat (Krzysztof Kozlowski, Mikko
     Perttunen, Viresh Kumar).

   - Fix a couple of minor issues in the operating performance points
     (OPP) framework and clean it up somewhat (Viresh Kumar).

   - Fix a CONFIG dependency in the hibernation core and clean it up
     slightly (Balbir Singh, Arvind Yadav, BaoJun Luo).

   - Add rk3228 support to the rockchip-io adaptive voltage scaling
     (AVS) driver (David Wu).

   - Fix an incorrect bit shift operation in the RAPL power capping
     driver (Adam Lessnau).

   - Add support for the EPP field in the HWP (hardware managed
     P-states) control register, HWP.EPP, to the x86_energy_perf_policy
     tool and update msr-index.h with HWP.EPP values (Len Brown).

   - Fix some minor issues in the turbostat tool (Len Brown).

   - Add support for AMD family 0x17 CPUs to the cpupower tool and fix a
     minor issue in it (Sherry Hurwitz).

   - Assorted cleanups, mostly related to the constification of some
     data structures (Arvind Yadav, Joe Perches, Kees Cook, Krzysztof
     Kozlowski)"

* tag 'pm-4.13-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (69 commits)
  cpufreq: Update scaling_cur_freq documentation
  cpufreq: intel_pstate: Clean up after performance governor changes
  PM: hibernate: constify attribute_group structures.
  cpuidle: menu: allow state 0 to be disabled
  intel_idle: Use more common logging style
  PM / Domains: Fix missing default_power_down_ok comment
  PM / Domains: Fix unsafe iteration over modified list of domains
  PM / Domains: Fix unsafe iteration over modified list of domain providers
  PM / Domains: Fix unsafe iteration over modified list of device links
  PM / Domains: Handle safely genpd_syscore_switch() call on non-genpd device
  PM / Domains: Call driver's noirq callbacks
  PM / core: Drop run_wake flag from struct dev_pm_info
  PCI / PM: Simplify device wakeup settings code
  PCI / PM: Drop pme_interrupt flag from struct pci_dev
  ACPI / PM: Consolidate device wakeup settings code
  ACPI / PM: Drop run_wake from struct acpi_device_wakeup_flags
  PM / QoS: constify *_attribute_group.
  PM / AVS: rockchip-io: add io selectors and supplies for rk3228
  powercap/RAPL: prevent overridding bits outside of the mask
  PM / sysfs: Constify attribute groups
  ...

1 files changed, 83 insertions, 89 deletions

diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
index eb1158532de3..48a98f11a84e 100644
--- a/drivers/cpufreq/intel_pstate.c
+++ b/drivers/cpufreq/intel_pstate.c
@@ -231,10 +231,8 @@ struct global_params {
  * @prev_cummulative_iowait: IO Wait time difference from last and
  *                      current sample
  * @sample:             Storage for storing last Sample data
- * @min_perf:           Minimum capacity limit as a fraction of the maximum
- *                      turbo P-state capacity.
- * @max_perf:           Maximum capacity limit as a fraction of the maximum
- *                      turbo P-state capacity.
+ * @min_perf_ratio:     Minimum capacity in terms of PERF or HWP ratios
+ * @max_perf_ratio:     Maximum capacity in terms of PERF or HWP ratios
  * @acpi_perf_data:     Stores ACPI perf information read from _PSS
  * @valid_pss_table:    Set to true for valid ACPI _PSS entries found
  * @epp_powersave:      Last saved HWP energy performance preference
@@ -266,8 +264,8 @@ struct cpudata {
         u64     prev_tsc;
         u64     prev_cummulative_iowait;
         struct sample sample;
-        int32_t min_perf;
-        int32_t max_perf;
+        int32_t min_perf_ratio;
+        int32_t max_perf_ratio;
 #ifdef CONFIG_ACPI
         struct acpi_processor_performance acpi_perf_data;
         bool valid_pss_table;
@@ -653,6 +651,12 @@ static const char * const energy_perf_strings[] = {
         "power",
         NULL
 };
+static const unsigned int epp_values[] = {
+        HWP_EPP_PERFORMANCE,
+        HWP_EPP_BALANCE_PERFORMANCE,
+        HWP_EPP_BALANCE_POWERSAVE,
+        HWP_EPP_POWERSAVE
+};
 
 static int intel_pstate_get_energy_pref_index(struct cpudata *cpu_data)
 {
@@ -664,17 +668,14 @@ static int intel_pstate_get_energy_pref_index(struct cpudata *cpu_data)
                 return epp;
 
         if (static_cpu_has(X86_FEATURE_HWP_EPP)) {
-                /*
-                 * Range:
-                 *      0x00-0x3F       :       Performance
-                 *      0x40-0x7F       :       Balance performance
-                 *      0x80-0xBF       :       Balance power
-                 *      0xC0-0xFF       :       Power
-                 * The EPP is a 8 bit value, but our ranges restrict the
-                 * value which can be set. Here only using top two bits
-                 * effectively.
-                 */
-                index = (epp >> 6) + 1;
+                if (epp == HWP_EPP_PERFORMANCE)
+                        return 1;
+                if (epp <= HWP_EPP_BALANCE_PERFORMANCE)
+                        return 2;
+                if (epp <= HWP_EPP_BALANCE_POWERSAVE)
+                        return 3;
+                else
+                        return 4;
         } else if (static_cpu_has(X86_FEATURE_EPB)) {
                 /*
                  * Range:
@@ -712,15 +713,8 @@ static int intel_pstate_set_energy_pref_index(struct cpudata *cpu_data,
 
                 value &= ~GENMASK_ULL(31, 24);
 
-                /*
-                 * If epp is not default, convert from index into
-                 * energy_perf_strings to epp value, by shifting 6
-                 * bits left to use only top two bits in epp.
-                 * The resultant epp need to shifted by 24 bits to
-                 * epp position in MSR_HWP_REQUEST.
-                 */
                 if (epp == -EINVAL)
-                        epp = (pref_index - 1) << 6;
+                        epp = epp_values[pref_index - 1];
 
                 value |= (u64)epp << 24;
                 ret = wrmsrl_on_cpu(cpu_data->cpu, MSR_HWP_REQUEST, value);
@@ -794,25 +788,32 @@ static struct freq_attr *hwp_cpufreq_attrs[] = {
         NULL,
 };
 
-static void intel_pstate_hwp_set(unsigned int cpu)
+static void intel_pstate_get_hwp_max(unsigned int cpu, int *phy_max,
+                                     int *current_max)
 {
-        struct cpudata *cpu_data = all_cpu_data[cpu];
-        int min, hw_min, max, hw_max;
-        u64 value, cap;
-        s16 epp;
+        u64 cap;
 
         rdmsrl_on_cpu(cpu, MSR_HWP_CAPABILITIES, &cap);
-        hw_min = HWP_LOWEST_PERF(cap);
         if (global.no_turbo)
-                hw_max = HWP_GUARANTEED_PERF(cap);
+                *current_max = HWP_GUARANTEED_PERF(cap);
         else
-                hw_max = HWP_HIGHEST_PERF(cap);
+                *current_max = HWP_HIGHEST_PERF(cap);
+
+        *phy_max = HWP_HIGHEST_PERF(cap);
+}
+
+static void intel_pstate_hwp_set(unsigned int cpu)
+{
+        struct cpudata *cpu_data = all_cpu_data[cpu];
+        int max, min;
+        u64 value;
+        s16 epp;
+
+        max = cpu_data->max_perf_ratio;
+        min = cpu_data->min_perf_ratio;
 
-        max = fp_ext_toint(hw_max * cpu_data->max_perf);
         if (cpu_data->policy == CPUFREQ_POLICY_PERFORMANCE)
                 min = max;
-        else
-                min = fp_ext_toint(hw_max * cpu_data->min_perf);
 
         rdmsrl_on_cpu(cpu, MSR_HWP_REQUEST, &value);
 
@@ -1528,8 +1529,7 @@ static void intel_pstate_max_within_limits(struct cpudata *cpu)
 
         update_turbo_state();
         pstate = intel_pstate_get_base_pstate(cpu);
-        pstate = max(cpu->pstate.min_pstate,
-                     fp_ext_toint(pstate * cpu->max_perf));
+        pstate = max(cpu->pstate.min_pstate, cpu->max_perf_ratio);
         intel_pstate_set_pstate(cpu, pstate);
 }
 
@@ -1616,9 +1616,6 @@ static inline int32_t get_target_pstate_use_cpu_load(struct cpudata *cpu)
         int32_t busy_frac, boost;
         int target, avg_pstate;
 
-        if (cpu->policy == CPUFREQ_POLICY_PERFORMANCE)
-                return cpu->pstate.turbo_pstate;
-
         busy_frac = div_fp(sample->mperf, sample->tsc);
 
         boost = cpu->iowait_boost;
@@ -1655,9 +1652,6 @@ static inline int32_t get_target_pstate_use_performance(struct cpudata *cpu)
         int32_t perf_scaled, max_pstate, current_pstate, sample_ratio;
         u64 duration_ns;
 
-        if (cpu->policy == CPUFREQ_POLICY_PERFORMANCE)
-                return cpu->pstate.turbo_pstate;
-
         /*
          * perf_scaled is the ratio of the average P-state during the last
          * sampling period to the P-state requested last time (in percent).
@@ -1695,9 +1689,8 @@ static int intel_pstate_prepare_request(struct cpudata *cpu, int pstate)
         int max_pstate = intel_pstate_get_base_pstate(cpu);
         int min_pstate;
 
-        min_pstate = max(cpu->pstate.min_pstate,
-                         fp_ext_toint(max_pstate * cpu->min_perf));
-        max_pstate = max(min_pstate, fp_ext_toint(max_pstate * cpu->max_perf));
+        min_pstate = max(cpu->pstate.min_pstate, cpu->min_perf_ratio);
+        max_pstate = max(min_pstate, cpu->max_perf_ratio);
         return clamp_t(int, pstate, min_pstate, max_pstate);
 }
 
@@ -1733,16 +1726,6 @@ static void intel_pstate_adjust_pstate(struct cpudata *cpu, int target_pstate)
                 fp_toint(cpu->iowait_boost * 100));
 }
 
-static void intel_pstate_update_util_hwp(struct update_util_data *data,
-                                         u64 time, unsigned int flags)
-{
-        struct cpudata *cpu = container_of(data, struct cpudata, update_util);
-        u64 delta_ns = time - cpu->sample.time;
-
-        if ((s64)delta_ns >= INTEL_PSTATE_HWP_SAMPLING_INTERVAL)
-                intel_pstate_sample(cpu, time);
-}
-
 static void intel_pstate_update_util_pid(struct update_util_data *data,
                                          u64 time, unsigned int flags)
 {
@@ -1934,6 +1917,9 @@ static void intel_pstate_set_update_util_hook(unsigned int cpu_num)
 {
         struct cpudata *cpu = all_cpu_data[cpu_num];
 
+        if (hwp_active)
+                return;
+
         if (cpu->update_util_set)
                 return;
 
@@ -1967,52 +1953,61 @@ static void intel_pstate_update_perf_limits(struct cpufreq_policy *policy,
 {
         int max_freq = intel_pstate_get_max_freq(cpu);
         int32_t max_policy_perf, min_policy_perf;
+        int max_state, turbo_max;
 
-        max_policy_perf = div_ext_fp(policy->max, max_freq);
-        max_policy_perf = clamp_t(int32_t, max_policy_perf, 0, int_ext_tofp(1));
+        /*
+         * HWP needs some special consideration, because on BDX the
+         * HWP_REQUEST uses abstract value to represent performance
+         * rather than pure ratios.
+         */
+        if (hwp_active) {
+                intel_pstate_get_hwp_max(cpu->cpu, &turbo_max, &max_state);
+        } else {
+                max_state = intel_pstate_get_base_pstate(cpu);
+                turbo_max = cpu->pstate.turbo_pstate;
+        }
+
+        max_policy_perf = max_state * policy->max / max_freq;
         if (policy->max == policy->min) {
                 min_policy_perf = max_policy_perf;
         } else {
-                min_policy_perf = div_ext_fp(policy->min, max_freq);
+                min_policy_perf = max_state * policy->min / max_freq;
                 min_policy_perf = clamp_t(int32_t, min_policy_perf,
                                           0, max_policy_perf);
         }
 
+        pr_debug("cpu:%d max_state %d min_policy_perf:%d max_policy_perf:%d\n",
+                 policy->cpu, max_state,
+                 min_policy_perf, max_policy_perf);
+
         /* Normalize user input to [min_perf, max_perf] */
         if (per_cpu_limits) {
-                cpu->min_perf = min_policy_perf;
-                cpu->max_perf = max_policy_perf;
+                cpu->min_perf_ratio = min_policy_perf;
+                cpu->max_perf_ratio = max_policy_perf;
         } else {
                 int32_t global_min, global_max;
 
                 /* Global limits are in percent of the maximum turbo P-state. */
-                global_max = percent_ext_fp(global.max_perf_pct);
-                global_min = percent_ext_fp(global.min_perf_pct);
-                if (max_freq != cpu->pstate.turbo_freq) {
-                        int32_t turbo_factor;
-
-                        turbo_factor = div_ext_fp(cpu->pstate.turbo_pstate,
-                                                  cpu->pstate.max_pstate);
-                        global_min = mul_ext_fp(global_min, turbo_factor);
-                        global_max = mul_ext_fp(global_max, turbo_factor);
-                }
+                global_max = DIV_ROUND_UP(turbo_max * global.max_perf_pct, 100);
+                global_min = DIV_ROUND_UP(turbo_max * global.min_perf_pct, 100);
                 global_min = clamp_t(int32_t, global_min, 0, global_max);
 
-                cpu->min_perf = max(min_policy_perf, global_min);
-                cpu->min_perf = min(cpu->min_perf, max_policy_perf);
-                cpu->max_perf = min(max_policy_perf, global_max);
-                cpu->max_perf = max(min_policy_perf, cpu->max_perf);
+                pr_debug("cpu:%d global_min:%d global_max:%d\n", policy->cpu,
+                         global_min, global_max);
 
-                /* Make sure min_perf <= max_perf */
-                cpu->min_perf = min(cpu->min_perf, cpu->max_perf);
-        }
+                cpu->min_perf_ratio = max(min_policy_perf, global_min);
+                cpu->min_perf_ratio = min(cpu->min_perf_ratio, max_policy_perf);
+                cpu->max_perf_ratio = min(max_policy_perf, global_max);
+                cpu->max_perf_ratio = max(min_policy_perf, cpu->max_perf_ratio);
 
-        cpu->max_perf = round_up(cpu->max_perf, EXT_FRAC_BITS);
-        cpu->min_perf = round_up(cpu->min_perf, EXT_FRAC_BITS);
+                /* Make sure min_perf <= max_perf */
+                cpu->min_perf_ratio = min(cpu->min_perf_ratio,
+                                          cpu->max_perf_ratio);
 
-        pr_debug("cpu:%d max_perf_pct:%d min_perf_pct:%d\n", policy->cpu,
-                 fp_ext_toint(cpu->max_perf * 100),
-                 fp_ext_toint(cpu->min_perf * 100));
+        }
+        pr_debug("cpu:%d max_perf_ratio:%d min_perf_ratio:%d\n", policy->cpu,
+                 cpu->max_perf_ratio,
+                 cpu->min_perf_ratio);
 }
 
 static int intel_pstate_set_policy(struct cpufreq_policy *policy)
@@ -2039,10 +2034,10 @@ static int intel_pstate_set_policy(struct cpufreq_policy *policy)
                  */
                 intel_pstate_clear_update_util_hook(policy->cpu);
                 intel_pstate_max_within_limits(cpu);
+        } else {
+                intel_pstate_set_update_util_hook(policy->cpu);
         }
 
-        intel_pstate_set_update_util_hook(policy->cpu);
-
         if (hwp_active)
                 intel_pstate_hwp_set(policy->cpu);
 
@@ -2115,8 +2110,8 @@ static int __intel_pstate_cpu_init(struct cpufreq_policy *policy)
 
         cpu = all_cpu_data[policy->cpu];
 
-        cpu->max_perf = int_ext_tofp(1);
-        cpu->min_perf = 0;
+        cpu->max_perf_ratio = 0xFF;
+        cpu->min_perf_ratio = 0;
 
         policy->min = cpu->pstate.min_pstate * cpu->pstate.scaling;
         policy->max = cpu->pstate.turbo_pstate * cpu->pstate.scaling;
@@ -2558,7 +2553,6 @@ static int __init intel_pstate_init(void)
                 } else {
                         hwp_active++;
                         intel_pstate.attr = hwp_cpufreq_attrs;
-                        pstate_funcs.update_util = intel_pstate_update_util_hwp;
                         goto hwp_cpu_matched;
                 }
         } else {