blob: 98fb8821382d8fc145c6bf9227b62236fdabedb1 [file] [log] [blame]
Dirk Brandewie93f08222013-02-06 09:02:13 -08001/*
Srinivas Pandruvadad1b68482013-04-09 22:38:18 +00002 * intel_pstate.c: Native P state management for Intel processors
Dirk Brandewie93f08222013-02-06 09:02:13 -08003 *
4 * (C) Copyright 2012 Intel Corporation
5 * Author: Dirk Brandewie <dirk.j.brandewie@intel.com>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; version 2
10 * of the License.
11 */
12
13#include <linux/kernel.h>
14#include <linux/kernel_stat.h>
15#include <linux/module.h>
16#include <linux/ktime.h>
17#include <linux/hrtimer.h>
18#include <linux/tick.h>
19#include <linux/slab.h>
20#include <linux/sched.h>
21#include <linux/list.h>
22#include <linux/cpu.h>
23#include <linux/cpufreq.h>
24#include <linux/sysfs.h>
25#include <linux/types.h>
26#include <linux/fs.h>
27#include <linux/debugfs.h>
Adrian Huangfbbcdc02013-10-31 23:24:05 +080028#include <linux/acpi.h>
Stephen Rothwelld6472302015-06-02 19:01:38 +100029#include <linux/vmalloc.h>
Dirk Brandewie93f08222013-02-06 09:02:13 -080030#include <trace/events/power.h>
31
32#include <asm/div64.h>
33#include <asm/msr.h>
34#include <asm/cpu_device_id.h>
Borislav Petkov64df1fd2015-04-03 15:19:53 +020035#include <asm/cpufeature.h>
Dirk Brandewie93f08222013-02-06 09:02:13 -080036
Philippe Longepe938d21a2015-11-09 17:40:46 -080037#define ATOM_RATIOS 0x66a
38#define ATOM_VIDS 0x66b
39#define ATOM_TURBO_RATIOS 0x66c
40#define ATOM_TURBO_VIDS 0x66d
Dirk Brandewie61d8d2a2014-02-12 10:01:07 -080041
Dirk Brandewief0fe3cd2014-05-29 09:32:23 -070042#define FRAC_BITS 8
Dirk Brandewie93f08222013-02-06 09:02:13 -080043#define int_tofp(X) ((int64_t)(X) << FRAC_BITS)
44#define fp_toint(X) ((X) >> FRAC_BITS)
Dirk Brandewief0fe3cd2014-05-29 09:32:23 -070045
Dirk Brandewie93f08222013-02-06 09:02:13 -080046static inline int32_t mul_fp(int32_t x, int32_t y)
47{
48 return ((int64_t)x * (int64_t)y) >> FRAC_BITS;
49}
50
Prarit Bhargava7180ddd2015-06-15 13:43:29 -040051static inline int32_t div_fp(s64 x, s64 y)
Dirk Brandewie93f08222013-02-06 09:02:13 -080052{
Prarit Bhargava7180ddd2015-06-15 13:43:29 -040053 return div64_s64((int64_t)x << FRAC_BITS, y);
Dirk Brandewie93f08222013-02-06 09:02:13 -080054}
55
Dirk Brandewied022a652014-10-13 08:37:44 -070056static inline int ceiling_fp(int32_t x)
57{
58 int mask, ret;
59
60 ret = fp_toint(x);
61 mask = (1 << FRAC_BITS) - 1;
62 if (x & mask)
63 ret += 1;
64 return ret;
65}
66
Dirk Brandewie93f08222013-02-06 09:02:13 -080067struct sample {
Brennan Shacklettd253d2a2013-10-21 09:20:32 -070068 int32_t core_pct_busy;
Dirk Brandewie93f08222013-02-06 09:02:13 -080069 u64 aperf;
70 u64 mperf;
Doug Smythies4055fad2015-04-11 21:10:26 -070071 u64 tsc;
Dirk Brandewie93f08222013-02-06 09:02:13 -080072 int freq;
Dirk Brandewiec4ee8412014-05-29 09:32:24 -070073 ktime_t time;
Dirk Brandewie93f08222013-02-06 09:02:13 -080074};
75
76struct pstate_data {
77 int current_pstate;
78 int min_pstate;
79 int max_pstate;
Srinivas Pandruvada3bcc6fa2015-10-14 16:12:00 -070080 int max_pstate_physical;
Dirk Brandewieb27580b2014-10-13 08:37:43 -070081 int scaling;
Dirk Brandewie93f08222013-02-06 09:02:13 -080082 int turbo_pstate;
83};
84
Dirk Brandewie007bea02013-12-18 10:32:39 -080085struct vid_data {
Dirk Brandewie21855ff2014-05-08 12:57:23 -070086 int min;
87 int max;
88 int turbo;
Dirk Brandewie007bea02013-12-18 10:32:39 -080089 int32_t ratio;
90};
91
Dirk Brandewie93f08222013-02-06 09:02:13 -080092struct _pid {
93 int setpoint;
94 int32_t integral;
95 int32_t p_gain;
96 int32_t i_gain;
97 int32_t d_gain;
98 int deadband;
Brennan Shacklettd253d2a2013-10-21 09:20:32 -070099 int32_t last_err;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800100};
101
102struct cpudata {
103 int cpu;
104
Dirk Brandewie93f08222013-02-06 09:02:13 -0800105 struct timer_list timer;
106
Dirk Brandewie93f08222013-02-06 09:02:13 -0800107 struct pstate_data pstate;
Dirk Brandewie007bea02013-12-18 10:32:39 -0800108 struct vid_data vid;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800109 struct _pid pid;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800110
Dirk Brandewiec4ee8412014-05-29 09:32:24 -0700111 ktime_t last_sample_time;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800112 u64 prev_aperf;
113 u64 prev_mperf;
Doug Smythies4055fad2015-04-11 21:10:26 -0700114 u64 prev_tsc;
Dirk Brandewied37e2b72014-02-12 10:01:04 -0800115 struct sample sample;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800116};
117
118static struct cpudata **all_cpu_data;
119struct pstate_adjust_policy {
120 int sample_rate_ms;
121 int deadband;
122 int setpoint;
123 int p_gain_pct;
124 int d_gain_pct;
125 int i_gain_pct;
126};
127
Dirk Brandewie016c8152013-10-21 09:20:34 -0700128struct pstate_funcs {
129 int (*get_max)(void);
Srinivas Pandruvada3bcc6fa2015-10-14 16:12:00 -0700130 int (*get_max_physical)(void);
Dirk Brandewie016c8152013-10-21 09:20:34 -0700131 int (*get_min)(void);
132 int (*get_turbo)(void);
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700133 int (*get_scaling)(void);
Dirk Brandewie007bea02013-12-18 10:32:39 -0800134 void (*set)(struct cpudata*, int pstate);
135 void (*get_vid)(struct cpudata *);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800136};
137
Dirk Brandewie016c8152013-10-21 09:20:34 -0700138struct cpu_defaults {
139 struct pstate_adjust_policy pid_policy;
140 struct pstate_funcs funcs;
141};
142
143static struct pstate_adjust_policy pid_params;
144static struct pstate_funcs pstate_funcs;
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800145static int hwp_active;
Dirk Brandewie016c8152013-10-21 09:20:34 -0700146
Dirk Brandewie93f08222013-02-06 09:02:13 -0800147struct perf_limits {
148 int no_turbo;
Dirk Brandewiedd5fbf72014-06-20 07:27:59 -0700149 int turbo_disabled;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800150 int max_perf_pct;
151 int min_perf_pct;
152 int32_t max_perf;
153 int32_t min_perf;
Dirk Brandewied8f469e2013-05-07 08:20:26 -0700154 int max_policy_pct;
155 int max_sysfs_pct;
Kristen Carlson Accardia0475992015-01-29 13:03:52 -0800156 int min_policy_pct;
157 int min_sysfs_pct;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800158};
159
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400160static struct perf_limits performance_limits = {
161 .no_turbo = 0,
162 .turbo_disabled = 0,
163 .max_perf_pct = 100,
164 .max_perf = int_tofp(1),
165 .min_perf_pct = 100,
166 .min_perf = int_tofp(1),
167 .max_policy_pct = 100,
168 .max_sysfs_pct = 100,
169 .min_policy_pct = 0,
170 .min_sysfs_pct = 0,
171};
172
173static struct perf_limits powersave_limits = {
Dirk Brandewie93f08222013-02-06 09:02:13 -0800174 .no_turbo = 0,
Gabriele Mazzotta4521e1a02014-10-13 08:37:41 -0700175 .turbo_disabled = 0,
Dirk Brandewie93f08222013-02-06 09:02:13 -0800176 .max_perf_pct = 100,
177 .max_perf = int_tofp(1),
178 .min_perf_pct = 0,
179 .min_perf = 0,
Dirk Brandewied8f469e2013-05-07 08:20:26 -0700180 .max_policy_pct = 100,
181 .max_sysfs_pct = 100,
Kristen Carlson Accardia0475992015-01-29 13:03:52 -0800182 .min_policy_pct = 0,
183 .min_sysfs_pct = 0,
Dirk Brandewie93f08222013-02-06 09:02:13 -0800184};
185
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400186#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
187static struct perf_limits *limits = &performance_limits;
188#else
189static struct perf_limits *limits = &powersave_limits;
190#endif
191
Dirk Brandewie93f08222013-02-06 09:02:13 -0800192static inline void pid_reset(struct _pid *pid, int setpoint, int busy,
Stratos Karafotisc4108332014-07-18 08:37:23 -0700193 int deadband, int integral) {
Dirk Brandewie93f08222013-02-06 09:02:13 -0800194 pid->setpoint = setpoint;
195 pid->deadband = deadband;
196 pid->integral = int_tofp(integral);
Dirk Brandewied98d0992014-02-12 10:01:05 -0800197 pid->last_err = int_tofp(setpoint) - int_tofp(busy);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800198}
199
200static inline void pid_p_gain_set(struct _pid *pid, int percent)
201{
202 pid->p_gain = div_fp(int_tofp(percent), int_tofp(100));
203}
204
205static inline void pid_i_gain_set(struct _pid *pid, int percent)
206{
207 pid->i_gain = div_fp(int_tofp(percent), int_tofp(100));
208}
209
210static inline void pid_d_gain_set(struct _pid *pid, int percent)
211{
Dirk Brandewie93f08222013-02-06 09:02:13 -0800212 pid->d_gain = div_fp(int_tofp(percent), int_tofp(100));
213}
214
Brennan Shacklettd253d2a2013-10-21 09:20:32 -0700215static signed int pid_calc(struct _pid *pid, int32_t busy)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800216{
Brennan Shacklettd253d2a2013-10-21 09:20:32 -0700217 signed int result;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800218 int32_t pterm, dterm, fp_error;
219 int32_t integral_limit;
220
Brennan Shacklettd253d2a2013-10-21 09:20:32 -0700221 fp_error = int_tofp(pid->setpoint) - busy;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800222
Brennan Shacklettd253d2a2013-10-21 09:20:32 -0700223 if (abs(fp_error) <= int_tofp(pid->deadband))
Dirk Brandewie93f08222013-02-06 09:02:13 -0800224 return 0;
225
226 pterm = mul_fp(pid->p_gain, fp_error);
227
228 pid->integral += fp_error;
229
Kristen Carlson Accardie0d4c8f2014-12-10 12:39:38 -0800230 /*
231 * We limit the integral here so that it will never
232 * get higher than 30. This prevents it from becoming
233 * too large an input over long periods of time and allows
234 * it to get factored out sooner.
235 *
236 * The value of 30 was chosen through experimentation.
237 */
Dirk Brandewie93f08222013-02-06 09:02:13 -0800238 integral_limit = int_tofp(30);
239 if (pid->integral > integral_limit)
240 pid->integral = integral_limit;
241 if (pid->integral < -integral_limit)
242 pid->integral = -integral_limit;
243
Brennan Shacklettd253d2a2013-10-21 09:20:32 -0700244 dterm = mul_fp(pid->d_gain, fp_error - pid->last_err);
245 pid->last_err = fp_error;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800246
247 result = pterm + mul_fp(pid->integral, pid->i_gain) + dterm;
Doug Smythies51d211e2014-06-17 13:36:10 -0700248 result = result + (1 << (FRAC_BITS-1));
Dirk Brandewie93f08222013-02-06 09:02:13 -0800249 return (signed int)fp_toint(result);
250}
251
252static inline void intel_pstate_busy_pid_reset(struct cpudata *cpu)
253{
Dirk Brandewie016c8152013-10-21 09:20:34 -0700254 pid_p_gain_set(&cpu->pid, pid_params.p_gain_pct);
255 pid_d_gain_set(&cpu->pid, pid_params.d_gain_pct);
256 pid_i_gain_set(&cpu->pid, pid_params.i_gain_pct);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800257
Stratos Karafotis2d8d1f12014-07-18 08:37:20 -0700258 pid_reset(&cpu->pid, pid_params.setpoint, 100, pid_params.deadband, 0);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800259}
260
Dirk Brandewie93f08222013-02-06 09:02:13 -0800261static inline void intel_pstate_reset_all_pid(void)
262{
263 unsigned int cpu;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700264
Dirk Brandewie93f08222013-02-06 09:02:13 -0800265 for_each_online_cpu(cpu) {
266 if (all_cpu_data[cpu])
267 intel_pstate_busy_pid_reset(all_cpu_data[cpu]);
268 }
269}
270
Gabriele Mazzotta4521e1a02014-10-13 08:37:41 -0700271static inline void update_turbo_state(void)
272{
273 u64 misc_en;
274 struct cpudata *cpu;
275
276 cpu = all_cpu_data[0];
277 rdmsrl(MSR_IA32_MISC_ENABLE, misc_en);
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400278 limits->turbo_disabled =
Gabriele Mazzotta4521e1a02014-10-13 08:37:41 -0700279 (misc_en & MSR_IA32_MISC_ENABLE_TURBO_DISABLE ||
280 cpu->pstate.max_pstate == cpu->pstate.turbo_pstate);
281}
282
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800283static void intel_pstate_hwp_set(void)
284{
Kristen Carlson Accardi74da56c2015-09-09 11:41:22 -0700285 int min, hw_min, max, hw_max, cpu, range, adj_range;
286 u64 value, cap;
287
288 rdmsrl(MSR_HWP_CAPABILITIES, cap);
289 hw_min = HWP_LOWEST_PERF(cap);
290 hw_max = HWP_HIGHEST_PERF(cap);
291 range = hw_max - hw_min;
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800292
293 get_online_cpus();
294
295 for_each_online_cpu(cpu) {
296 rdmsrl_on_cpu(cpu, MSR_HWP_REQUEST, &value);
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400297 adj_range = limits->min_perf_pct * range / 100;
Kristen Carlson Accardi74da56c2015-09-09 11:41:22 -0700298 min = hw_min + adj_range;
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800299 value &= ~HWP_MIN_PERF(~0L);
300 value |= HWP_MIN_PERF(min);
301
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400302 adj_range = limits->max_perf_pct * range / 100;
Kristen Carlson Accardi74da56c2015-09-09 11:41:22 -0700303 max = hw_min + adj_range;
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400304 if (limits->no_turbo) {
Kristen Carlson Accardi74da56c2015-09-09 11:41:22 -0700305 hw_max = HWP_GUARANTEED_PERF(cap);
306 if (hw_max < max)
307 max = hw_max;
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800308 }
309
310 value &= ~HWP_MAX_PERF(~0L);
311 value |= HWP_MAX_PERF(max);
312 wrmsrl_on_cpu(cpu, MSR_HWP_REQUEST, value);
313 }
314
315 put_online_cpus();
316}
317
Dirk Brandewie93f08222013-02-06 09:02:13 -0800318/************************** debugfs begin ************************/
319static int pid_param_set(void *data, u64 val)
320{
321 *(u32 *)data = val;
322 intel_pstate_reset_all_pid();
323 return 0;
324}
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700325
Dirk Brandewie93f08222013-02-06 09:02:13 -0800326static int pid_param_get(void *data, u64 *val)
327{
328 *val = *(u32 *)data;
329 return 0;
330}
Stratos Karafotis2d8d1f12014-07-18 08:37:20 -0700331DEFINE_SIMPLE_ATTRIBUTE(fops_pid_param, pid_param_get, pid_param_set, "%llu\n");
Dirk Brandewie93f08222013-02-06 09:02:13 -0800332
333struct pid_param {
334 char *name;
335 void *value;
336};
337
338static struct pid_param pid_files[] = {
Dirk Brandewie016c8152013-10-21 09:20:34 -0700339 {"sample_rate_ms", &pid_params.sample_rate_ms},
340 {"d_gain_pct", &pid_params.d_gain_pct},
341 {"i_gain_pct", &pid_params.i_gain_pct},
342 {"deadband", &pid_params.deadband},
343 {"setpoint", &pid_params.setpoint},
344 {"p_gain_pct", &pid_params.p_gain_pct},
Dirk Brandewie93f08222013-02-06 09:02:13 -0800345 {NULL, NULL}
346};
347
Stratos Karafotis317dd502014-07-18 08:37:17 -0700348static void __init intel_pstate_debug_expose_params(void)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800349{
Stratos Karafotis317dd502014-07-18 08:37:17 -0700350 struct dentry *debugfs_parent;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800351 int i = 0;
352
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800353 if (hwp_active)
354 return;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800355 debugfs_parent = debugfs_create_dir("pstate_snb", NULL);
356 if (IS_ERR_OR_NULL(debugfs_parent))
357 return;
358 while (pid_files[i].name) {
359 debugfs_create_file(pid_files[i].name, 0660,
Stratos Karafotisc4108332014-07-18 08:37:23 -0700360 debugfs_parent, pid_files[i].value,
361 &fops_pid_param);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800362 i++;
363 }
364}
365
366/************************** debugfs end ************************/
367
368/************************** sysfs begin ************************/
369#define show_one(file_name, object) \
370 static ssize_t show_##file_name \
371 (struct kobject *kobj, struct attribute *attr, char *buf) \
372 { \
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400373 return sprintf(buf, "%u\n", limits->object); \
Dirk Brandewie93f08222013-02-06 09:02:13 -0800374 }
375
Kristen Carlson Accardid01b1f42015-01-28 15:03:27 -0800376static ssize_t show_turbo_pct(struct kobject *kobj,
377 struct attribute *attr, char *buf)
378{
379 struct cpudata *cpu;
380 int total, no_turbo, turbo_pct;
381 uint32_t turbo_fp;
382
383 cpu = all_cpu_data[0];
384
385 total = cpu->pstate.turbo_pstate - cpu->pstate.min_pstate + 1;
386 no_turbo = cpu->pstate.max_pstate - cpu->pstate.min_pstate + 1;
387 turbo_fp = div_fp(int_tofp(no_turbo), int_tofp(total));
388 turbo_pct = 100 - fp_toint(mul_fp(turbo_fp, int_tofp(100)));
389 return sprintf(buf, "%u\n", turbo_pct);
390}
391
Kristen Carlson Accardi05224242015-01-28 15:03:28 -0800392static ssize_t show_num_pstates(struct kobject *kobj,
393 struct attribute *attr, char *buf)
394{
395 struct cpudata *cpu;
396 int total;
397
398 cpu = all_cpu_data[0];
399 total = cpu->pstate.turbo_pstate - cpu->pstate.min_pstate + 1;
400 return sprintf(buf, "%u\n", total);
401}
402
Gabriele Mazzotta4521e1a02014-10-13 08:37:41 -0700403static ssize_t show_no_turbo(struct kobject *kobj,
404 struct attribute *attr, char *buf)
405{
406 ssize_t ret;
407
408 update_turbo_state();
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400409 if (limits->turbo_disabled)
410 ret = sprintf(buf, "%u\n", limits->turbo_disabled);
Gabriele Mazzotta4521e1a02014-10-13 08:37:41 -0700411 else
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400412 ret = sprintf(buf, "%u\n", limits->no_turbo);
Gabriele Mazzotta4521e1a02014-10-13 08:37:41 -0700413
414 return ret;
415}
416
Dirk Brandewie93f08222013-02-06 09:02:13 -0800417static ssize_t store_no_turbo(struct kobject *a, struct attribute *b,
Stratos Karafotisc4108332014-07-18 08:37:23 -0700418 const char *buf, size_t count)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800419{
420 unsigned int input;
421 int ret;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700422
Dirk Brandewie93f08222013-02-06 09:02:13 -0800423 ret = sscanf(buf, "%u", &input);
424 if (ret != 1)
425 return -EINVAL;
Gabriele Mazzotta4521e1a02014-10-13 08:37:41 -0700426
427 update_turbo_state();
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400428 if (limits->turbo_disabled) {
Doug Smythiesf16255e2015-05-31 07:46:47 -0700429 pr_warn("intel_pstate: Turbo disabled by BIOS or unavailable on processor\n");
Gabriele Mazzotta4521e1a02014-10-13 08:37:41 -0700430 return -EPERM;
Dirk Brandewiedd5fbf72014-06-20 07:27:59 -0700431 }
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800432
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400433 limits->no_turbo = clamp_t(int, input, 0, 1);
Gabriele Mazzotta4521e1a02014-10-13 08:37:41 -0700434
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800435 if (hwp_active)
436 intel_pstate_hwp_set();
437
Dirk Brandewie93f08222013-02-06 09:02:13 -0800438 return count;
439}
440
441static ssize_t store_max_perf_pct(struct kobject *a, struct attribute *b,
Stratos Karafotisc4108332014-07-18 08:37:23 -0700442 const char *buf, size_t count)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800443{
444 unsigned int input;
445 int ret;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700446
Dirk Brandewie93f08222013-02-06 09:02:13 -0800447 ret = sscanf(buf, "%u", &input);
448 if (ret != 1)
449 return -EINVAL;
450
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400451 limits->max_sysfs_pct = clamp_t(int, input, 0 , 100);
452 limits->max_perf_pct = min(limits->max_policy_pct,
453 limits->max_sysfs_pct);
454 limits->max_perf_pct = max(limits->min_policy_pct,
455 limits->max_perf_pct);
456 limits->max_perf_pct = max(limits->min_perf_pct,
457 limits->max_perf_pct);
458 limits->max_perf = div_fp(int_tofp(limits->max_perf_pct),
459 int_tofp(100));
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700460
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800461 if (hwp_active)
462 intel_pstate_hwp_set();
Dirk Brandewie93f08222013-02-06 09:02:13 -0800463 return count;
464}
465
466static ssize_t store_min_perf_pct(struct kobject *a, struct attribute *b,
Stratos Karafotisc4108332014-07-18 08:37:23 -0700467 const char *buf, size_t count)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800468{
469 unsigned int input;
470 int ret;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700471
Dirk Brandewie93f08222013-02-06 09:02:13 -0800472 ret = sscanf(buf, "%u", &input);
473 if (ret != 1)
474 return -EINVAL;
Kristen Carlson Accardia0475992015-01-29 13:03:52 -0800475
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400476 limits->min_sysfs_pct = clamp_t(int, input, 0 , 100);
477 limits->min_perf_pct = max(limits->min_policy_pct,
478 limits->min_sysfs_pct);
479 limits->min_perf_pct = min(limits->max_policy_pct,
480 limits->min_perf_pct);
481 limits->min_perf_pct = min(limits->max_perf_pct,
482 limits->min_perf_pct);
483 limits->min_perf = div_fp(int_tofp(limits->min_perf_pct),
484 int_tofp(100));
Dirk Brandewie93f08222013-02-06 09:02:13 -0800485
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800486 if (hwp_active)
487 intel_pstate_hwp_set();
Dirk Brandewie93f08222013-02-06 09:02:13 -0800488 return count;
489}
490
Dirk Brandewie93f08222013-02-06 09:02:13 -0800491show_one(max_perf_pct, max_perf_pct);
492show_one(min_perf_pct, min_perf_pct);
493
494define_one_global_rw(no_turbo);
495define_one_global_rw(max_perf_pct);
496define_one_global_rw(min_perf_pct);
Kristen Carlson Accardid01b1f42015-01-28 15:03:27 -0800497define_one_global_ro(turbo_pct);
Kristen Carlson Accardi05224242015-01-28 15:03:28 -0800498define_one_global_ro(num_pstates);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800499
500static struct attribute *intel_pstate_attributes[] = {
501 &no_turbo.attr,
502 &max_perf_pct.attr,
503 &min_perf_pct.attr,
Kristen Carlson Accardid01b1f42015-01-28 15:03:27 -0800504 &turbo_pct.attr,
Kristen Carlson Accardi05224242015-01-28 15:03:28 -0800505 &num_pstates.attr,
Dirk Brandewie93f08222013-02-06 09:02:13 -0800506 NULL
507};
508
509static struct attribute_group intel_pstate_attr_group = {
510 .attrs = intel_pstate_attributes,
511};
Dirk Brandewie93f08222013-02-06 09:02:13 -0800512
Stratos Karafotis317dd502014-07-18 08:37:17 -0700513static void __init intel_pstate_sysfs_expose_params(void)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800514{
Stratos Karafotis317dd502014-07-18 08:37:17 -0700515 struct kobject *intel_pstate_kobject;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800516 int rc;
517
518 intel_pstate_kobject = kobject_create_and_add("intel_pstate",
519 &cpu_subsys.dev_root->kobj);
520 BUG_ON(!intel_pstate_kobject);
Stratos Karafotis2d8d1f12014-07-18 08:37:20 -0700521 rc = sysfs_create_group(intel_pstate_kobject, &intel_pstate_attr_group);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800522 BUG_ON(rc);
523}
Dirk Brandewie93f08222013-02-06 09:02:13 -0800524/************************** sysfs end ************************/
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800525
Kristen Carlson Accardiba88d432015-07-14 09:46:23 -0700526static void intel_pstate_hwp_enable(struct cpudata *cpudata)
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800527{
Kristen Carlson Accardiba88d432015-07-14 09:46:23 -0700528 wrmsrl_on_cpu(cpudata->cpu, MSR_PM_ENABLE, 0x1);
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800529}
530
Philippe Longepe938d21a2015-11-09 17:40:46 -0800531static int atom_get_min_pstate(void)
Dirk Brandewie19e77c22013-10-21 09:20:35 -0700532{
533 u64 value;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700534
Philippe Longepe938d21a2015-11-09 17:40:46 -0800535 rdmsrl(ATOM_RATIOS, value);
Dirk Brandewiec16ed062014-06-20 07:27:58 -0700536 return (value >> 8) & 0x7F;
Dirk Brandewie19e77c22013-10-21 09:20:35 -0700537}
Dirk Brandewie93f08222013-02-06 09:02:13 -0800538
Philippe Longepe938d21a2015-11-09 17:40:46 -0800539static int atom_get_max_pstate(void)
Dirk Brandewie19e77c22013-10-21 09:20:35 -0700540{
541 u64 value;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700542
Philippe Longepe938d21a2015-11-09 17:40:46 -0800543 rdmsrl(ATOM_RATIOS, value);
Dirk Brandewiec16ed062014-06-20 07:27:58 -0700544 return (value >> 16) & 0x7F;
Dirk Brandewie19e77c22013-10-21 09:20:35 -0700545}
546
Philippe Longepe938d21a2015-11-09 17:40:46 -0800547static int atom_get_turbo_pstate(void)
Dirk Brandewie61d8d2a2014-02-12 10:01:07 -0800548{
549 u64 value;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700550
Philippe Longepe938d21a2015-11-09 17:40:46 -0800551 rdmsrl(ATOM_TURBO_RATIOS, value);
Dirk Brandewiec16ed062014-06-20 07:27:58 -0700552 return value & 0x7F;
Dirk Brandewie61d8d2a2014-02-12 10:01:07 -0800553}
554
Philippe Longepe938d21a2015-11-09 17:40:46 -0800555static void atom_set_pstate(struct cpudata *cpudata, int pstate)
Dirk Brandewie007bea02013-12-18 10:32:39 -0800556{
557 u64 val;
558 int32_t vid_fp;
559 u32 vid;
560
Chen Yu144c8e12015-07-29 23:53:10 +0800561 val = (u64)pstate << 8;
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400562 if (limits->no_turbo && !limits->turbo_disabled)
Dirk Brandewie007bea02013-12-18 10:32:39 -0800563 val |= (u64)1 << 32;
564
565 vid_fp = cpudata->vid.min + mul_fp(
566 int_tofp(pstate - cpudata->pstate.min_pstate),
567 cpudata->vid.ratio);
568
569 vid_fp = clamp_t(int32_t, vid_fp, cpudata->vid.min, cpudata->vid.max);
Dirk Brandewied022a652014-10-13 08:37:44 -0700570 vid = ceiling_fp(vid_fp);
Dirk Brandewie007bea02013-12-18 10:32:39 -0800571
Dirk Brandewie21855ff2014-05-08 12:57:23 -0700572 if (pstate > cpudata->pstate.max_pstate)
573 vid = cpudata->vid.turbo;
574
Dirk Brandewie007bea02013-12-18 10:32:39 -0800575 val |= vid;
576
Joe Konno0dd23f92015-05-12 07:59:42 -0700577 wrmsrl_on_cpu(cpudata->cpu, MSR_IA32_PERF_CTL, val);
Dirk Brandewie007bea02013-12-18 10:32:39 -0800578}
579
Philippe Longepe1421df62015-11-09 17:40:47 -0800580static int silvermont_get_scaling(void)
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700581{
582 u64 value;
583 int i;
Philippe Longepe1421df62015-11-09 17:40:47 -0800584 /* Defined in Table 35-6 from SDM (Sept 2015) */
585 static int silvermont_freq_table[] = {
586 83300, 100000, 133300, 116700, 80000};
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700587
588 rdmsrl(MSR_FSB_FREQ, value);
Philippe Longepe1421df62015-11-09 17:40:47 -0800589 i = value & 0x7;
590 WARN_ON(i > 4);
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700591
Philippe Longepe1421df62015-11-09 17:40:47 -0800592 return silvermont_freq_table[i];
593}
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700594
Philippe Longepe1421df62015-11-09 17:40:47 -0800595static int airmont_get_scaling(void)
596{
597 u64 value;
598 int i;
599 /* Defined in Table 35-10 from SDM (Sept 2015) */
600 static int airmont_freq_table[] = {
601 83300, 100000, 133300, 116700, 80000,
602 93300, 90000, 88900, 87500};
603
604 rdmsrl(MSR_FSB_FREQ, value);
605 i = value & 0xF;
606 WARN_ON(i > 8);
607
608 return airmont_freq_table[i];
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700609}
610
Philippe Longepe938d21a2015-11-09 17:40:46 -0800611static void atom_get_vid(struct cpudata *cpudata)
Dirk Brandewie007bea02013-12-18 10:32:39 -0800612{
613 u64 value;
614
Philippe Longepe938d21a2015-11-09 17:40:46 -0800615 rdmsrl(ATOM_VIDS, value);
Dirk Brandewiec16ed062014-06-20 07:27:58 -0700616 cpudata->vid.min = int_tofp((value >> 8) & 0x7f);
617 cpudata->vid.max = int_tofp((value >> 16) & 0x7f);
Dirk Brandewie007bea02013-12-18 10:32:39 -0800618 cpudata->vid.ratio = div_fp(
619 cpudata->vid.max - cpudata->vid.min,
620 int_tofp(cpudata->pstate.max_pstate -
621 cpudata->pstate.min_pstate));
Dirk Brandewie21855ff2014-05-08 12:57:23 -0700622
Philippe Longepe938d21a2015-11-09 17:40:46 -0800623 rdmsrl(ATOM_TURBO_VIDS, value);
Dirk Brandewie21855ff2014-05-08 12:57:23 -0700624 cpudata->vid.turbo = value & 0x7f;
Dirk Brandewie007bea02013-12-18 10:32:39 -0800625}
626
Dirk Brandewie016c8152013-10-21 09:20:34 -0700627static int core_get_min_pstate(void)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800628{
629 u64 value;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700630
Konrad Rzeszutek Wilk05e99c8cf2013-03-20 14:21:10 +0000631 rdmsrl(MSR_PLATFORM_INFO, value);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800632 return (value >> 40) & 0xFF;
633}
634
Srinivas Pandruvada3bcc6fa2015-10-14 16:12:00 -0700635static int core_get_max_pstate_physical(void)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800636{
637 u64 value;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700638
Konrad Rzeszutek Wilk05e99c8cf2013-03-20 14:21:10 +0000639 rdmsrl(MSR_PLATFORM_INFO, value);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800640 return (value >> 8) & 0xFF;
641}
642
Dirk Brandewie93f08222013-02-06 09:02:13 -0800643static int core_get_max_pstate(void)
644{
Srinivas Pandruvada6a35fc22015-10-14 16:11:59 -0700645 u64 tar;
646 u64 plat_info;
647 int max_pstate;
648 int err;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800649
Srinivas Pandruvada6a35fc22015-10-14 16:11:59 -0700650 rdmsrl(MSR_PLATFORM_INFO, plat_info);
651 max_pstate = (plat_info >> 8) & 0xFF;
652
653 err = rdmsrl_safe(MSR_TURBO_ACTIVATION_RATIO, &tar);
654 if (!err) {
655 /* Do some sanity checking for safety */
656 if (plat_info & 0x600000000) {
657 u64 tdp_ctrl;
658 u64 tdp_ratio;
659 int tdp_msr;
660
661 err = rdmsrl_safe(MSR_CONFIG_TDP_CONTROL, &tdp_ctrl);
662 if (err)
663 goto skip_tar;
664
665 tdp_msr = MSR_CONFIG_TDP_NOMINAL + tdp_ctrl;
666 err = rdmsrl_safe(tdp_msr, &tdp_ratio);
667 if (err)
668 goto skip_tar;
669
670 if (tdp_ratio - 1 == tar) {
671 max_pstate = tar;
672 pr_debug("max_pstate=TAC %x\n", max_pstate);
673 } else {
674 goto skip_tar;
675 }
676 }
677 }
678
679skip_tar:
680 return max_pstate;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800681}
682
Dirk Brandewie016c8152013-10-21 09:20:34 -0700683static int core_get_turbo_pstate(void)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800684{
685 u64 value;
686 int nont, ret;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700687
Konrad Rzeszutek Wilk05e99c8cf2013-03-20 14:21:10 +0000688 rdmsrl(MSR_NHM_TURBO_RATIO_LIMIT, value);
Dirk Brandewie016c8152013-10-21 09:20:34 -0700689 nont = core_get_max_pstate();
Stratos Karafotis285cb992014-07-18 08:37:21 -0700690 ret = (value) & 255;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800691 if (ret <= nont)
692 ret = nont;
693 return ret;
694}
695
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700696static inline int core_get_scaling(void)
697{
698 return 100000;
699}
700
Dirk Brandewie007bea02013-12-18 10:32:39 -0800701static void core_set_pstate(struct cpudata *cpudata, int pstate)
Dirk Brandewie016c8152013-10-21 09:20:34 -0700702{
703 u64 val;
704
Chen Yu144c8e12015-07-29 23:53:10 +0800705 val = (u64)pstate << 8;
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400706 if (limits->no_turbo && !limits->turbo_disabled)
Dirk Brandewie016c8152013-10-21 09:20:34 -0700707 val |= (u64)1 << 32;
708
Dirk Brandewiebb180082014-03-19 08:45:54 -0700709 wrmsrl_on_cpu(cpudata->cpu, MSR_IA32_PERF_CTL, val);
Dirk Brandewie016c8152013-10-21 09:20:34 -0700710}
711
Dasaratharaman Chandramoulib34ef932015-04-10 10:22:18 -0700712static int knl_get_turbo_pstate(void)
713{
714 u64 value;
715 int nont, ret;
716
717 rdmsrl(MSR_NHM_TURBO_RATIO_LIMIT, value);
718 nont = core_get_max_pstate();
719 ret = (((value) >> 8) & 0xFF);
720 if (ret <= nont)
721 ret = nont;
722 return ret;
723}
724
Dirk Brandewie016c8152013-10-21 09:20:34 -0700725static struct cpu_defaults core_params = {
726 .pid_policy = {
727 .sample_rate_ms = 10,
728 .deadband = 0,
729 .setpoint = 97,
730 .p_gain_pct = 20,
731 .d_gain_pct = 0,
732 .i_gain_pct = 0,
733 },
734 .funcs = {
735 .get_max = core_get_max_pstate,
Srinivas Pandruvada3bcc6fa2015-10-14 16:12:00 -0700736 .get_max_physical = core_get_max_pstate_physical,
Dirk Brandewie016c8152013-10-21 09:20:34 -0700737 .get_min = core_get_min_pstate,
738 .get_turbo = core_get_turbo_pstate,
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700739 .get_scaling = core_get_scaling,
Dirk Brandewie016c8152013-10-21 09:20:34 -0700740 .set = core_set_pstate,
741 },
742};
743
Philippe Longepe1421df62015-11-09 17:40:47 -0800744static struct cpu_defaults silvermont_params = {
Dirk Brandewie19e77c22013-10-21 09:20:35 -0700745 .pid_policy = {
746 .sample_rate_ms = 10,
747 .deadband = 0,
Kristen Carlson Accardi6a82ba62015-04-10 11:06:43 -0700748 .setpoint = 60,
Dirk Brandewie19e77c22013-10-21 09:20:35 -0700749 .p_gain_pct = 14,
750 .d_gain_pct = 0,
751 .i_gain_pct = 4,
752 },
753 .funcs = {
Philippe Longepe938d21a2015-11-09 17:40:46 -0800754 .get_max = atom_get_max_pstate,
755 .get_max_physical = atom_get_max_pstate,
756 .get_min = atom_get_min_pstate,
757 .get_turbo = atom_get_turbo_pstate,
758 .set = atom_set_pstate,
Philippe Longepe1421df62015-11-09 17:40:47 -0800759 .get_scaling = silvermont_get_scaling,
760 .get_vid = atom_get_vid,
761 },
762};
763
764static struct cpu_defaults airmont_params = {
765 .pid_policy = {
766 .sample_rate_ms = 10,
767 .deadband = 0,
768 .setpoint = 60,
769 .p_gain_pct = 14,
770 .d_gain_pct = 0,
771 .i_gain_pct = 4,
772 },
773 .funcs = {
774 .get_max = atom_get_max_pstate,
775 .get_max_physical = atom_get_max_pstate,
776 .get_min = atom_get_min_pstate,
777 .get_turbo = atom_get_turbo_pstate,
778 .set = atom_set_pstate,
779 .get_scaling = airmont_get_scaling,
Philippe Longepe938d21a2015-11-09 17:40:46 -0800780 .get_vid = atom_get_vid,
Dirk Brandewie19e77c22013-10-21 09:20:35 -0700781 },
782};
783
Dasaratharaman Chandramoulib34ef932015-04-10 10:22:18 -0700784static struct cpu_defaults knl_params = {
785 .pid_policy = {
786 .sample_rate_ms = 10,
787 .deadband = 0,
788 .setpoint = 97,
789 .p_gain_pct = 20,
790 .d_gain_pct = 0,
791 .i_gain_pct = 0,
792 },
793 .funcs = {
794 .get_max = core_get_max_pstate,
Srinivas Pandruvada3bcc6fa2015-10-14 16:12:00 -0700795 .get_max_physical = core_get_max_pstate_physical,
Dasaratharaman Chandramoulib34ef932015-04-10 10:22:18 -0700796 .get_min = core_get_min_pstate,
797 .get_turbo = knl_get_turbo_pstate,
Lukasz Anaczkowski69cefc22015-07-21 10:41:13 +0200798 .get_scaling = core_get_scaling,
Dasaratharaman Chandramoulib34ef932015-04-10 10:22:18 -0700799 .set = core_set_pstate,
800 },
801};
802
Dirk Brandewie93f08222013-02-06 09:02:13 -0800803static void intel_pstate_get_min_max(struct cpudata *cpu, int *min, int *max)
804{
805 int max_perf = cpu->pstate.turbo_pstate;
Dirk Brandewie7244cb62013-10-21 09:20:33 -0700806 int max_perf_adj;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800807 int min_perf;
Stratos Karafotis845c1cb2014-07-18 08:37:19 -0700808
Prarit Bhargava51443fb2015-10-15 07:34:15 -0400809 if (limits->no_turbo || limits->turbo_disabled)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800810 max_perf = cpu->pstate.max_pstate;
811
Kristen Carlson Accardie0d4c8f2014-12-10 12:39:38 -0800812 /*
813 * performance can be limited by user through sysfs, by cpufreq
814 * policy, or by cpu specific default values determined through
815 * experimentation.
816 */
Rafael J. Wysocki799281a2015-11-18 23:29:56 +0100817 max_perf_adj = fp_toint(mul_fp(int_tofp(max_perf), limits->max_perf));
818 *max = clamp_t(int, max_perf_adj,
819 cpu->pstate.min_pstate, cpu->pstate.turbo_pstate);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800820
Rafael J. Wysocki799281a2015-11-18 23:29:56 +0100821 min_perf = fp_toint(mul_fp(int_tofp(max_perf), limits->min_perf));
822 *min = clamp_t(int, min_perf, cpu->pstate.min_pstate, max_perf);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800823}
824
Doug Smythies6c1e4592015-06-01 21:12:34 -0700825static void intel_pstate_set_pstate(struct cpudata *cpu, int pstate, bool force)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800826{
827 int max_perf, min_perf;
828
Doug Smythies6c1e4592015-06-01 21:12:34 -0700829 if (force) {
830 update_turbo_state();
Gabriele Mazzotta4521e1a02014-10-13 08:37:41 -0700831
Doug Smythies6c1e4592015-06-01 21:12:34 -0700832 intel_pstate_get_min_max(cpu, &min_perf, &max_perf);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800833
Doug Smythies6c1e4592015-06-01 21:12:34 -0700834 pstate = clamp_t(int, pstate, min_perf, max_perf);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800835
Doug Smythies6c1e4592015-06-01 21:12:34 -0700836 if (pstate == cpu->pstate.current_pstate)
837 return;
838 }
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700839 trace_cpu_frequency(pstate * cpu->pstate.scaling, cpu->cpu);
Dirk Brandewie35363e92013-05-07 08:20:30 -0700840
Dirk Brandewie93f08222013-02-06 09:02:13 -0800841 cpu->pstate.current_pstate = pstate;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800842
Dirk Brandewie007bea02013-12-18 10:32:39 -0800843 pstate_funcs.set(cpu, pstate);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800844}
845
Dirk Brandewie93f08222013-02-06 09:02:13 -0800846static void intel_pstate_get_cpu_pstates(struct cpudata *cpu)
847{
Dirk Brandewie016c8152013-10-21 09:20:34 -0700848 cpu->pstate.min_pstate = pstate_funcs.get_min();
849 cpu->pstate.max_pstate = pstate_funcs.get_max();
Srinivas Pandruvada3bcc6fa2015-10-14 16:12:00 -0700850 cpu->pstate.max_pstate_physical = pstate_funcs.get_max_physical();
Dirk Brandewie016c8152013-10-21 09:20:34 -0700851 cpu->pstate.turbo_pstate = pstate_funcs.get_turbo();
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700852 cpu->pstate.scaling = pstate_funcs.get_scaling();
Dirk Brandewie93f08222013-02-06 09:02:13 -0800853
Dirk Brandewie007bea02013-12-18 10:32:39 -0800854 if (pstate_funcs.get_vid)
855 pstate_funcs.get_vid(cpu);
Doug Smythies6c1e4592015-06-01 21:12:34 -0700856 intel_pstate_set_pstate(cpu, cpu->pstate.min_pstate, false);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800857}
858
Stratos Karafotis6b17ddb2014-04-29 20:53:49 +0300859static inline void intel_pstate_calc_busy(struct cpudata *cpu)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800860{
Stratos Karafotis6b17ddb2014-04-29 20:53:49 +0300861 struct sample *sample = &cpu->sample;
Doug Smythiesbf810222014-05-30 10:10:57 -0700862 int64_t core_pct;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800863
Doug Smythiesbf810222014-05-30 10:10:57 -0700864 core_pct = int_tofp(sample->aperf) * int_tofp(100);
Stratos Karafotis78e27082014-07-18 08:37:27 -0700865 core_pct = div64_u64(core_pct, int_tofp(sample->mperf));
Dirk Brandewiefcb6a152014-02-03 08:55:31 -0800866
Dirk Brandewiefcb6a152014-02-03 08:55:31 -0800867 sample->freq = fp_toint(
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700868 mul_fp(int_tofp(
Srinivas Pandruvada3bcc6fa2015-10-14 16:12:00 -0700869 cpu->pstate.max_pstate_physical *
870 cpu->pstate.scaling / 100),
Dirk Brandewieb27580b2014-10-13 08:37:43 -0700871 core_pct));
Dirk Brandewiefcb6a152014-02-03 08:55:31 -0800872
Doug Smythiesbf810222014-05-30 10:10:57 -0700873 sample->core_pct_busy = (int32_t)core_pct;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800874}
875
876static inline void intel_pstate_sample(struct cpudata *cpu)
877{
Dirk Brandewie93f08222013-02-06 09:02:13 -0800878 u64 aperf, mperf;
Stratos Karafotis4ab60c32014-07-18 08:37:24 -0700879 unsigned long flags;
Doug Smythies4055fad2015-04-11 21:10:26 -0700880 u64 tsc;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800881
Stratos Karafotis4ab60c32014-07-18 08:37:24 -0700882 local_irq_save(flags);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800883 rdmsrl(MSR_IA32_APERF, aperf);
884 rdmsrl(MSR_IA32_MPERF, mperf);
Srinivas Pandruvada8e601a92015-10-15 12:34:21 -0700885 if (cpu->prev_mperf == mperf) {
886 local_irq_restore(flags);
887 return;
888 }
889
Andy Lutomirski4ea16362015-06-25 18:44:07 +0200890 tsc = rdtsc();
Stratos Karafotis4ab60c32014-07-18 08:37:24 -0700891 local_irq_restore(flags);
Dirk Brandewieb69880f2014-01-16 10:32:25 -0800892
Dirk Brandewiec4ee8412014-05-29 09:32:24 -0700893 cpu->last_sample_time = cpu->sample.time;
894 cpu->sample.time = ktime_get();
Dirk Brandewied37e2b72014-02-12 10:01:04 -0800895 cpu->sample.aperf = aperf;
896 cpu->sample.mperf = mperf;
Doug Smythies4055fad2015-04-11 21:10:26 -0700897 cpu->sample.tsc = tsc;
Dirk Brandewied37e2b72014-02-12 10:01:04 -0800898 cpu->sample.aperf -= cpu->prev_aperf;
899 cpu->sample.mperf -= cpu->prev_mperf;
Doug Smythies4055fad2015-04-11 21:10:26 -0700900 cpu->sample.tsc -= cpu->prev_tsc;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800901
Stratos Karafotis6b17ddb2014-04-29 20:53:49 +0300902 intel_pstate_calc_busy(cpu);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800903
Dirk Brandewie93f08222013-02-06 09:02:13 -0800904 cpu->prev_aperf = aperf;
905 cpu->prev_mperf = mperf;
Doug Smythies4055fad2015-04-11 21:10:26 -0700906 cpu->prev_tsc = tsc;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800907}
908
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800909static inline void intel_hwp_set_sample_time(struct cpudata *cpu)
910{
911 int delay;
912
913 delay = msecs_to_jiffies(50);
914 mod_timer_pinned(&cpu->timer, jiffies + delay);
915}
916
Dirk Brandewie93f08222013-02-06 09:02:13 -0800917static inline void intel_pstate_set_sample_time(struct cpudata *cpu)
918{
Stratos Karafotisabf013b2014-07-18 08:37:22 -0700919 int delay;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800920
Stratos Karafotisabf013b2014-07-18 08:37:22 -0700921 delay = msecs_to_jiffies(pid_params.sample_rate_ms);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800922 mod_timer_pinned(&cpu->timer, jiffies + delay);
923}
924
Brennan Shacklettd253d2a2013-10-21 09:20:32 -0700925static inline int32_t intel_pstate_get_scaled_busy(struct cpudata *cpu)
Dirk Brandewie93f08222013-02-06 09:02:13 -0800926{
Dirk Brandewiec4ee8412014-05-29 09:32:24 -0700927 int32_t core_busy, max_pstate, current_pstate, sample_ratio;
Prarit Bhargava7180ddd2015-06-15 13:43:29 -0400928 s64 duration_us;
Dirk Brandewiec4ee8412014-05-29 09:32:24 -0700929 u32 sample_time;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800930
Kristen Carlson Accardie0d4c8f2014-12-10 12:39:38 -0800931 /*
932 * core_busy is the ratio of actual performance to max
933 * max_pstate is the max non turbo pstate available
934 * current_pstate was the pstate that was requested during
935 * the last sample period.
936 *
937 * We normalize core_busy, which was our actual percent
938 * performance to what we requested during the last sample
939 * period. The result will be a percentage of busy at a
940 * specified pstate.
941 */
Dirk Brandewied37e2b72014-02-12 10:01:04 -0800942 core_busy = cpu->sample.core_pct_busy;
Srinivas Pandruvada3bcc6fa2015-10-14 16:12:00 -0700943 max_pstate = int_tofp(cpu->pstate.max_pstate_physical);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800944 current_pstate = int_tofp(cpu->pstate.current_pstate);
Dirk Brandewiee66c1762014-02-25 10:35:37 -0800945 core_busy = mul_fp(core_busy, div_fp(max_pstate, current_pstate));
Dirk Brandewiec4ee8412014-05-29 09:32:24 -0700946
Kristen Carlson Accardie0d4c8f2014-12-10 12:39:38 -0800947 /*
948 * Since we have a deferred timer, it will not fire unless
949 * we are in C0. So, determine if the actual elapsed time
950 * is significantly greater (3x) than our sample interval. If it
951 * is, then we were idle for a long enough period of time
952 * to adjust our busyness.
953 */
Stratos Karafotis285cb992014-07-18 08:37:21 -0700954 sample_time = pid_params.sample_rate_ms * USEC_PER_MSEC;
Prarit Bhargava7180ddd2015-06-15 13:43:29 -0400955 duration_us = ktime_us_delta(cpu->sample.time,
956 cpu->last_sample_time);
Dirk Brandewiec4ee8412014-05-29 09:32:24 -0700957 if (duration_us > sample_time * 3) {
958 sample_ratio = div_fp(int_tofp(sample_time),
Stratos Karafotisc4108332014-07-18 08:37:23 -0700959 int_tofp(duration_us));
Dirk Brandewiec4ee8412014-05-29 09:32:24 -0700960 core_busy = mul_fp(core_busy, sample_ratio);
961 }
962
Dirk Brandewief0fe3cd2014-05-29 09:32:23 -0700963 return core_busy;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800964}
965
966static inline void intel_pstate_adjust_busy_pstate(struct cpudata *cpu)
967{
Brennan Shacklettd253d2a2013-10-21 09:20:32 -0700968 int32_t busy_scaled;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800969 struct _pid *pid;
Stratos Karafotis4b707c82014-07-18 08:37:26 -0700970 signed int ctl;
Doug Smythies4055fad2015-04-11 21:10:26 -0700971 int from;
972 struct sample *sample;
973
974 from = cpu->pstate.current_pstate;
Dirk Brandewie93f08222013-02-06 09:02:13 -0800975
976 pid = &cpu->pid;
977 busy_scaled = intel_pstate_get_scaled_busy(cpu);
978
979 ctl = pid_calc(pid, busy_scaled);
980
Stratos Karafotis4b707c82014-07-18 08:37:26 -0700981 /* Negative values of ctl increase the pstate and vice versa */
Doug Smythies6c1e4592015-06-01 21:12:34 -0700982 intel_pstate_set_pstate(cpu, cpu->pstate.current_pstate - ctl, true);
Doug Smythies4055fad2015-04-11 21:10:26 -0700983
984 sample = &cpu->sample;
985 trace_pstate_sample(fp_toint(sample->core_pct_busy),
986 fp_toint(busy_scaled),
987 from,
988 cpu->pstate.current_pstate,
989 sample->mperf,
990 sample->aperf,
991 sample->tsc,
992 sample->freq);
Dirk Brandewie93f08222013-02-06 09:02:13 -0800993}
994
Dirk Brandewie2f86dc42014-11-06 09:40:47 -0800995static void intel_hwp_timer_func(unsigned long __data)
996{
997 struct cpudata *cpu = (struct cpudata *) __data;
998
999 intel_pstate_sample(cpu);
1000 intel_hwp_set_sample_time(cpu);
1001}
1002
Dirk Brandewie93f08222013-02-06 09:02:13 -08001003static void intel_pstate_timer_func(unsigned long __data)
1004{
1005 struct cpudata *cpu = (struct cpudata *) __data;
1006
1007 intel_pstate_sample(cpu);
Dirk Brandewieb69880f2014-01-16 10:32:25 -08001008
Dirk Brandewieca182ae2013-05-07 08:20:27 -07001009 intel_pstate_adjust_busy_pstate(cpu);
Dirk Brandewieb69880f2014-01-16 10:32:25 -08001010
Dirk Brandewie93f08222013-02-06 09:02:13 -08001011 intel_pstate_set_sample_time(cpu);
1012}
1013
1014#define ICPU(model, policy) \
Dirk Brandewie6cbd7ee2014-01-06 10:59:16 -08001015 { X86_VENDOR_INTEL, 6, model, X86_FEATURE_APERFMPERF,\
1016 (unsigned long)&policy }
Dirk Brandewie93f08222013-02-06 09:02:13 -08001017
1018static const struct x86_cpu_id intel_pstate_cpu_ids[] = {
Dirk Brandewie016c8152013-10-21 09:20:34 -07001019 ICPU(0x2a, core_params),
1020 ICPU(0x2d, core_params),
Philippe Longepe1421df62015-11-09 17:40:47 -08001021 ICPU(0x37, silvermont_params),
Dirk Brandewie016c8152013-10-21 09:20:34 -07001022 ICPU(0x3a, core_params),
1023 ICPU(0x3c, core_params),
Dirk Brandewiec7e241d2014-05-08 12:57:27 -07001024 ICPU(0x3d, core_params),
Dirk Brandewie016c8152013-10-21 09:20:34 -07001025 ICPU(0x3e, core_params),
1026 ICPU(0x3f, core_params),
1027 ICPU(0x45, core_params),
1028 ICPU(0x46, core_params),
Dirk Brandewie43f8a962014-11-06 09:50:45 -08001029 ICPU(0x47, core_params),
Philippe Longepe1421df62015-11-09 17:40:47 -08001030 ICPU(0x4c, airmont_params),
Kristen Carlson Accardi7ab02562015-01-28 13:53:28 -08001031 ICPU(0x4e, core_params),
Dirk Brandewiec7e241d2014-05-08 12:57:27 -07001032 ICPU(0x4f, core_params),
Kristen Carlson Accardi1c939122015-08-05 12:47:14 -07001033 ICPU(0x5e, core_params),
Dirk Brandewiec7e241d2014-05-08 12:57:27 -07001034 ICPU(0x56, core_params),
Dasaratharaman Chandramoulib34ef932015-04-10 10:22:18 -07001035 ICPU(0x57, knl_params),
Dirk Brandewie93f08222013-02-06 09:02:13 -08001036 {}
1037};
1038MODULE_DEVICE_TABLE(x86cpu, intel_pstate_cpu_ids);
1039
Dirk Brandewie2f86dc42014-11-06 09:40:47 -08001040static const struct x86_cpu_id intel_pstate_cpu_oob_ids[] = {
1041 ICPU(0x56, core_params),
1042 {}
1043};
1044
Dirk Brandewie93f08222013-02-06 09:02:13 -08001045static int intel_pstate_init_cpu(unsigned int cpunum)
1046{
Dirk Brandewie93f08222013-02-06 09:02:13 -08001047 struct cpudata *cpu;
1048
Dirk Brandewiec0348712014-10-13 08:37:42 -07001049 if (!all_cpu_data[cpunum])
1050 all_cpu_data[cpunum] = kzalloc(sizeof(struct cpudata),
1051 GFP_KERNEL);
Dirk Brandewie93f08222013-02-06 09:02:13 -08001052 if (!all_cpu_data[cpunum])
1053 return -ENOMEM;
1054
1055 cpu = all_cpu_data[cpunum];
1056
Dirk Brandewie93f08222013-02-06 09:02:13 -08001057 cpu->cpu = cpunum;
Kristen Carlson Accardiba88d432015-07-14 09:46:23 -07001058
1059 if (hwp_active)
1060 intel_pstate_hwp_enable(cpu);
1061
Vincent Minet179e8472014-07-05 01:51:33 +02001062 intel_pstate_get_cpu_pstates(cpu);
Dirk Brandewie016c8152013-10-21 09:20:34 -07001063
Dirk Brandewie93f08222013-02-06 09:02:13 -08001064 init_timer_deferrable(&cpu->timer);
Stratos Karafotis2d8d1f12014-07-18 08:37:20 -07001065 cpu->timer.data = (unsigned long)cpu;
Dirk Brandewie93f08222013-02-06 09:02:13 -08001066 cpu->timer.expires = jiffies + HZ/100;
Dirk Brandewie2f86dc42014-11-06 09:40:47 -08001067
1068 if (!hwp_active)
1069 cpu->timer.function = intel_pstate_timer_func;
1070 else
1071 cpu->timer.function = intel_hwp_timer_func;
1072
Dirk Brandewie93f08222013-02-06 09:02:13 -08001073 intel_pstate_busy_pid_reset(cpu);
Dirk Brandewie93f08222013-02-06 09:02:13 -08001074 intel_pstate_sample(cpu);
Dirk Brandewie93f08222013-02-06 09:02:13 -08001075
1076 add_timer_on(&cpu->timer, cpunum);
1077
Doug Smythiesf16255e2015-05-31 07:46:47 -07001078 pr_debug("intel_pstate: controlling: cpu %d\n", cpunum);
Dirk Brandewie93f08222013-02-06 09:02:13 -08001079
1080 return 0;
1081}
1082
1083static unsigned int intel_pstate_get(unsigned int cpu_num)
1084{
1085 struct sample *sample;
1086 struct cpudata *cpu;
1087
1088 cpu = all_cpu_data[cpu_num];
1089 if (!cpu)
1090 return 0;
Dirk Brandewied37e2b72014-02-12 10:01:04 -08001091 sample = &cpu->sample;
Dirk Brandewie93f08222013-02-06 09:02:13 -08001092 return sample->freq;
1093}
1094
1095static int intel_pstate_set_policy(struct cpufreq_policy *policy)
1096{
Dirk Brandewied3929b82013-03-05 14:15:26 -08001097 if (!policy->cpuinfo.max_freq)
1098 return -ENODEV;
1099
Srinivas Pandruvada630ec282015-01-29 12:17:13 -08001100 if (policy->policy == CPUFREQ_POLICY_PERFORMANCE &&
1101 policy->max >= policy->cpuinfo.max_freq) {
Prarit Bhargava51443fb2015-10-15 07:34:15 -04001102 pr_debug("intel_pstate: set performance\n");
1103 limits = &performance_limits;
Alexandra Yates584ee3d2015-11-18 14:58:40 -08001104 if (hwp_active)
1105 intel_pstate_hwp_set();
Srinivas Pandruvadad1b68482013-04-09 22:38:18 +00001106 return 0;
Dirk Brandewie93f08222013-02-06 09:02:13 -08001107 }
Dirk Brandewie2f86dc42014-11-06 09:40:47 -08001108
Prarit Bhargava51443fb2015-10-15 07:34:15 -04001109 pr_debug("intel_pstate: set powersave\n");
1110 limits = &powersave_limits;
1111 limits->min_policy_pct = (policy->min * 100) / policy->cpuinfo.max_freq;
1112 limits->min_policy_pct = clamp_t(int, limits->min_policy_pct, 0 , 100);
Prarit Bhargava8478f532015-11-20 18:47:56 -05001113 limits->max_policy_pct = DIV_ROUND_UP(policy->max * 100,
1114 policy->cpuinfo.max_freq);
Prarit Bhargava51443fb2015-10-15 07:34:15 -04001115 limits->max_policy_pct = clamp_t(int, limits->max_policy_pct, 0 , 100);
Chen Yu43717aa2015-09-09 18:27:31 +08001116
1117 /* Normalize user input to [min_policy_pct, max_policy_pct] */
Prarit Bhargava51443fb2015-10-15 07:34:15 -04001118 limits->min_perf_pct = max(limits->min_policy_pct,
1119 limits->min_sysfs_pct);
1120 limits->min_perf_pct = min(limits->max_policy_pct,
1121 limits->min_perf_pct);
1122 limits->max_perf_pct = min(limits->max_policy_pct,
1123 limits->max_sysfs_pct);
1124 limits->max_perf_pct = max(limits->min_policy_pct,
1125 limits->max_perf_pct);
Prarit Bhargava88b7b7c2015-12-08 13:44:59 -05001126 limits->max_perf = round_up(limits->max_perf, FRAC_BITS);
Chen Yu43717aa2015-09-09 18:27:31 +08001127
1128 /* Make sure min_perf_pct <= max_perf_pct */
Prarit Bhargava51443fb2015-10-15 07:34:15 -04001129 limits->min_perf_pct = min(limits->max_perf_pct, limits->min_perf_pct);
Chen Yu43717aa2015-09-09 18:27:31 +08001130
Prarit Bhargava51443fb2015-10-15 07:34:15 -04001131 limits->min_perf = div_fp(int_tofp(limits->min_perf_pct),
1132 int_tofp(100));
1133 limits->max_perf = div_fp(int_tofp(limits->max_perf_pct),
1134 int_tofp(100));
Dirk Brandewie93f08222013-02-06 09:02:13 -08001135
Dirk Brandewie2f86dc42014-11-06 09:40:47 -08001136 if (hwp_active)
1137 intel_pstate_hwp_set();
1138
Dirk Brandewie93f08222013-02-06 09:02:13 -08001139 return 0;
1140}
1141
1142static int intel_pstate_verify_policy(struct cpufreq_policy *policy)
1143{
Viresh Kumarbe49e342013-10-02 14:13:19 +05301144 cpufreq_verify_within_cpu_limits(policy);
Dirk Brandewie93f08222013-02-06 09:02:13 -08001145
Stratos Karafotis285cb992014-07-18 08:37:21 -07001146 if (policy->policy != CPUFREQ_POLICY_POWERSAVE &&
Stratos Karafotisc4108332014-07-18 08:37:23 -07001147 policy->policy != CPUFREQ_POLICY_PERFORMANCE)
Dirk Brandewie93f08222013-02-06 09:02:13 -08001148 return -EINVAL;
1149
1150 return 0;
1151}
1152
Dirk Brandewiebb180082014-03-19 08:45:54 -07001153static void intel_pstate_stop_cpu(struct cpufreq_policy *policy)
Dirk Brandewie93f08222013-02-06 09:02:13 -08001154{
Dirk Brandewiebb180082014-03-19 08:45:54 -07001155 int cpu_num = policy->cpu;
1156 struct cpudata *cpu = all_cpu_data[cpu_num];
Dirk Brandewie93f08222013-02-06 09:02:13 -08001157
Doug Smythiesf16255e2015-05-31 07:46:47 -07001158 pr_debug("intel_pstate: CPU %d exiting\n", cpu_num);
Dirk Brandewiebb180082014-03-19 08:45:54 -07001159
Dirk Brandewiec2294a22014-03-24 07:41:29 -07001160 del_timer_sync(&all_cpu_data[cpu_num]->timer);
Dirk Brandewie2f86dc42014-11-06 09:40:47 -08001161 if (hwp_active)
1162 return;
1163
Doug Smythies6c1e4592015-06-01 21:12:34 -07001164 intel_pstate_set_pstate(cpu, cpu->pstate.min_pstate, false);
Dirk Brandewie93f08222013-02-06 09:02:13 -08001165}
1166
Paul Gortmaker27609842013-06-19 13:54:04 -04001167static int intel_pstate_cpu_init(struct cpufreq_policy *policy)
Dirk Brandewie93f08222013-02-06 09:02:13 -08001168{
Dirk Brandewie93f08222013-02-06 09:02:13 -08001169 struct cpudata *cpu;
Dirk Brandewie52e0a502013-10-15 11:06:14 -07001170 int rc;
Dirk Brandewie93f08222013-02-06 09:02:13 -08001171
1172 rc = intel_pstate_init_cpu(policy->cpu);
1173 if (rc)
1174 return rc;
1175
1176 cpu = all_cpu_data[policy->cpu];
1177
Prarit Bhargava51443fb2015-10-15 07:34:15 -04001178 if (limits->min_perf_pct == 100 && limits->max_perf_pct == 100)
Dirk Brandewie93f08222013-02-06 09:02:13 -08001179 policy->policy = CPUFREQ_POLICY_PERFORMANCE;
1180 else
1181 policy->policy = CPUFREQ_POLICY_POWERSAVE;
1182
Dirk Brandewieb27580b2014-10-13 08:37:43 -07001183 policy->min = cpu->pstate.min_pstate * cpu->pstate.scaling;
1184 policy->max = cpu->pstate.turbo_pstate * cpu->pstate.scaling;
Dirk Brandewie93f08222013-02-06 09:02:13 -08001185
1186 /* cpuinfo and default policy values */
Dirk Brandewieb27580b2014-10-13 08:37:43 -07001187 policy->cpuinfo.min_freq = cpu->pstate.min_pstate * cpu->pstate.scaling;
1188 policy->cpuinfo.max_freq =
1189 cpu->pstate.turbo_pstate * cpu->pstate.scaling;
Dirk Brandewie93f08222013-02-06 09:02:13 -08001190 policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
1191 cpumask_set_cpu(policy->cpu, policy->cpus);
1192
1193 return 0;
1194}
1195
1196static struct cpufreq_driver intel_pstate_driver = {
1197 .flags = CPUFREQ_CONST_LOOPS,
1198 .verify = intel_pstate_verify_policy,
1199 .setpolicy = intel_pstate_set_policy,
1200 .get = intel_pstate_get,
1201 .init = intel_pstate_cpu_init,
Dirk Brandewiebb180082014-03-19 08:45:54 -07001202 .stop_cpu = intel_pstate_stop_cpu,
Dirk Brandewie93f08222013-02-06 09:02:13 -08001203 .name = "intel_pstate",
Dirk Brandewie93f08222013-02-06 09:02:13 -08001204};
1205
Dirk Brandewie6be26492013-02-15 22:55:10 +01001206static int __initdata no_load;
Dirk Brandewie2f86dc42014-11-06 09:40:47 -08001207static int __initdata no_hwp;
Kristen Carlson Accardid64c3b02015-02-06 13:41:55 -08001208static int __initdata hwp_only;
Ethan Zhaoaa4ea342014-12-09 10:43:19 +09001209static unsigned int force_load;
Dirk Brandewie6be26492013-02-15 22:55:10 +01001210
Dirk Brandewieb563b4e2013-03-22 01:29:28 +01001211static int intel_pstate_msrs_not_valid(void)
1212{
Dirk Brandewie016c8152013-10-21 09:20:34 -07001213 if (!pstate_funcs.get_max() ||
Stratos Karafotisc4108332014-07-18 08:37:23 -07001214 !pstate_funcs.get_min() ||
1215 !pstate_funcs.get_turbo())
Dirk Brandewieb563b4e2013-03-22 01:29:28 +01001216 return -ENODEV;
1217
Dirk Brandewieb563b4e2013-03-22 01:29:28 +01001218 return 0;
1219}
Dirk Brandewie016c8152013-10-21 09:20:34 -07001220
Dirk Brandewiee0a261a2013-10-30 08:38:32 -07001221static void copy_pid_params(struct pstate_adjust_policy *policy)
Dirk Brandewie016c8152013-10-21 09:20:34 -07001222{
1223 pid_params.sample_rate_ms = policy->sample_rate_ms;
1224 pid_params.p_gain_pct = policy->p_gain_pct;
1225 pid_params.i_gain_pct = policy->i_gain_pct;
1226 pid_params.d_gain_pct = policy->d_gain_pct;
1227 pid_params.deadband = policy->deadband;
1228 pid_params.setpoint = policy->setpoint;
1229}
1230
Dirk Brandewiee0a261a2013-10-30 08:38:32 -07001231static void copy_cpu_funcs(struct pstate_funcs *funcs)
Dirk Brandewie016c8152013-10-21 09:20:34 -07001232{
1233 pstate_funcs.get_max = funcs->get_max;
Srinivas Pandruvada3bcc6fa2015-10-14 16:12:00 -07001234 pstate_funcs.get_max_physical = funcs->get_max_physical;
Dirk Brandewie016c8152013-10-21 09:20:34 -07001235 pstate_funcs.get_min = funcs->get_min;
1236 pstate_funcs.get_turbo = funcs->get_turbo;
Dirk Brandewieb27580b2014-10-13 08:37:43 -07001237 pstate_funcs.get_scaling = funcs->get_scaling;
Dirk Brandewie016c8152013-10-21 09:20:34 -07001238 pstate_funcs.set = funcs->set;
Dirk Brandewie007bea02013-12-18 10:32:39 -08001239 pstate_funcs.get_vid = funcs->get_vid;
Dirk Brandewie016c8152013-10-21 09:20:34 -07001240}
1241
Adrian Huangfbbcdc02013-10-31 23:24:05 +08001242#if IS_ENABLED(CONFIG_ACPI)
Rafael J. Wysocki6ee11e412015-11-19 00:20:42 +01001243#include <acpi/processor.h>
Adrian Huangfbbcdc02013-10-31 23:24:05 +08001244
1245static bool intel_pstate_no_acpi_pss(void)
1246{
1247 int i;
1248
1249 for_each_possible_cpu(i) {
1250 acpi_status status;
1251 union acpi_object *pss;
1252 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1253 struct acpi_processor *pr = per_cpu(processors, i);
1254
1255 if (!pr)
1256 continue;
1257
1258 status = acpi_evaluate_object(pr->handle, "_PSS", NULL, &buffer);
1259 if (ACPI_FAILURE(status))
1260 continue;
1261
1262 pss = buffer.pointer;
1263 if (pss && pss->type == ACPI_TYPE_PACKAGE) {
1264 kfree(pss);
1265 return false;
1266 }
1267
1268 kfree(pss);
1269 }
1270
1271 return true;
1272}
1273
ethan zhao966916e2014-12-01 11:32:08 +09001274static bool intel_pstate_has_acpi_ppc(void)
1275{
1276 int i;
1277
1278 for_each_possible_cpu(i) {
1279 struct acpi_processor *pr = per_cpu(processors, i);
1280
1281 if (!pr)
1282 continue;
1283 if (acpi_has_method(pr->handle, "_PPC"))
1284 return true;
1285 }
1286 return false;
1287}
1288
1289enum {
1290 PSS,
1291 PPC,
1292};
1293
Adrian Huangfbbcdc02013-10-31 23:24:05 +08001294struct hw_vendor_info {
1295 u16 valid;
1296 char oem_id[ACPI_OEM_ID_SIZE];
1297 char oem_table_id[ACPI_OEM_TABLE_ID_SIZE];
ethan zhao966916e2014-12-01 11:32:08 +09001298 int oem_pwr_table;
Adrian Huangfbbcdc02013-10-31 23:24:05 +08001299};
1300
1301/* Hardware vendor-specific info that has its own power management modes */
1302static struct hw_vendor_info vendor_info[] = {
ethan zhao966916e2014-12-01 11:32:08 +09001303 {1, "HP ", "ProLiant", PSS},
1304 {1, "ORACLE", "X4-2 ", PPC},
1305 {1, "ORACLE", "X4-2L ", PPC},
1306 {1, "ORACLE", "X4-2B ", PPC},
1307 {1, "ORACLE", "X3-2 ", PPC},
1308 {1, "ORACLE", "X3-2L ", PPC},
1309 {1, "ORACLE", "X3-2B ", PPC},
1310 {1, "ORACLE", "X4470M2 ", PPC},
1311 {1, "ORACLE", "X4270M3 ", PPC},
1312 {1, "ORACLE", "X4270M2 ", PPC},
1313 {1, "ORACLE", "X4170M2 ", PPC},
Ethan Zhao5aecc3c2015-08-05 09:28:50 +09001314 {1, "ORACLE", "X4170 M3", PPC},
1315 {1, "ORACLE", "X4275 M3", PPC},
1316 {1, "ORACLE", "X6-2 ", PPC},
1317 {1, "ORACLE", "Sudbury ", PPC},
Adrian Huangfbbcdc02013-10-31 23:24:05 +08001318 {0, "", ""},
1319};
1320
1321static bool intel_pstate_platform_pwr_mgmt_exists(void)
1322{
1323 struct acpi_table_header hdr;
1324 struct hw_vendor_info *v_info;
Dirk Brandewie2f86dc42014-11-06 09:40:47 -08001325 const struct x86_cpu_id *id;
1326 u64 misc_pwr;
1327
1328 id = x86_match_cpu(intel_pstate_cpu_oob_ids);
1329 if (id) {
1330 rdmsrl(MSR_MISC_PWR_MGMT, misc_pwr);
1331 if ( misc_pwr & (1 << 8))
1332 return true;
1333 }
Adrian Huangfbbcdc02013-10-31 23:24:05 +08001334
Stratos Karafotisc4108332014-07-18 08:37:23 -07001335 if (acpi_disabled ||
1336 ACPI_FAILURE(acpi_get_table_header(ACPI_SIG_FADT, 0, &hdr)))
Adrian Huangfbbcdc02013-10-31 23:24:05 +08001337 return false;
1338
1339 for (v_info = vendor_info; v_info->valid; v_info++) {
Stratos Karafotisc4108332014-07-18 08:37:23 -07001340 if (!strncmp(hdr.oem_id, v_info->oem_id, ACPI_OEM_ID_SIZE) &&
ethan zhao966916e2014-12-01 11:32:08 +09001341 !strncmp(hdr.oem_table_id, v_info->oem_table_id,
1342 ACPI_OEM_TABLE_ID_SIZE))
1343 switch (v_info->oem_pwr_table) {
1344 case PSS:
1345 return intel_pstate_no_acpi_pss();
1346 case PPC:
Ethan Zhaoaa4ea342014-12-09 10:43:19 +09001347 return intel_pstate_has_acpi_ppc() &&
1348 (!force_load);
ethan zhao966916e2014-12-01 11:32:08 +09001349 }
Adrian Huangfbbcdc02013-10-31 23:24:05 +08001350 }
1351
1352 return false;
1353}
1354#else /* CONFIG_ACPI not enabled */
1355static inline bool intel_pstate_platform_pwr_mgmt_exists(void) { return false; }
ethan zhao966916e2014-12-01 11:32:08 +09001356static inline bool intel_pstate_has_acpi_ppc(void) { return false; }
Adrian Huangfbbcdc02013-10-31 23:24:05 +08001357#endif /* CONFIG_ACPI */
1358
Dirk Brandewie93f08222013-02-06 09:02:13 -08001359static int __init intel_pstate_init(void)
1360{
Dirk Brandewie907cc902013-03-05 14:15:27 -08001361 int cpu, rc = 0;
Dirk Brandewie93f08222013-02-06 09:02:13 -08001362 const struct x86_cpu_id *id;
Borislav Petkov64df1fd2015-04-03 15:19:53 +02001363 struct cpu_defaults *cpu_def;
Dirk Brandewie93f08222013-02-06 09:02:13 -08001364
Dirk Brandewie6be26492013-02-15 22:55:10 +01001365 if (no_load)
1366 return -ENODEV;
1367
Dirk Brandewie93f08222013-02-06 09:02:13 -08001368 id = x86_match_cpu(intel_pstate_cpu_ids);
1369 if (!id)
1370 return -ENODEV;
1371
Adrian Huangfbbcdc02013-10-31 23:24:05 +08001372 /*
1373 * The Intel pstate driver will be ignored if the platform
1374 * firmware has its own power management modes.
1375 */
1376 if (intel_pstate_platform_pwr_mgmt_exists())
1377 return -ENODEV;
1378
Borislav Petkov64df1fd2015-04-03 15:19:53 +02001379 cpu_def = (struct cpu_defaults *)id->driver_data;
Dirk Brandewie016c8152013-10-21 09:20:34 -07001380
Borislav Petkov64df1fd2015-04-03 15:19:53 +02001381 copy_pid_params(&cpu_def->pid_policy);
1382 copy_cpu_funcs(&cpu_def->funcs);
Dirk Brandewie016c8152013-10-21 09:20:34 -07001383
Dirk Brandewieb563b4e2013-03-22 01:29:28 +01001384 if (intel_pstate_msrs_not_valid())
1385 return -ENODEV;
1386
Dirk Brandewie93f08222013-02-06 09:02:13 -08001387 pr_info("Intel P-state driver initializing.\n");
1388
Wei Yongjunb57ffac2013-05-13 08:03:43 +00001389 all_cpu_data = vzalloc(sizeof(void *) * num_possible_cpus());
Dirk Brandewie93f08222013-02-06 09:02:13 -08001390 if (!all_cpu_data)
1391 return -ENOMEM;
Dirk Brandewie93f08222013-02-06 09:02:13 -08001392
Prarit Bhargava539342f2015-10-22 09:43:31 -04001393 if (static_cpu_has_safe(X86_FEATURE_HWP) && !no_hwp) {
1394 pr_info("intel_pstate: HWP enabled\n");
Kristen Carlson Accardiba88d432015-07-14 09:46:23 -07001395 hwp_active++;
Prarit Bhargava539342f2015-10-22 09:43:31 -04001396 }
Dirk Brandewie2f86dc42014-11-06 09:40:47 -08001397
Kristen Carlson Accardid64c3b02015-02-06 13:41:55 -08001398 if (!hwp_active && hwp_only)
1399 goto out;
1400
Dirk Brandewie93f08222013-02-06 09:02:13 -08001401 rc = cpufreq_register_driver(&intel_pstate_driver);
1402 if (rc)
1403 goto out;
1404
1405 intel_pstate_debug_expose_params();
1406 intel_pstate_sysfs_expose_params();
Dirk Brandewieb69880f2014-01-16 10:32:25 -08001407
Dirk Brandewie93f08222013-02-06 09:02:13 -08001408 return rc;
1409out:
Dirk Brandewie907cc902013-03-05 14:15:27 -08001410 get_online_cpus();
1411 for_each_online_cpu(cpu) {
1412 if (all_cpu_data[cpu]) {
1413 del_timer_sync(&all_cpu_data[cpu]->timer);
1414 kfree(all_cpu_data[cpu]);
1415 }
1416 }
1417
1418 put_online_cpus();
1419 vfree(all_cpu_data);
Dirk Brandewie93f08222013-02-06 09:02:13 -08001420 return -ENODEV;
1421}
1422device_initcall(intel_pstate_init);
1423
Dirk Brandewie6be26492013-02-15 22:55:10 +01001424static int __init intel_pstate_setup(char *str)
1425{
1426 if (!str)
1427 return -EINVAL;
1428
1429 if (!strcmp(str, "disable"))
1430 no_load = 1;
Prarit Bhargava539342f2015-10-22 09:43:31 -04001431 if (!strcmp(str, "no_hwp")) {
1432 pr_info("intel_pstate: HWP disabled\n");
Dirk Brandewie2f86dc42014-11-06 09:40:47 -08001433 no_hwp = 1;
Prarit Bhargava539342f2015-10-22 09:43:31 -04001434 }
Ethan Zhaoaa4ea342014-12-09 10:43:19 +09001435 if (!strcmp(str, "force"))
1436 force_load = 1;
Kristen Carlson Accardid64c3b02015-02-06 13:41:55 -08001437 if (!strcmp(str, "hwp_only"))
1438 hwp_only = 1;
Dirk Brandewie6be26492013-02-15 22:55:10 +01001439 return 0;
1440}
1441early_param("intel_pstate", intel_pstate_setup);
1442
Dirk Brandewie93f08222013-02-06 09:02:13 -08001443MODULE_AUTHOR("Dirk Brandewie <dirk.j.brandewie@intel.com>");
1444MODULE_DESCRIPTION("'intel_pstate' - P state driver Intel Core processors");
1445MODULE_LICENSE("GPL");