blob: 1ee3674a99bb8404306f2f483a6cdf30cb94bd59 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Dave Jones3a58df32009-01-17 22:36:14 -05002 * acpi-cpufreq.c - ACPI Processor P-States Driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 * Copyright (C) 2002 - 2004 Dominik Brodowski <linux@brodo.de>
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -07007 * Copyright (C) 2006 Denis Sadykov <denis.m.sadykov@intel.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or (at
14 * your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
24 *
25 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26 */
27
Joe Perches1c5864e2016-04-05 13:28:25 -070028#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/kernel.h>
31#include <linux/module.h>
32#include <linux/init.h>
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -070033#include <linux/smp.h>
34#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/cpufreq.h>
Venkatesh Pallipadid395bf12005-08-25 15:59:00 -040036#include <linux/compiler.h>
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -070037#include <linux/dmi.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090038#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40#include <linux/acpi.h>
Dave Jones3a58df32009-01-17 22:36:14 -050041#include <linux/io.h>
42#include <linux/delay.h>
43#include <linux/uaccess.h>
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <acpi/processor.h>
46
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -070047#include <asm/msr.h>
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -070048#include <asm/processor.h>
49#include <asm/cpufeature.h>
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -070050
Linus Torvalds1da177e2005-04-16 15:20:36 -070051MODULE_AUTHOR("Paul Diefenbaugh, Dominik Brodowski");
52MODULE_DESCRIPTION("ACPI Processor P-States Driver");
53MODULE_LICENSE("GPL");
54
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -070055enum {
56 UNDEFINED_CAPABLE = 0,
57 SYSTEM_INTEL_MSR_CAPABLE,
Matthew Garrett3dc9a632012-09-04 08:28:02 +000058 SYSTEM_AMD_MSR_CAPABLE,
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -070059 SYSTEM_IO_CAPABLE,
60};
61
62#define INTEL_MSR_RANGE (0xffff)
Matthew Garrett3dc9a632012-09-04 08:28:02 +000063#define AMD_MSR_RANGE (0x7)
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -070064
Andre Przywara615b7302012-09-04 08:28:07 +000065#define MSR_K7_HWCR_CPB_DIS (1ULL << 25)
66
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -070067struct acpi_cpufreq_data {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -070068 unsigned int resume;
69 unsigned int cpu_feature;
Pan Xinhui8cfcfd32015-07-10 14:36:20 +080070 unsigned int acpi_perf_cpu;
Lan Tianyuf4fd3792013-06-27 15:08:54 +080071 cpumask_var_t freqdomain_cpus;
Rafael J. Wysockied757a22016-03-02 03:05:22 +010072 void (*cpu_freq_write)(struct acpi_pct_register *reg, u32 val);
73 u32 (*cpu_freq_read)(struct acpi_pct_register *reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074};
75
Fenghua Yu50109292007-08-07 18:40:30 -040076/* acpi_perf_data is a pointer to percpu data. */
Namhyung Kim3f6c4df2010-08-13 23:00:11 +090077static struct acpi_processor_performance __percpu *acpi_perf_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
Rafael J. Wysocki34276162015-07-22 22:11:56 +020079static inline struct acpi_processor_performance *to_perf_data(struct acpi_cpufreq_data *data)
80{
81 return per_cpu_ptr(acpi_perf_data, data->acpi_perf_cpu);
82}
83
Linus Torvalds1da177e2005-04-16 15:20:36 -070084static struct cpufreq_driver acpi_cpufreq_driver;
85
Venkatesh Pallipadid395bf12005-08-25 15:59:00 -040086static unsigned int acpi_pstate_strict;
Andre Przywara615b7302012-09-04 08:28:07 +000087static struct msr __percpu *msrs;
88
89static bool boost_state(unsigned int cpu)
90{
91 u32 lo, hi;
92 u64 msr;
93
94 switch (boot_cpu_data.x86_vendor) {
95 case X86_VENDOR_INTEL:
96 rdmsr_on_cpu(cpu, MSR_IA32_MISC_ENABLE, &lo, &hi);
97 msr = lo | ((u64)hi << 32);
98 return !(msr & MSR_IA32_MISC_ENABLE_TURBO_DISABLE);
99 case X86_VENDOR_AMD:
100 rdmsr_on_cpu(cpu, MSR_K7_HWCR, &lo, &hi);
101 msr = lo | ((u64)hi << 32);
102 return !(msr & MSR_K7_HWCR_CPB_DIS);
103 }
104 return false;
105}
106
107static void boost_set_msrs(bool enable, const struct cpumask *cpumask)
108{
109 u32 cpu;
110 u32 msr_addr;
111 u64 msr_mask;
112
113 switch (boot_cpu_data.x86_vendor) {
114 case X86_VENDOR_INTEL:
115 msr_addr = MSR_IA32_MISC_ENABLE;
116 msr_mask = MSR_IA32_MISC_ENABLE_TURBO_DISABLE;
117 break;
118 case X86_VENDOR_AMD:
119 msr_addr = MSR_K7_HWCR;
120 msr_mask = MSR_K7_HWCR_CPB_DIS;
121 break;
122 default:
123 return;
124 }
125
126 rdmsr_on_cpus(cpumask, msr_addr, msrs);
127
128 for_each_cpu(cpu, cpumask) {
129 struct msr *reg = per_cpu_ptr(msrs, cpu);
130 if (enable)
131 reg->q &= ~msr_mask;
132 else
133 reg->q |= msr_mask;
134 }
135
136 wrmsr_on_cpus(cpumask, msr_addr, msrs);
137}
138
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100139static int set_boost(int val)
Andre Przywara615b7302012-09-04 08:28:07 +0000140{
Andre Przywara615b7302012-09-04 08:28:07 +0000141 get_online_cpus();
Andre Przywara615b7302012-09-04 08:28:07 +0000142 boost_set_msrs(val, cpu_online_mask);
Andre Przywara615b7302012-09-04 08:28:07 +0000143 put_online_cpus();
Andre Przywara615b7302012-09-04 08:28:07 +0000144 pr_debug("Core Boosting %sabled.\n", val ? "en" : "dis");
145
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100146 return 0;
Andre Przywara615b7302012-09-04 08:28:07 +0000147}
148
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800149static ssize_t show_freqdomain_cpus(struct cpufreq_policy *policy, char *buf)
150{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800151 struct acpi_cpufreq_data *data = policy->driver_data;
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800152
Srinivas Pandruvadae2530362015-10-07 13:50:43 -0700153 if (unlikely(!data))
154 return -ENODEV;
155
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800156 return cpufreq_show_cpus(data->freqdomain_cpus, buf);
157}
158
159cpufreq_freq_attr_ro(freqdomain_cpus);
160
Andre Przywara11269ff2012-09-04 08:28:08 +0000161#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100162static ssize_t store_cpb(struct cpufreq_policy *policy, const char *buf,
163 size_t count)
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100164{
165 int ret;
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100166 unsigned int val = 0;
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100167
Rafael J. Wysocki7a6c79f2015-12-27 00:27:38 +0100168 if (!acpi_cpufreq_driver.set_boost)
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100169 return -EINVAL;
170
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100171 ret = kstrtouint(buf, 10, &val);
172 if (ret || val > 1)
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100173 return -EINVAL;
174
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100175 set_boost(val);
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100176
177 return count;
178}
179
Andre Przywara11269ff2012-09-04 08:28:08 +0000180static ssize_t show_cpb(struct cpufreq_policy *policy, char *buf)
181{
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100182 return sprintf(buf, "%u\n", acpi_cpufreq_driver.boost_enabled);
Andre Przywara11269ff2012-09-04 08:28:08 +0000183}
184
Lan Tianyu59027d32013-08-13 10:05:53 +0800185cpufreq_freq_attr_rw(cpb);
Andre Przywara11269ff2012-09-04 08:28:08 +0000186#endif
187
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700188static int check_est_cpu(unsigned int cpuid)
189{
Mike Travis92cb7612007-10-19 20:35:04 +0200190 struct cpuinfo_x86 *cpu = &cpu_data(cpuid);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700191
Harald Welte0de51082009-06-08 18:27:54 +0800192 return cpu_has(cpu, X86_FEATURE_EST);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700193}
194
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000195static int check_amd_hwpstate_cpu(unsigned int cpuid)
196{
197 struct cpuinfo_x86 *cpu = &cpu_data(cpuid);
198
199 return cpu_has(cpu, X86_FEATURE_HW_PSTATE);
200}
201
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530202static unsigned extract_io(struct cpufreq_policy *policy, u32 value)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700203{
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530204 struct acpi_cpufreq_data *data = policy->driver_data;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700205 struct acpi_processor_performance *perf;
206 int i;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700207
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200208 perf = to_perf_data(data);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700209
Dave Jones3a58df32009-01-17 22:36:14 -0500210 for (i = 0; i < perf->state_count; i++) {
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700211 if (value == perf->states[i].status)
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530212 return policy->freq_table[i].frequency;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700213 }
214 return 0;
215}
216
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530217static unsigned extract_msr(struct cpufreq_policy *policy, u32 msr)
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700218{
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530219 struct acpi_cpufreq_data *data = policy->driver_data;
Stratos Karafotis041526f2014-04-25 23:15:38 +0300220 struct cpufreq_frequency_table *pos;
Venkatesh Pallipadia6f6e6e62006-10-03 12:37:42 -0700221 struct acpi_processor_performance *perf;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700222
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000223 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
224 msr &= AMD_MSR_RANGE;
225 else
226 msr &= INTEL_MSR_RANGE;
227
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200228 perf = to_perf_data(data);
Venkatesh Pallipadia6f6e6e62006-10-03 12:37:42 -0700229
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530230 cpufreq_for_each_entry(pos, policy->freq_table)
Stratos Karafotis041526f2014-04-25 23:15:38 +0300231 if (msr == perf->states[pos->driver_data].status)
232 return pos->frequency;
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530233 return policy->freq_table[0].frequency;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700234}
235
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530236static unsigned extract_freq(struct cpufreq_policy *policy, u32 val)
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700237{
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530238 struct acpi_cpufreq_data *data = policy->driver_data;
239
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700240 switch (data->cpu_feature) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700241 case SYSTEM_INTEL_MSR_CAPABLE:
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000242 case SYSTEM_AMD_MSR_CAPABLE:
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530243 return extract_msr(policy, val);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700244 case SYSTEM_IO_CAPABLE:
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530245 return extract_io(policy, val);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700246 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700247 return 0;
248 }
249}
250
Jisheng Zhangac13b992016-03-22 22:34:30 +0800251static u32 cpu_freq_read_intel(struct acpi_pct_register *not_used)
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100252{
253 u32 val, dummy;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700254
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100255 rdmsr(MSR_IA32_PERF_CTL, val, dummy);
256 return val;
257}
258
Jisheng Zhangac13b992016-03-22 22:34:30 +0800259static void cpu_freq_write_intel(struct acpi_pct_register *not_used, u32 val)
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100260{
261 u32 lo, hi;
262
263 rdmsr(MSR_IA32_PERF_CTL, lo, hi);
264 lo = (lo & ~INTEL_MSR_RANGE) | (val & INTEL_MSR_RANGE);
265 wrmsr(MSR_IA32_PERF_CTL, lo, hi);
266}
267
Jisheng Zhangac13b992016-03-22 22:34:30 +0800268static u32 cpu_freq_read_amd(struct acpi_pct_register *not_used)
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100269{
270 u32 val, dummy;
271
272 rdmsr(MSR_AMD_PERF_CTL, val, dummy);
273 return val;
274}
275
Jisheng Zhangac13b992016-03-22 22:34:30 +0800276static void cpu_freq_write_amd(struct acpi_pct_register *not_used, u32 val)
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100277{
278 wrmsr(MSR_AMD_PERF_CTL, val, 0);
279}
280
Jisheng Zhangac13b992016-03-22 22:34:30 +0800281static u32 cpu_freq_read_io(struct acpi_pct_register *reg)
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100282{
283 u32 val;
284
285 acpi_os_read_port(reg->address, &val, reg->bit_width);
286 return val;
287}
288
Jisheng Zhangac13b992016-03-22 22:34:30 +0800289static void cpu_freq_write_io(struct acpi_pct_register *reg, u32 val)
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100290{
291 acpi_os_write_port(reg->address, val, reg->bit_width);
292}
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700293
294struct drv_cmd {
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100295 struct acpi_pct_register *reg;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700296 u32 val;
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100297 union {
298 void (*write)(struct acpi_pct_register *reg, u32 val);
299 u32 (*read)(struct acpi_pct_register *reg);
300 } func;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700301};
302
Andrew Morton01599fc2009-04-13 10:27:49 -0700303/* Called via smp_call_function_single(), on the target CPU */
304static void do_drv_read(void *_cmd)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700305{
Mike Travis72859082009-01-16 15:31:15 -0800306 struct drv_cmd *cmd = _cmd;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700307
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100308 cmd->val = cmd->func.read(cmd->reg);
309}
310
311static u32 drv_read(struct acpi_cpufreq_data *data, const struct cpumask *mask)
312{
313 struct acpi_processor_performance *perf = to_perf_data(data);
314 struct drv_cmd cmd = {
315 .reg = &perf->control_register,
316 .func.read = data->cpu_freq_read,
317 };
318 int err;
319
320 err = smp_call_function_any(mask, do_drv_read, &cmd, 1);
321 WARN_ON_ONCE(err); /* smp_call_function_any() was buggy? */
322 return cmd.val;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700323}
324
Andrew Morton01599fc2009-04-13 10:27:49 -0700325/* Called via smp_call_function_many(), on the target CPUs */
326static void do_drv_write(void *_cmd)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700327{
Mike Travis72859082009-01-16 15:31:15 -0800328 struct drv_cmd *cmd = _cmd;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700329
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100330 cmd->func.write(cmd->reg, cmd->val);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700331}
332
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100333static void drv_write(struct acpi_cpufreq_data *data,
334 const struct cpumask *mask, u32 val)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700335{
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100336 struct acpi_processor_performance *perf = to_perf_data(data);
337 struct drv_cmd cmd = {
338 .reg = &perf->control_register,
339 .val = val,
340 .func.write = data->cpu_freq_write,
341 };
Linus Torvaldsea34f432009-04-15 08:05:13 -0700342 int this_cpu;
343
344 this_cpu = get_cpu();
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100345 if (cpumask_test_cpu(this_cpu, mask))
346 do_drv_write(&cmd);
347
348 smp_call_function_many(mask, do_drv_write, &cmd, 1);
Linus Torvaldsea34f432009-04-15 08:05:13 -0700349 put_cpu();
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700350}
351
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100352static u32 get_cur_val(const struct cpumask *mask, struct acpi_cpufreq_data *data)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700353{
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100354 u32 val;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700355
Mike Travis4d8bb532009-01-04 05:18:08 -0800356 if (unlikely(cpumask_empty(mask)))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700357 return 0;
358
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100359 val = drv_read(data, mask);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700360
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100361 pr_debug("get_cur_val = %u\n", val);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700362
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100363 return val;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700364}
365
366static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
367{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800368 struct acpi_cpufreq_data *data;
369 struct cpufreq_policy *policy;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700370 unsigned int freq;
Venkatesh Pallipadie56a7272008-04-28 15:13:43 -0400371 unsigned int cached_freq;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700372
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200373 pr_debug("get_cur_freq_on_cpu (%d)\n", cpu);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700374
Rafael J. Wysocki1f0bd442015-09-16 02:17:49 +0200375 policy = cpufreq_cpu_get_raw(cpu);
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800376 if (unlikely(!policy))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700377 return 0;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800378
379 data = policy->driver_data;
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530380 if (unlikely(!data || !policy->freq_table))
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800381 return 0;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700382
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530383 cached_freq = policy->freq_table[to_perf_data(data)->state].frequency;
384 freq = extract_freq(policy, get_cur_val(cpumask_of(cpu), data));
Venkatesh Pallipadie56a7272008-04-28 15:13:43 -0400385 if (freq != cached_freq) {
386 /*
387 * The dreaded BIOS frequency change behind our back.
388 * Force set the frequency on next target call.
389 */
390 data->resume = 1;
391 }
392
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200393 pr_debug("cur freq = %u\n", freq);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700394
395 return freq;
396}
397
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530398static unsigned int check_freqs(struct cpufreq_policy *policy,
399 const struct cpumask *mask, unsigned int freq)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700400{
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530401 struct acpi_cpufreq_data *data = policy->driver_data;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700402 unsigned int cur_freq;
403 unsigned int i;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700404
Dave Jones3a58df32009-01-17 22:36:14 -0500405 for (i = 0; i < 100; i++) {
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530406 cur_freq = extract_freq(policy, get_cur_val(mask, data));
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700407 if (cur_freq == freq)
408 return 1;
409 udelay(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 }
411 return 0;
412}
413
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700414static int acpi_cpufreq_target(struct cpufreq_policy *policy,
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530415 unsigned int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800417 struct acpi_cpufreq_data *data = policy->driver_data;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700418 struct acpi_processor_performance *perf;
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100419 const struct cpumask *mask;
Venkatesh Pallipadi8edc59d92006-12-19 12:58:55 -0800420 unsigned int next_perf_state = 0; /* Index into perf table */
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700421 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530423 if (unlikely(!data)) {
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700424 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 }
426
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200427 perf = to_perf_data(data);
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530428 next_perf_state = policy->freq_table[index].driver_data;
Venkatesh Pallipadi7650b282006-10-03 12:36:30 -0700429 if (perf->state == next_perf_state) {
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700430 if (unlikely(data->resume)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200431 pr_debug("Called after resume, resetting to P%d\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700432 next_perf_state);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700433 data->resume = 0;
434 } else {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200435 pr_debug("Already at target state (P%d)\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700436 next_perf_state);
Rafael J. Wysocki9a909a12016-02-26 00:03:58 +0100437 return 0;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700438 }
439 }
440
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100441 /*
442 * The core won't allow CPUs to go away until the governor has been
443 * stopped, so we can rely on the stability of policy->cpus.
444 */
445 mask = policy->shared_type == CPUFREQ_SHARED_TYPE_ANY ?
446 cpumask_of(policy->cpu) : policy->cpus;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700447
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100448 drv_write(data, mask, perf->states[next_perf_state].control);
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500449
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700450 if (acpi_pstate_strict) {
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530451 if (!check_freqs(policy, mask,
452 policy->freq_table[index].frequency)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200453 pr_debug("acpi_cpufreq_target failed (%d)\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700454 policy->cpu);
Mike Travis4d8bb532009-01-04 05:18:08 -0800455 result = -EAGAIN;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500456 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500457 }
458
Viresh Kumare15d8302013-06-19 14:22:55 +0530459 if (!result)
460 perf->state = next_perf_state;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500461
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700462 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463}
464
Rafael J. Wysockib7898fd2016-03-30 03:47:49 +0200465unsigned int acpi_cpufreq_fast_switch(struct cpufreq_policy *policy,
466 unsigned int target_freq)
467{
468 struct acpi_cpufreq_data *data = policy->driver_data;
469 struct acpi_processor_performance *perf;
470 struct cpufreq_frequency_table *entry;
Viresh Kumar82577362016-06-27 09:59:34 +0530471 unsigned int next_perf_state, next_freq, index;
Rafael J. Wysockib7898fd2016-03-30 03:47:49 +0200472
473 /*
474 * Find the closest frequency above target_freq.
Rafael J. Wysockib7898fd2016-03-30 03:47:49 +0200475 */
Steve Muckle5b6667c2016-07-13 13:25:27 -0700476 if (policy->cached_target_freq == target_freq)
477 index = policy->cached_resolved_idx;
478 else
479 index = cpufreq_table_find_index_dl(policy, target_freq);
Viresh Kumar82577362016-06-27 09:59:34 +0530480
481 entry = &policy->freq_table[index];
Rafael J. Wysockib7898fd2016-03-30 03:47:49 +0200482 next_freq = entry->frequency;
483 next_perf_state = entry->driver_data;
484
485 perf = to_perf_data(data);
486 if (perf->state == next_perf_state) {
487 if (unlikely(data->resume))
488 data->resume = 0;
489 else
490 return next_freq;
491 }
492
493 data->cpu_freq_write(&perf->control_register,
494 perf->states[next_perf_state].control);
495 perf->state = next_perf_state;
496 return next_freq;
497}
498
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499static unsigned long
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700500acpi_cpufreq_guess_freq(struct acpi_cpufreq_data *data, unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501{
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200502 struct acpi_processor_performance *perf;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500503
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200504 perf = to_perf_data(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 if (cpu_khz) {
506 /* search the closest match to cpu_khz */
507 unsigned int i;
508 unsigned long freq;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500509 unsigned long freqn = perf->states[0].core_frequency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Dave Jones3a58df32009-01-17 22:36:14 -0500511 for (i = 0; i < (perf->state_count-1); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 freq = freqn;
Dave Jones95dd7222006-10-18 00:41:48 -0400513 freqn = perf->states[i+1].core_frequency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 if ((2 * cpu_khz) > (freqn + freq)) {
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500515 perf->state = i;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700516 return freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 }
518 }
Dave Jones95dd7222006-10-18 00:41:48 -0400519 perf->state = perf->state_count-1;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700520 return freqn;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500521 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 /* assume CPU is at P0... */
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500523 perf->state = 0;
524 return perf->states[0].core_frequency * 1000;
525 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526}
527
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800528static void free_acpi_perf_data(void)
529{
530 unsigned int i;
531
532 /* Freeing a NULL pointer is OK, and alloc_percpu zeroes. */
533 for_each_possible_cpu(i)
534 free_cpumask_var(per_cpu_ptr(acpi_perf_data, i)
535 ->shared_cpu_map);
536 free_percpu(acpi_perf_data);
537}
538
Andre Przywara615b7302012-09-04 08:28:07 +0000539static int boost_notify(struct notifier_block *nb, unsigned long action,
540 void *hcpu)
541{
542 unsigned cpu = (long)hcpu;
543 const struct cpumask *cpumask;
544
545 cpumask = get_cpu_mask(cpu);
546
547 /*
548 * Clear the boost-disable bit on the CPU_DOWN path so that
549 * this cpu cannot block the remaining ones from boosting. On
550 * the CPU_UP path we simply keep the boost-disable flag in
551 * sync with the current global state.
552 */
553
554 switch (action) {
Richard Cochraned726622016-03-18 22:26:11 +0100555 case CPU_DOWN_FAILED:
556 case CPU_DOWN_FAILED_FROZEN:
557 case CPU_ONLINE:
558 case CPU_ONLINE_FROZEN:
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100559 boost_set_msrs(acpi_cpufreq_driver.boost_enabled, cpumask);
Andre Przywara615b7302012-09-04 08:28:07 +0000560 break;
561
562 case CPU_DOWN_PREPARE:
563 case CPU_DOWN_PREPARE_FROZEN:
564 boost_set_msrs(1, cpumask);
565 break;
566
567 default:
568 break;
569 }
570
571 return NOTIFY_OK;
572}
573
574
575static struct notifier_block boost_nb = {
576 .notifier_call = boost_notify,
577};
578
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500579/*
580 * acpi_cpufreq_early_init - initialize ACPI P-States library
581 *
582 * Initialize the ACPI P-States library (drivers/acpi/processor_perflib.c)
583 * in order to determine correct frequency and voltage pairings. We can
584 * do _PDC and _PSD and find out the processor dependency for the
585 * actual init that will happen later...
586 */
Fenghua Yu50109292007-08-07 18:40:30 -0400587static int __init acpi_cpufreq_early_init(void)
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500588{
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800589 unsigned int i;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200590 pr_debug("acpi_cpufreq_early_init\n");
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500591
Fenghua Yu50109292007-08-07 18:40:30 -0400592 acpi_perf_data = alloc_percpu(struct acpi_processor_performance);
593 if (!acpi_perf_data) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200594 pr_debug("Memory allocation error for acpi_perf_data.\n");
Fenghua Yu50109292007-08-07 18:40:30 -0400595 return -ENOMEM;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500596 }
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800597 for_each_possible_cpu(i) {
Yinghai Lueaa95842009-06-06 14:51:36 -0700598 if (!zalloc_cpumask_var_node(
Mike Travis80855f72008-12-31 18:08:47 -0800599 &per_cpu_ptr(acpi_perf_data, i)->shared_cpu_map,
600 GFP_KERNEL, cpu_to_node(i))) {
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800601
602 /* Freeing a NULL pointer is OK: alloc_percpu zeroes. */
603 free_acpi_perf_data();
604 return -ENOMEM;
605 }
606 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500607
608 /* Do initialization in ACPI core */
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700609 acpi_processor_preregister_performance(acpi_perf_data);
610 return 0;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500611}
612
Dave Jones95625b82006-10-21 01:37:39 -0400613#ifdef CONFIG_SMP
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700614/*
615 * Some BIOSes do SW_ANY coordination internally, either set it up in hw
616 * or do it in BIOS firmware and won't inform about it to OS. If not
617 * detected, this has a side effect of making CPU run at a different speed
618 * than OS intended it to run at. Detect it and handle it cleanly.
619 */
620static int bios_with_sw_any_bug;
621
Jeff Garzik18552562007-10-03 15:15:40 -0400622static int sw_any_bug_found(const struct dmi_system_id *d)
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700623{
624 bios_with_sw_any_bug = 1;
625 return 0;
626}
627
Jeff Garzik18552562007-10-03 15:15:40 -0400628static const struct dmi_system_id sw_any_bug_dmi_table[] = {
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700629 {
630 .callback = sw_any_bug_found,
631 .ident = "Supermicro Server X6DLP",
632 .matches = {
633 DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
634 DMI_MATCH(DMI_BIOS_VERSION, "080010"),
635 DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"),
636 },
637 },
638 { }
639};
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400640
641static int acpi_cpufreq_blacklist(struct cpuinfo_x86 *c)
642{
John Villalovos293afe42009-09-25 13:30:08 -0400643 /* Intel Xeon Processor 7100 Series Specification Update
644 * http://www.intel.com/Assets/PDF/specupdate/314554.pdf
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400645 * AL30: A Machine Check Exception (MCE) Occurring during an
646 * Enhanced Intel SpeedStep Technology Ratio Change May Cause
John Villalovos293afe42009-09-25 13:30:08 -0400647 * Both Processor Cores to Lock Up. */
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400648 if (c->x86_vendor == X86_VENDOR_INTEL) {
649 if ((c->x86 == 15) &&
650 (c->x86_model == 6) &&
Jia Zhang06be0072018-01-01 09:52:10 +0800651 (c->x86_stepping == 8)) {
Joe Perches1c5864e2016-04-05 13:28:25 -0700652 pr_info("Intel(R) Xeon(R) 7100 Errata AL30, processors may lock up on frequency changes: disabling acpi-cpufreq\n");
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400653 return -ENODEV;
John Villalovos293afe42009-09-25 13:30:08 -0400654 }
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400655 }
656 return 0;
657}
Dave Jones95625b82006-10-21 01:37:39 -0400658#endif
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700659
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700660static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661{
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700662 unsigned int i;
663 unsigned int valid_states = 0;
664 unsigned int cpu = policy->cpu;
665 struct acpi_cpufreq_data *data;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700666 unsigned int result = 0;
Mike Travis92cb7612007-10-19 20:35:04 +0200667 struct cpuinfo_x86 *c = &cpu_data(policy->cpu);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700668 struct acpi_processor_performance *perf;
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530669 struct cpufreq_frequency_table *freq_table;
John Villalovos293afe42009-09-25 13:30:08 -0400670#ifdef CONFIG_SMP
671 static int blacklisted;
672#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200674 pr_debug("acpi_cpufreq_cpu_init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400676#ifdef CONFIG_SMP
John Villalovos293afe42009-09-25 13:30:08 -0400677 if (blacklisted)
678 return blacklisted;
679 blacklisted = acpi_cpufreq_blacklist(c);
680 if (blacklisted)
681 return blacklisted;
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400682#endif
683
Viresh Kumard5b73cd2013-08-06 22:53:06 +0530684 data = kzalloc(sizeof(*data), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 if (!data)
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700686 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800688 if (!zalloc_cpumask_var(&data->freqdomain_cpus, GFP_KERNEL)) {
689 result = -ENOMEM;
690 goto err_free;
691 }
692
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200693 perf = per_cpu_ptr(acpi_perf_data, cpu);
Pan Xinhui8cfcfd32015-07-10 14:36:20 +0800694 data->acpi_perf_cpu = cpu;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800695 policy->driver_data = data;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700696
Dave Jones95dd7222006-10-18 00:41:48 -0400697 if (cpu_has(c, X86_FEATURE_CONSTANT_TSC))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700698 acpi_cpufreq_driver.flags |= CPUFREQ_CONST_LOOPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200700 result = acpi_processor_register_performance(perf, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 if (result)
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800702 goto err_free_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500704 policy->shared_type = perf->shared_type;
Dave Jones95dd7222006-10-18 00:41:48 -0400705
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400706 /*
Dave Jones95dd7222006-10-18 00:41:48 -0400707 * Will let policy->cpus know about dependency only when software
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400708 * coordination is required.
709 */
710 if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700711 policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
Rusty Russell835481d2009-01-04 05:18:06 -0800712 cpumask_copy(policy->cpus, perf->shared_cpu_map);
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700713 }
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800714 cpumask_copy(data->freqdomain_cpus, perf->shared_cpu_map);
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700715
716#ifdef CONFIG_SMP
717 dmi_check_system(sw_any_bug_dmi_table);
Fabio Baltieri2624f902013-01-31 09:44:40 +0000718 if (bios_with_sw_any_bug && !policy_is_shared(policy)) {
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700719 policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
Bartosz Golaszewski3280c3c2015-05-26 15:11:33 +0200720 cpumask_copy(policy->cpus, topology_core_cpumask(cpu));
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700721 }
Andre Przywaraacd31622012-09-04 08:28:03 +0000722
723 if (check_amd_hwpstate_cpu(cpu) && !acpi_pstate_strict) {
724 cpumask_clear(policy->cpus);
725 cpumask_set_cpu(cpu, policy->cpus);
Bartosz Golaszewski3280c3c2015-05-26 15:11:33 +0200726 cpumask_copy(data->freqdomain_cpus,
727 topology_sibling_cpumask(cpu));
Andre Przywaraacd31622012-09-04 08:28:03 +0000728 policy->shared_type = CPUFREQ_SHARED_TYPE_HW;
Joe Perches1c5864e2016-04-05 13:28:25 -0700729 pr_info_once("overriding BIOS provided _PSD data\n");
Andre Przywaraacd31622012-09-04 08:28:03 +0000730 }
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700731#endif
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 /* capability check */
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500734 if (perf->state_count <= 1) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200735 pr_debug("No P-States\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 result = -ENODEV;
737 goto err_unreg;
738 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500739
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700740 if (perf->control_register.space_id != perf->status_register.space_id) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 result = -ENODEV;
742 goto err_unreg;
743 }
744
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700745 switch (perf->control_register.space_id) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700746 case ACPI_ADR_SPACE_SYSTEM_IO:
Matthew Garrettc40a4512013-01-20 10:24:26 +0000747 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
748 boot_cpu_data.x86 == 0xf) {
749 pr_debug("AMD K8 systems must use native drivers.\n");
750 result = -ENODEV;
751 goto err_unreg;
752 }
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200753 pr_debug("SYSTEM IO addr space\n");
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700754 data->cpu_feature = SYSTEM_IO_CAPABLE;
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100755 data->cpu_freq_read = cpu_freq_read_io;
756 data->cpu_freq_write = cpu_freq_write_io;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700757 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700758 case ACPI_ADR_SPACE_FIXED_HARDWARE:
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200759 pr_debug("HARDWARE addr space\n");
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000760 if (check_est_cpu(cpu)) {
761 data->cpu_feature = SYSTEM_INTEL_MSR_CAPABLE;
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100762 data->cpu_freq_read = cpu_freq_read_intel;
763 data->cpu_freq_write = cpu_freq_write_intel;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000764 break;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700765 }
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000766 if (check_amd_hwpstate_cpu(cpu)) {
767 data->cpu_feature = SYSTEM_AMD_MSR_CAPABLE;
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100768 data->cpu_freq_read = cpu_freq_read_amd;
769 data->cpu_freq_write = cpu_freq_write_amd;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000770 break;
771 }
772 result = -ENODEV;
773 goto err_unreg;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700774 default:
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200775 pr_debug("Unknown addr space %d\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700776 (u32) (perf->control_register.space_id));
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700777 result = -ENODEV;
778 goto err_unreg;
779 }
780
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530781 freq_table = kzalloc(sizeof(*freq_table) *
Dave Jones95dd7222006-10-18 00:41:48 -0400782 (perf->state_count+1), GFP_KERNEL);
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530783 if (!freq_table) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 result = -ENOMEM;
785 goto err_unreg;
786 }
787
788 /* detect transition latency */
789 policy->cpuinfo.transition_latency = 0;
Dave Jones3a58df32009-01-17 22:36:14 -0500790 for (i = 0; i < perf->state_count; i++) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700791 if ((perf->states[i].transition_latency * 1000) >
792 policy->cpuinfo.transition_latency)
793 policy->cpuinfo.transition_latency =
794 perf->states[i].transition_latency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700797 /* Check for high latency (>20uS) from buggy BIOSes, like on T42 */
798 if (perf->control_register.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE &&
799 policy->cpuinfo.transition_latency > 20 * 1000) {
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700800 policy->cpuinfo.transition_latency = 20 * 1000;
Joe Perchesb49c22a2016-04-05 13:28:24 -0700801 pr_info_once("P-state transition latency capped at 20 uS\n");
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700802 }
803
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 /* table init */
Dave Jones3a58df32009-01-17 22:36:14 -0500805 for (i = 0; i < perf->state_count; i++) {
806 if (i > 0 && perf->states[i].core_frequency >=
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530807 freq_table[valid_states-1].frequency / 1000)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700808 continue;
809
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530810 freq_table[valid_states].driver_data = i;
811 freq_table[valid_states].frequency =
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700812 perf->states[i].core_frequency * 1000;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700813 valid_states++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 }
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530815 freq_table[valid_states].frequency = CPUFREQ_TABLE_END;
Venkatesh Pallipadi8edc59d92006-12-19 12:58:55 -0800816 perf->state = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530818 result = cpufreq_table_validate_and_show(policy, freq_table);
Dave Jones95dd7222006-10-18 00:41:48 -0400819 if (result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 goto err_freqfree;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
Thomas Renningerd876dfb2009-04-17 16:22:08 +0200822 if (perf->states[0].core_frequency * 1000 != policy->cpuinfo.max_freq)
Joe Perchesb49c22a2016-04-05 13:28:24 -0700823 pr_warn(FW_WARN "P-state 0 is not max freq\n");
Thomas Renningerd876dfb2009-04-17 16:22:08 +0200824
Mattia Dongilia507ac42006-12-15 19:52:45 +0100825 switch (perf->control_register.space_id) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700826 case ACPI_ADR_SPACE_SYSTEM_IO:
Viresh Kumar1bab64d2013-10-16 23:58:10 +0200827 /*
828 * The core will not set policy->cur, because
829 * cpufreq_driver->get is NULL, so we need to set it here.
830 * However, we have to guess it, because the current speed is
831 * unknown and not detectable via IO ports.
832 */
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700833 policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);
834 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700835 case ACPI_ADR_SPACE_FIXED_HARDWARE:
Venkatesh Pallipadi7650b282006-10-03 12:36:30 -0700836 acpi_cpufreq_driver.get = get_cur_freq_on_cpu;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700837 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700838 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700839 break;
840 }
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 /* notify BIOS that we exist */
843 acpi_processor_notify_smm(THIS_MODULE);
844
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200845 pr_debug("CPU%u - ACPI performance management activated.\n", cpu);
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500846 for (i = 0; i < perf->state_count; i++)
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200847 pr_debug(" %cP%d: %d MHz, %d mW, %d uS\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700848 (i == perf->state ? '*' : ' '), i,
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500849 (u32) perf->states[i].core_frequency,
850 (u32) perf->states[i].power,
851 (u32) perf->states[i].transition_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Dominik Brodowski4b31e772005-05-18 13:49:00 -0400853 /*
854 * the first call to ->target() should result in us actually
855 * writing something to the appropriate registers.
856 */
857 data->resume = 1;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700858
Rafael J. Wysockib7898fd2016-03-30 03:47:49 +0200859 policy->fast_switch_possible = !acpi_pstate_strict &&
860 !(policy_is_shared(policy) && policy->shared_type != CPUFREQ_SHARED_TYPE_ANY);
861
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700862 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
Dave Jones95dd7222006-10-18 00:41:48 -0400864err_freqfree:
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530865 kfree(freq_table);
Dave Jones95dd7222006-10-18 00:41:48 -0400866err_unreg:
Rafael J. Wysockib2f8dc42015-07-22 22:11:16 +0200867 acpi_processor_unregister_performance(cpu);
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800868err_free_mask:
869 free_cpumask_var(data->freqdomain_cpus);
Dave Jones95dd7222006-10-18 00:41:48 -0400870err_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 kfree(data);
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800872 policy->driver_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700874 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875}
876
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700877static int acpi_cpufreq_cpu_exit(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800879 struct acpi_cpufreq_data *data = policy->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200881 pr_debug("acpi_cpufreq_cpu_exit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
Viresh Kumar9b55f552016-04-07 14:06:58 +0530883 policy->fast_switch_possible = false;
884 policy->driver_data = NULL;
885 acpi_processor_unregister_performance(data->acpi_perf_cpu);
886 free_cpumask_var(data->freqdomain_cpus);
Viresh Kumar8cee1ee2016-04-07 14:06:57 +0530887 kfree(policy->freq_table);
Viresh Kumar9b55f552016-04-07 14:06:58 +0530888 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700890 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891}
892
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700893static int acpi_cpufreq_resume(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800895 struct acpi_cpufreq_data *data = policy->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200897 pr_debug("acpi_cpufreq_resume\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
899 data->resume = 1;
900
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700901 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902}
903
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700904static struct freq_attr *acpi_cpufreq_attr[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 &cpufreq_freq_attr_scaling_available_freqs,
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800906 &freqdomain_cpus,
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200907#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
908 &cpb,
909#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 NULL,
911};
912
913static struct cpufreq_driver acpi_cpufreq_driver = {
Viresh Kumardb9be212013-10-03 20:27:56 +0530914 .verify = cpufreq_generic_frequency_table_verify,
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530915 .target_index = acpi_cpufreq_target,
Rafael J. Wysockib7898fd2016-03-30 03:47:49 +0200916 .fast_switch = acpi_cpufreq_fast_switch,
Thomas Renningere2f74f32009-11-19 12:31:01 +0100917 .bios_limit = acpi_processor_get_bios_limit,
918 .init = acpi_cpufreq_cpu_init,
919 .exit = acpi_cpufreq_cpu_exit,
920 .resume = acpi_cpufreq_resume,
921 .name = "acpi-cpufreq",
Thomas Renningere2f74f32009-11-19 12:31:01 +0100922 .attr = acpi_cpufreq_attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923};
924
Andre Przywara615b7302012-09-04 08:28:07 +0000925static void __init acpi_cpufreq_boost_init(void)
926{
927 if (boot_cpu_has(X86_FEATURE_CPB) || boot_cpu_has(X86_FEATURE_IDA)) {
928 msrs = msrs_alloc();
929
930 if (!msrs)
931 return;
932
Rafael J. Wysocki7a6c79f2015-12-27 00:27:38 +0100933 acpi_cpufreq_driver.set_boost = set_boost;
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100934 acpi_cpufreq_driver.boost_enabled = boost_state(0);
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530935
936 cpu_notifier_register_begin();
Andre Przywara615b7302012-09-04 08:28:07 +0000937
938 /* Force all MSRs to the same value */
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100939 boost_set_msrs(acpi_cpufreq_driver.boost_enabled,
940 cpu_online_mask);
Andre Przywara615b7302012-09-04 08:28:07 +0000941
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530942 __register_cpu_notifier(&boost_nb);
Andre Przywara615b7302012-09-04 08:28:07 +0000943
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530944 cpu_notifier_register_done();
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100945 }
Andre Przywara615b7302012-09-04 08:28:07 +0000946}
947
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500948static void acpi_cpufreq_boost_exit(void)
Andre Przywara615b7302012-09-04 08:28:07 +0000949{
Andre Przywara615b7302012-09-04 08:28:07 +0000950 if (msrs) {
951 unregister_cpu_notifier(&boost_nb);
952
953 msrs_free(msrs);
954 msrs = NULL;
955 }
956}
957
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700958static int __init acpi_cpufreq_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959{
Fenghua Yu50109292007-08-07 18:40:30 -0400960 int ret;
961
Rafael J. Wysocki75c07582013-10-25 16:22:47 +0200962 if (acpi_disabled)
963 return -ENODEV;
964
Yinghai Lu8a61e122013-09-20 10:43:56 -0700965 /* don't keep reloading if cpufreq_driver exists */
966 if (cpufreq_get_current_driver())
Rafael J. Wysocki75c07582013-10-25 16:22:47 +0200967 return -EEXIST;
Yinghai Luee297532008-09-24 19:04:31 -0700968
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200969 pr_debug("acpi_cpufreq_init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970
Fenghua Yu50109292007-08-07 18:40:30 -0400971 ret = acpi_cpufreq_early_init();
972 if (ret)
973 return ret;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500974
Andre Przywara11269ff2012-09-04 08:28:08 +0000975#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
976 /* this is a sysfs file with a strange name and an even stranger
977 * semantic - per CPU instantiation, but system global effect.
978 * Lets enable it only on AMD CPUs for compatibility reasons and
979 * only if configured. This is considered legacy code, which
980 * will probably be removed at some point in the future.
981 */
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200982 if (!check_amd_hwpstate_cpu(0)) {
983 struct freq_attr **attr;
Andre Przywara11269ff2012-09-04 08:28:08 +0000984
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200985 pr_debug("CPB unsupported, do not expose it\n");
Andre Przywara11269ff2012-09-04 08:28:08 +0000986
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200987 for (attr = acpi_cpufreq_attr; *attr; attr++)
988 if (*attr == &cpb) {
989 *attr = NULL;
990 break;
991 }
Andre Przywara11269ff2012-09-04 08:28:08 +0000992 }
993#endif
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100994 acpi_cpufreq_boost_init();
Andre Przywara11269ff2012-09-04 08:28:08 +0000995
Akinobu Mita847aef62008-07-14 11:59:44 +0900996 ret = cpufreq_register_driver(&acpi_cpufreq_driver);
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500997 if (ret) {
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800998 free_acpi_perf_data();
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500999 acpi_cpufreq_boost_exit();
1000 }
Akinobu Mita847aef62008-07-14 11:59:44 +09001001 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002}
1003
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -07001004static void __exit acpi_cpufreq_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005{
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001006 pr_debug("acpi_cpufreq_exit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
Andre Przywara615b7302012-09-04 08:28:07 +00001008 acpi_cpufreq_boost_exit();
1009
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 cpufreq_unregister_driver(&acpi_cpufreq_driver);
1011
Luming Yu50f4ddd2011-07-08 16:37:44 -04001012 free_acpi_perf_data();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013}
1014
Venkatesh Pallipadid395bf12005-08-25 15:59:00 -04001015module_param(acpi_pstate_strict, uint, 0644);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -07001016MODULE_PARM_DESC(acpi_pstate_strict,
Dave Jones95dd7222006-10-18 00:41:48 -04001017 "value 0 or non-zero. non-zero -> strict ACPI checks are "
1018 "performed during frequency changes.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
1020late_initcall(acpi_cpufreq_init);
1021module_exit(acpi_cpufreq_exit);
1022
Matthew Garrettefa17192013-01-22 22:33:46 +01001023static const struct x86_cpu_id acpi_cpufreq_ids[] = {
1024 X86_FEATURE_MATCH(X86_FEATURE_ACPI),
1025 X86_FEATURE_MATCH(X86_FEATURE_HW_PSTATE),
1026 {}
1027};
1028MODULE_DEVICE_TABLE(x86cpu, acpi_cpufreq_ids);
1029
Rafael J. Wysockic655aff2013-06-07 13:13:31 +02001030static const struct acpi_device_id processor_device_ids[] = {
1031 {ACPI_PROCESSOR_OBJECT_HID, },
1032 {ACPI_PROCESSOR_DEVICE_HID, },
1033 {},
1034};
1035MODULE_DEVICE_TABLE(acpi, processor_device_ids);
1036
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037MODULE_ALIAS("acpi");