summarylogtreecommitdiffstats
path: root/intel-pstate-backport.patch
diff options
context:
space:
mode:
Diffstat (limited to 'intel-pstate-backport.patch')
-rw-r--r--intel-pstate-backport.patch775
1 files changed, 775 insertions, 0 deletions
diff --git a/intel-pstate-backport.patch b/intel-pstate-backport.patch
new file mode 100644
index 00000000000..8b614640124
--- /dev/null
+++ b/intel-pstate-backport.patch
@@ -0,0 +1,775 @@
+--- linux-4.6/drivers/cpufreq/intel_pstate.c.orig 2016-05-15 18:43:13.000000000 -0400
++++ linux-4.6/drivers/cpufreq/intel_pstate.c 2016-06-24 17:36:23.064118833 -0400
+@@ -10,6 +10,8 @@
+ * of the License.
+ */
+
++#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
++
+ #include <linux/kernel.h>
+ #include <linux/kernel_stat.h>
+ #include <linux/module.h>
+@@ -39,10 +41,17 @@
+ #define ATOM_TURBO_RATIOS 0x66c
+ #define ATOM_TURBO_VIDS 0x66d
+
++#ifdef CONFIG_ACPI
++#include <acpi/processor.h>
++#endif
++
+ #define FRAC_BITS 8
+ #define int_tofp(X) ((int64_t)(X) << FRAC_BITS)
+ #define fp_toint(X) ((X) >> FRAC_BITS)
+
++#define EXT_BITS 6
++#define EXT_FRAC_BITS (EXT_BITS + FRAC_BITS)
++
+ static inline int32_t mul_fp(int32_t x, int32_t y)
+ {
+ return ((int64_t)x * (int64_t)y) >> FRAC_BITS;
+@@ -64,12 +73,22 @@
+ return ret;
+ }
+
++static inline u64 mul_ext_fp(u64 x, u64 y)
++{
++ return (x * y) >> EXT_FRAC_BITS;
++}
++
++static inline u64 div_ext_fp(u64 x, u64 y)
++{
++ return div64_u64(x << EXT_FRAC_BITS, y);
++}
++
+ /**
+ * struct sample - Store performance sample
+- * @core_pct_busy: Ratio of APERF/MPERF in percent, which is actual
++ * @core_avg_perf: Ratio of APERF/MPERF which is the actual average
+ * performance during last sample period
+ * @busy_scaled: Scaled busy value which is used to calculate next
+- * P state. This can be different than core_pct_busy
++ * P state. This can be different than core_avg_perf
+ * to account for cpu idle period
+ * @aperf: Difference of actual performance frequency clock count
+ * read from APERF MSR between last and current sample
+@@ -84,7 +103,7 @@
+ * data for choosing next P State.
+ */
+ struct sample {
+- int32_t core_pct_busy;
++ int32_t core_avg_perf;
+ int32_t busy_scaled;
+ u64 aperf;
+ u64 mperf;
+@@ -162,6 +181,7 @@
+ * struct cpudata - Per CPU instance data storage
+ * @cpu: CPU number for this instance data
+ * @update_util: CPUFreq utility callback information
++ * @update_util_set: CPUFreq utility callback is set
+ * @pstate: Stores P state limits for this CPU
+ * @vid: Stores VID limits for this CPU
+ * @pid: Stores PID parameters for this CPU
+@@ -172,6 +192,8 @@
+ * @prev_cummulative_iowait: IO Wait time difference from last and
+ * current sample
+ * @sample: Storage for storing last Sample data
++ * @acpi_perf_data: Stores ACPI perf information read from _PSS
++ * @valid_pss_table: Set to true for valid ACPI _PSS entries found
+ *
+ * This structure stores per CPU instance data for all CPUs.
+ */
+@@ -179,6 +201,7 @@
+ int cpu;
+
+ struct update_util_data update_util;
++ bool update_util_set;
+
+ struct pstate_data pstate;
+ struct vid_data vid;
+@@ -190,6 +213,10 @@
+ u64 prev_tsc;
+ u64 prev_cummulative_iowait;
+ struct sample sample;
++#ifdef CONFIG_ACPI
++ struct acpi_processor_performance acpi_perf_data;
++ bool valid_pss_table;
++#endif
+ };
+
+ static struct cpudata **all_cpu_data;
+@@ -258,6 +285,9 @@
+ static struct pstate_funcs pstate_funcs;
+ static int hwp_active;
+
++#ifdef CONFIG_ACPI
++static bool acpi_ppc;
++#endif
+
+ /**
+ * struct perf_limits - Store user and policy limits
+@@ -331,6 +361,124 @@
+ static struct perf_limits *limits = &powersave_limits;
+ #endif
+
++#ifdef CONFIG_ACPI
++
++static bool intel_pstate_get_ppc_enable_status(void)
++{
++ if (acpi_gbl_FADT.preferred_profile == PM_ENTERPRISE_SERVER ||
++ acpi_gbl_FADT.preferred_profile == PM_PERFORMANCE_SERVER)
++ return true;
++
++ return acpi_ppc;
++}
++
++/*
++ * The max target pstate ratio is a 8 bit value in both PLATFORM_INFO MSR and
++ * in TURBO_RATIO_LIMIT MSR, which pstate driver stores in max_pstate and
++ * max_turbo_pstate fields. The PERF_CTL MSR contains 16 bit value for P state
++ * ratio, out of it only high 8 bits are used. For example 0x1700 is setting
++ * target ratio 0x17. The _PSS control value stores in a format which can be
++ * directly written to PERF_CTL MSR. But in intel_pstate driver this shift
++ * occurs during write to PERF_CTL (E.g. for cores core_set_pstate()).
++ * This function converts the _PSS control value to intel pstate driver format
++ * for comparison and assignment.
++ */
++static int convert_to_native_pstate_format(struct cpudata *cpu, int index)
++{
++ return cpu->acpi_perf_data.states[index].control >> 8;
++}
++
++static void intel_pstate_init_acpi_perf_limits(struct cpufreq_policy *policy)
++{
++ struct cpudata *cpu;
++ int turbo_pss_ctl;
++ int ret;
++ int i;
++
++ if (hwp_active)
++ return;
++
++ if (!intel_pstate_get_ppc_enable_status())
++ return;
++
++ cpu = all_cpu_data[policy->cpu];
++
++ ret = acpi_processor_register_performance(&cpu->acpi_perf_data,
++ policy->cpu);
++ if (ret)
++ return;
++
++ /*
++ * Check if the control value in _PSS is for PERF_CTL MSR, which should
++ * guarantee that the states returned by it map to the states in our
++ * list directly.
++ */
++ if (cpu->acpi_perf_data.control_register.space_id !=
++ ACPI_ADR_SPACE_FIXED_HARDWARE)
++ goto err;
++
++ /*
++ * If there is only one entry _PSS, simply ignore _PSS and continue as
++ * usual without taking _PSS into account
++ */
++ if (cpu->acpi_perf_data.state_count < 2)
++ goto err;
++
++ pr_debug("CPU%u - ACPI _PSS perf data\n", policy->cpu);
++ for (i = 0; i < cpu->acpi_perf_data.state_count; i++) {
++ pr_debug(" %cP%d: %u MHz, %u mW, 0x%x\n",
++ (i == cpu->acpi_perf_data.state ? '*' : ' '), i,
++ (u32) cpu->acpi_perf_data.states[i].core_frequency,
++ (u32) cpu->acpi_perf_data.states[i].power,
++ (u32) cpu->acpi_perf_data.states[i].control);
++ }
++
++ /*
++ * The _PSS table doesn't contain whole turbo frequency range.
++ * This just contains +1 MHZ above the max non turbo frequency,
++ * with control value corresponding to max turbo ratio. But
++ * when cpufreq set policy is called, it will call with this
++ * max frequency, which will cause a reduced performance as
++ * this driver uses real max turbo frequency as the max
++ * frequency. So correct this frequency in _PSS table to
++ * correct max turbo frequency based on the turbo ratio.
++ * Also need to convert to MHz as _PSS freq is in MHz.
++ */
++ turbo_pss_ctl = convert_to_native_pstate_format(cpu, 0);
++ if (turbo_pss_ctl > cpu->pstate.max_pstate)
++ cpu->acpi_perf_data.states[0].core_frequency =
++ policy->cpuinfo.max_freq / 1000;
++ cpu->valid_pss_table = true;
++ pr_info("_PPC limits will be enforced\n");
++
++ return;
++
++ err:
++ cpu->valid_pss_table = false;
++ acpi_processor_unregister_performance(policy->cpu);
++}
++
++static void intel_pstate_exit_perf_limits(struct cpufreq_policy *policy)
++{
++ struct cpudata *cpu;
++
++ cpu = all_cpu_data[policy->cpu];
++ if (!cpu->valid_pss_table)
++ return;
++
++ acpi_processor_unregister_performance(policy->cpu);
++}
++
++#else
++static void intel_pstate_init_acpi_perf_limits(struct cpufreq_policy *policy)
++{
++}
++
++static void intel_pstate_exit_perf_limits(struct cpufreq_policy *policy)
++{
++}
++#endif
++
+ static inline void pid_reset(struct _pid *pid, int setpoint, int busy,
+ int deadband, int integral) {
+ pid->setpoint = int_tofp(setpoint);
+@@ -341,17 +489,17 @@
+
+ static inline void pid_p_gain_set(struct _pid *pid, int percent)
+ {
+- pid->p_gain = div_fp(int_tofp(percent), int_tofp(100));
++ pid->p_gain = div_fp(percent, 100);
+ }
+
+ static inline void pid_i_gain_set(struct _pid *pid, int percent)
+ {
+- pid->i_gain = div_fp(int_tofp(percent), int_tofp(100));
++ pid->i_gain = div_fp(percent, 100);
+ }
+
+ static inline void pid_d_gain_set(struct _pid *pid, int percent)
+ {
+- pid->d_gain = div_fp(int_tofp(percent), int_tofp(100));
++ pid->d_gain = div_fp(percent, 100);
+ }
+
+ static signed int pid_calc(struct _pid *pid, int32_t busy)
+@@ -537,7 +685,7 @@
+
+ total = cpu->pstate.turbo_pstate - cpu->pstate.min_pstate + 1;
+ no_turbo = cpu->pstate.max_pstate - cpu->pstate.min_pstate + 1;
+- turbo_fp = div_fp(int_tofp(no_turbo), int_tofp(total));
++ turbo_fp = div_fp(no_turbo, total);
+ turbo_pct = 100 - fp_toint(mul_fp(turbo_fp, int_tofp(100)));
+ return sprintf(buf, "%u\n", turbo_pct);
+ }
+@@ -579,7 +727,7 @@
+
+ update_turbo_state();
+ if (limits->turbo_disabled) {
+- pr_warn("intel_pstate: Turbo disabled by BIOS or unavailable on processor\n");
++ pr_warn("Turbo disabled by BIOS or unavailable on processor\n");
+ return -EPERM;
+ }
+
+@@ -608,8 +756,7 @@
+ limits->max_perf_pct);
+ limits->max_perf_pct = max(limits->min_perf_pct,
+ limits->max_perf_pct);
+- limits->max_perf = div_fp(int_tofp(limits->max_perf_pct),
+- int_tofp(100));
++ limits->max_perf = div_fp(limits->max_perf_pct, 100);
+
+ if (hwp_active)
+ intel_pstate_hwp_set_online_cpus();
+@@ -633,8 +780,7 @@
+ limits->min_perf_pct);
+ limits->min_perf_pct = min(limits->max_perf_pct,
+ limits->min_perf_pct);
+- limits->min_perf = div_fp(int_tofp(limits->min_perf_pct),
+- int_tofp(100));
++ limits->min_perf = div_fp(limits->min_perf_pct, 100);
+
+ if (hwp_active)
+ intel_pstate_hwp_set_online_cpus();
+@@ -1019,15 +1165,11 @@
+ intel_pstate_set_min_pstate(cpu);
+ }
+
+-static inline void intel_pstate_calc_busy(struct cpudata *cpu)
++static inline void intel_pstate_calc_avg_perf(struct cpudata *cpu)
+ {
+ struct sample *sample = &cpu->sample;
+- int64_t core_pct;
+-
+- core_pct = int_tofp(sample->aperf) * int_tofp(100);
+- core_pct = div64_u64(core_pct, int_tofp(sample->mperf));
+
+- sample->core_pct_busy = (int32_t)core_pct;
++ sample->core_avg_perf = div_ext_fp(sample->aperf, sample->mperf);
+ }
+
+ static inline bool intel_pstate_sample(struct cpudata *cpu, u64 time)
+@@ -1070,9 +1212,14 @@
+
+ static inline int32_t get_avg_frequency(struct cpudata *cpu)
+ {
+- return fp_toint(mul_fp(cpu->sample.core_pct_busy,
+- int_tofp(cpu->pstate.max_pstate_physical *
+- cpu->pstate.scaling / 100)));
++ return mul_ext_fp(cpu->sample.core_avg_perf,
++ cpu->pstate.max_pstate_physical * cpu->pstate.scaling);
++}
++
++static inline int32_t get_avg_pstate(struct cpudata *cpu)
++{
++ return mul_ext_fp(cpu->pstate.max_pstate_physical,
++ cpu->sample.core_avg_perf);
+ }
+
+ static inline int32_t get_target_pstate_use_cpu_load(struct cpudata *cpu)
+@@ -1107,49 +1254,43 @@
+ cpu_load = div64_u64(int_tofp(100) * mperf, sample->tsc);
+ cpu->sample.busy_scaled = cpu_load;
+
+- return cpu->pstate.current_pstate - pid_calc(&cpu->pid, cpu_load);
++ return get_avg_pstate(cpu) - pid_calc(&cpu->pid, cpu_load);
+ }
+
+ static inline int32_t get_target_pstate_use_performance(struct cpudata *cpu)
+ {
+- int32_t core_busy, max_pstate, current_pstate, sample_ratio;
++ int32_t perf_scaled, max_pstate, current_pstate, sample_ratio;
+ u64 duration_ns;
+
+ /*
+- * core_busy is the ratio of actual performance to max
+- * max_pstate is the max non turbo pstate available
+- * current_pstate was the pstate that was requested during
+- * the last sample period.
+- *
+- * We normalize core_busy, which was our actual percent
+- * performance to what we requested during the last sample
+- * period. The result will be a percentage of busy at a
+- * specified pstate.
++ * perf_scaled is the average performance during the last sampling
++ * period scaled by the ratio of the maximum P-state to the P-state
++ * requested last time (in percent). That measures the system's
++ * response to the previous P-state selection.
+ */
+- core_busy = cpu->sample.core_pct_busy;
+- max_pstate = int_tofp(cpu->pstate.max_pstate_physical);
+- current_pstate = int_tofp(cpu->pstate.current_pstate);
+- core_busy = mul_fp(core_busy, div_fp(max_pstate, current_pstate));
++ max_pstate = cpu->pstate.max_pstate_physical;
++ current_pstate = cpu->pstate.current_pstate;
++ perf_scaled = mul_ext_fp(cpu->sample.core_avg_perf,
++ div_fp(100 * max_pstate, current_pstate));
+
+ /*
+ * Since our utilization update callback will not run unless we are
+ * in C0, check if the actual elapsed time is significantly greater (3x)
+ * than our sample interval. If it is, then we were idle for a long
+- * enough period of time to adjust our busyness.
++ * enough period of time to adjust our performance metric.
+ */
+ duration_ns = cpu->sample.time - cpu->last_sample_time;
+ if ((s64)duration_ns > pid_params.sample_rate_ns * 3) {
+- sample_ratio = div_fp(int_tofp(pid_params.sample_rate_ns),
+- int_tofp(duration_ns));
+- core_busy = mul_fp(core_busy, sample_ratio);
++ sample_ratio = div_fp(pid_params.sample_rate_ns, duration_ns);
++ perf_scaled = mul_fp(perf_scaled, sample_ratio);
+ } else {
+ sample_ratio = div_fp(100 * cpu->sample.mperf, cpu->sample.tsc);
+ if (sample_ratio < int_tofp(1))
+- core_busy = 0;
++ perf_scaled = 0;
+ }
+
+- cpu->sample.busy_scaled = core_busy;
+- return cpu->pstate.current_pstate - pid_calc(&cpu->pid, core_busy);
++ cpu->sample.busy_scaled = perf_scaled;
++ return cpu->pstate.current_pstate - pid_calc(&cpu->pid, perf_scaled);
+ }
+
+ static inline void intel_pstate_update_pstate(struct cpudata *cpu, int pstate)
+@@ -1179,7 +1320,7 @@
+ intel_pstate_update_pstate(cpu, target_pstate);
+
+ sample = &cpu->sample;
+- trace_pstate_sample(fp_toint(sample->core_pct_busy),
++ trace_pstate_sample(mul_ext_fp(100, sample->core_avg_perf),
+ fp_toint(sample->busy_scaled),
+ from,
+ cpu->pstate.current_pstate,
+@@ -1199,7 +1340,7 @@
+ bool sample_taken = intel_pstate_sample(cpu, time);
+
+ if (sample_taken) {
+- intel_pstate_calc_busy(cpu);
++ intel_pstate_calc_avg_perf(cpu);
+ if (!hwp_active)
+ intel_pstate_adjust_busy_pstate(cpu);
+ }
+@@ -1261,23 +1402,16 @@
+
+ intel_pstate_busy_pid_reset(cpu);
+
+- cpu->update_util.func = intel_pstate_update_util;
+-
+- pr_debug("intel_pstate: controlling: cpu %d\n", cpunum);
++ pr_debug("controlling: cpu %d\n", cpunum);
+
+ return 0;
+ }
+
+ static unsigned int intel_pstate_get(unsigned int cpu_num)
+ {
+- struct sample *sample;
+- struct cpudata *cpu;
++ struct cpudata *cpu = all_cpu_data[cpu_num];
+
+- cpu = all_cpu_data[cpu_num];
+- if (!cpu)
+- return 0;
+- sample = &cpu->sample;
+- return get_avg_frequency(cpu);
++ return cpu ? get_avg_frequency(cpu) : 0;
+ }
+
+ static void intel_pstate_set_update_util_hook(unsigned int cpu_num)
+@@ -1286,12 +1420,20 @@
+
+ /* Prevent intel_pstate_update_util() from using stale data. */
+ cpu->sample.time = 0;
+- cpufreq_set_update_util_data(cpu_num, &cpu->update_util);
++ cpufreq_add_update_util_hook(cpu_num, &cpu->update_util,
++ intel_pstate_update_util);
++ cpu->update_util_set = true;
+ }
+
+ static void intel_pstate_clear_update_util_hook(unsigned int cpu)
+ {
+- cpufreq_set_update_util_data(cpu, NULL);
++ struct cpudata *cpu_data = all_cpu_data[cpu];
++
++ if (!cpu_data->update_util_set)
++ return;
++
++ cpufreq_remove_update_util_hook(cpu);
++ cpu_data->update_util_set = false;
+ synchronize_sched();
+ }
+
+@@ -1311,20 +1453,31 @@
+
+ static int intel_pstate_set_policy(struct cpufreq_policy *policy)
+ {
++ struct cpudata *cpu;
++
+ if (!policy->cpuinfo.max_freq)
+ return -ENODEV;
+
+ intel_pstate_clear_update_util_hook(policy->cpu);
+
++ cpu = all_cpu_data[0];
++ if (cpu->pstate.max_pstate_physical > cpu->pstate.max_pstate) {
++ if (policy->max < policy->cpuinfo.max_freq &&
++ policy->max > cpu->pstate.max_pstate * cpu->pstate.scaling) {
++ pr_debug("policy->max > max non turbo frequency\n");
++ policy->max = policy->cpuinfo.max_freq;
++ }
++ }
++
+ if (policy->policy == CPUFREQ_POLICY_PERFORMANCE) {
+ limits = &performance_limits;
+ if (policy->max >= policy->cpuinfo.max_freq) {
+- pr_debug("intel_pstate: set performance\n");
++ pr_debug("set performance\n");
+ intel_pstate_set_performance_limits(limits);
+ goto out;
+ }
+ } else {
+- pr_debug("intel_pstate: set powersave\n");
++ pr_debug("set powersave\n");
+ limits = &powersave_limits;
+ }
+
+@@ -1348,10 +1501,8 @@
+ /* Make sure min_perf_pct <= max_perf_pct */
+ limits->min_perf_pct = min(limits->max_perf_pct, limits->min_perf_pct);
+
+- limits->min_perf = div_fp(int_tofp(limits->min_perf_pct),
+- int_tofp(100));
+- limits->max_perf = div_fp(int_tofp(limits->max_perf_pct),
+- int_tofp(100));
++ limits->min_perf = div_fp(limits->min_perf_pct, 100);
++ limits->max_perf = div_fp(limits->max_perf_pct, 100);
+
+ out:
+ intel_pstate_set_update_util_hook(policy->cpu);
+@@ -1377,7 +1528,7 @@
+ int cpu_num = policy->cpu;
+ struct cpudata *cpu = all_cpu_data[cpu_num];
+
+- pr_debug("intel_pstate: CPU %d exiting\n", cpu_num);
++ pr_debug("CPU %d exiting\n", cpu_num);
+
+ intel_pstate_clear_update_util_hook(cpu_num);
+
+@@ -1410,12 +1561,20 @@
+ policy->cpuinfo.min_freq = cpu->pstate.min_pstate * cpu->pstate.scaling;
+ policy->cpuinfo.max_freq =
+ cpu->pstate.turbo_pstate * cpu->pstate.scaling;
++ intel_pstate_init_acpi_perf_limits(policy);
+ policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
+ cpumask_set_cpu(policy->cpu, policy->cpus);
+
+ return 0;
+ }
+
++static int intel_pstate_cpu_exit(struct cpufreq_policy *policy)
++{
++ intel_pstate_exit_perf_limits(policy);
++
++ return 0;
++}
++
+ static struct cpufreq_driver intel_pstate_driver = {
+ .flags = CPUFREQ_CONST_LOOPS,
+ .verify = intel_pstate_verify_policy,
+@@ -1423,6 +1582,7 @@
+ .resume = intel_pstate_hwp_set_policy,
+ .get = intel_pstate_get,
+ .init = intel_pstate_cpu_init,
++ .exit = intel_pstate_cpu_exit,
+ .stop_cpu = intel_pstate_stop_cpu,
+ .name = "intel_pstate",
+ };
+@@ -1466,8 +1626,7 @@
+
+ }
+
+-#if IS_ENABLED(CONFIG_ACPI)
+-#include <acpi/processor.h>
++#ifdef CONFIG_ACPI
+
+ static bool intel_pstate_no_acpi_pss(void)
+ {
+@@ -1623,7 +1782,7 @@
+ if (intel_pstate_platform_pwr_mgmt_exists())
+ return -ENODEV;
+
+- pr_info("Intel P-state driver initializing.\n");
++ pr_info("Intel P-state driver initializing\n");
+
+ all_cpu_data = vzalloc(sizeof(void *) * num_possible_cpus());
+ if (!all_cpu_data)
+@@ -1640,7 +1799,7 @@
+ intel_pstate_sysfs_expose_params();
+
+ if (hwp_active)
+- pr_info("intel_pstate: HWP enabled\n");
++ pr_info("HWP enabled\n");
+
+ return rc;
+ out:
+@@ -1666,13 +1825,19 @@
+ if (!strcmp(str, "disable"))
+ no_load = 1;
+ if (!strcmp(str, "no_hwp")) {
+- pr_info("intel_pstate: HWP disabled\n");
++ pr_info("HWP disabled\n");
+ no_hwp = 1;
+ }
+ if (!strcmp(str, "force"))
+ force_load = 1;
+ if (!strcmp(str, "hwp_only"))
+ hwp_only = 1;
++
++#ifdef CONFIG_ACPI
++ if (!strcmp(str, "support_acpi_ppc"))
++ acpi_ppc = true;
++#endif
++
+ return 0;
+ }
+ early_param("intel_pstate", intel_pstate_setup);
+--- linux-4.6/kernel/sched/cpufreq.c.orig 2016-06-24 15:32:20.064495916 -0400
++++ linux-4.6/kernel/sched/cpufreq.c 2016-06-24 15:33:47.717298423 -0400
+@@ -35,3 +35,52 @@
+ rcu_assign_pointer(per_cpu(cpufreq_update_util_data, cpu), data);
+ }
+ EXPORT_SYMBOL_GPL(cpufreq_set_update_util_data);
++
++/**
++ * cpufreq_add_update_util_hook - Populate the CPU's update_util_data pointer.
++ * @cpu: The CPU to set the pointer for.
++ * @data: New pointer value.
++ * @func: Callback function to set for the CPU.
++ *
++ * Set and publish the update_util_data pointer for the given CPU.
++ *
++ * The update_util_data pointer of @cpu is set to @data and the callback
++ * function pointer in the target struct update_util_data is set to @func.
++ * That function will be called by cpufreq_update_util() from RCU-sched
++ * read-side critical sections, so it must not sleep. @data will always be
++ * passed to it as the first argument which allows the function to get to the
++ * target update_util_data structure and its container.
++ *
++ * The update_util_data pointer of @cpu must be NULL when this function is
++ * called or it will WARN() and return with no effect.
++ */
++void cpufreq_add_update_util_hook(int cpu, struct update_util_data *data,
++ void (*func)(struct update_util_data *data, u64 time,
++ unsigned long util, unsigned long max))
++{
++ if (WARN_ON(!data || !func))
++ return;
++
++ if (WARN_ON(per_cpu(cpufreq_update_util_data, cpu)))
++ return;
++
++ data->func = func;
++ rcu_assign_pointer(per_cpu(cpufreq_update_util_data, cpu), data);
++}
++EXPORT_SYMBOL_GPL(cpufreq_add_update_util_hook);
++
++/**
++ * cpufreq_remove_update_util_hook - Clear the CPU's update_util_data pointer.
++ * @cpu: The CPU to clear the pointer for.
++ *
++ * Clear the update_util_data pointer for the given CPU.
++ *
++ * Callers must use RCU-sched callbacks to free any memory that might be
++ * accessed via the old update_util_data pointer or invoke synchronize_sched()
++ * right after this function to avoid use-after-free.
++ */
++void cpufreq_remove_update_util_hook(int cpu)
++{
++ rcu_assign_pointer(per_cpu(cpufreq_update_util_data, cpu), NULL);
++}
++EXPORT_SYMBOL_GPL(cpufreq_remove_update_util_hook);
+--- linux-4.6/include/linux/sched.h.dist 2016-06-24 19:19:15.391657951 -0400
++++ linux-4.6/include/linux/sched.h 2016-06-24 19:21:46.863939933 -0400
+@@ -3241,6 +3241,10 @@
+ };
+
+ void cpufreq_set_update_util_data(int cpu, struct update_util_data *data);
++void cpufreq_add_update_util_hook(int cpu, struct update_util_data *data,
++ void (*func)(struct update_util_data *data, u64 time,
++ unsigned long util, unsigned long max));
++void cpufreq_remove_update_util_hook(int cpu);
+ #endif /* CONFIG_CPU_FREQ */
+
+ #endif
+--- linux-4.6/drivers/cpufreq/intel_pstate.c.orig 2016-07-03 10:37:53.324091642 -0400
++++ linux-4.6/drivers/cpufreq/intel_pstate.c 2016-07-03 10:38:50.450757945 -0400
+@@ -372,26 +372,9 @@
+ return acpi_ppc;
+ }
+
+-/*
+- * The max target pstate ratio is a 8 bit value in both PLATFORM_INFO MSR and
+- * in TURBO_RATIO_LIMIT MSR, which pstate driver stores in max_pstate and
+- * max_turbo_pstate fields. The PERF_CTL MSR contains 16 bit value for P state
+- * ratio, out of it only high 8 bits are used. For example 0x1700 is setting
+- * target ratio 0x17. The _PSS control value stores in a format which can be
+- * directly written to PERF_CTL MSR. But in intel_pstate driver this shift
+- * occurs during write to PERF_CTL (E.g. for cores core_set_pstate()).
+- * This function converts the _PSS control value to intel pstate driver format
+- * for comparison and assignment.
+- */
+-static int convert_to_native_pstate_format(struct cpudata *cpu, int index)
+-{
+- return cpu->acpi_perf_data.states[index].control >> 8;
+-}
+-
+ static void intel_pstate_init_acpi_perf_limits(struct cpufreq_policy *policy)
+ {
+ struct cpudata *cpu;
+- int turbo_pss_ctl;
+ int ret;
+ int i;
+
+@@ -441,15 +424,14 @@
+ * max frequency, which will cause a reduced performance as
+ * this driver uses real max turbo frequency as the max
+ * frequency. So correct this frequency in _PSS table to
+- * correct max turbo frequency based on the turbo ratio.
++ * correct max turbo frequency based on the turbo state.
+ * Also need to convert to MHz as _PSS freq is in MHz.
+ */
+- turbo_pss_ctl = convert_to_native_pstate_format(cpu, 0);
+- if (turbo_pss_ctl > cpu->pstate.max_pstate)
++ if (!limits->turbo_disabled)
+ cpu->acpi_perf_data.states[0].core_frequency =
+ policy->cpuinfo.max_freq / 1000;
+ cpu->valid_pss_table = true;
+- pr_info("_PPC limits will be enforced\n");
++ pr_debug("_PPC limits will be enforced\n");
+
+ return;
+
+@@ -1418,6 +1400,9 @@
+ {
+ struct cpudata *cpu = all_cpu_data[cpu_num];
+
++ if (cpu->update_util_set)
++ return;
++
+ /* Prevent intel_pstate_update_util() from using stale data. */
+ cpu->sample.time = 0;
+ cpufreq_add_update_util_hook(cpu_num, &cpu->update_util,
+@@ -1458,15 +1443,15 @@
+ if (!policy->cpuinfo.max_freq)
+ return -ENODEV;
+
+- intel_pstate_clear_update_util_hook(policy->cpu);
++ pr_debug("set_policy cpuinfo.max %u policy->max %u\n",
++ policy->cpuinfo.max_freq, policy->max);
+
+ cpu = all_cpu_data[0];
+- if (cpu->pstate.max_pstate_physical > cpu->pstate.max_pstate) {
+- if (policy->max < policy->cpuinfo.max_freq &&
+- policy->max > cpu->pstate.max_pstate * cpu->pstate.scaling) {
+- pr_debug("policy->max > max non turbo frequency\n");
+- policy->max = policy->cpuinfo.max_freq;
+- }
++ if (cpu->pstate.max_pstate_physical > cpu->pstate.max_pstate &&
++ policy->max < policy->cpuinfo.max_freq &&
++ policy->max > cpu->pstate.max_pstate * cpu->pstate.scaling) {
++ pr_debug("policy->max > max non turbo frequency\n");
++ policy->max = policy->cpuinfo.max_freq;
+ }
+
+ if (policy->policy == CPUFREQ_POLICY_PERFORMANCE) {
+@@ -1496,13 +1481,13 @@
+ limits->max_sysfs_pct);
+ limits->max_perf_pct = max(limits->min_policy_pct,
+ limits->max_perf_pct);
+- limits->max_perf = round_up(limits->max_perf, FRAC_BITS);
+
+ /* Make sure min_perf_pct <= max_perf_pct */
+ limits->min_perf_pct = min(limits->max_perf_pct, limits->min_perf_pct);
+
+ limits->min_perf = div_fp(limits->min_perf_pct, 100);
+ limits->max_perf = div_fp(limits->max_perf_pct, 100);
++ limits->max_perf = round_up(limits->max_perf, FRAC_BITS);
+
+ out:
+ intel_pstate_set_update_util_hook(policy->cpu);
+@@ -1559,8 +1544,11 @@
+
+ /* cpuinfo and default policy values */
+ policy->cpuinfo.min_freq = cpu->pstate.min_pstate * cpu->pstate.scaling;
+- policy->cpuinfo.max_freq =
+- cpu->pstate.turbo_pstate * cpu->pstate.scaling;
++ update_turbo_state();
++ policy->cpuinfo.max_freq = limits->turbo_disabled ?
++ cpu->pstate.max_pstate : cpu->pstate.turbo_pstate;
++ policy->cpuinfo.max_freq *= cpu->pstate.scaling;
++
+ intel_pstate_init_acpi_perf_limits(policy);
+ policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
+ cpumask_set_cpu(policy->cpu, policy->cpus);