blob: 59a7b380fbe28fcc242e3aa641ff1eac1a09ebcb [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/kernel.h>
29#include <linux/module.h>
30#include <linux/init.h>
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -070031#include <linux/smp.h>
32#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/cpufreq.h>
Venkatesh Pallipadid395bf12005-08-25 15:59:00 -040034#include <linux/compiler.h>
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -070035#include <linux/dmi.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090036#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38#include <linux/acpi.h>
Dave Jones3a58df32009-01-17 22:36:14 -050039#include <linux/io.h>
40#include <linux/delay.h>
41#include <linux/uaccess.h>
42
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <acpi/processor.h>
44
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -070045#include <asm/msr.h>
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -070046#include <asm/processor.h>
47#include <asm/cpufeature.h>
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -070048
Linus Torvalds1da177e2005-04-16 15:20:36 -070049MODULE_AUTHOR("Paul Diefenbaugh, Dominik Brodowski");
50MODULE_DESCRIPTION("ACPI Processor P-States Driver");
51MODULE_LICENSE("GPL");
52
Andre Przywaraacd31622012-09-04 08:28:03 +000053#define PFX "acpi-cpufreq: "
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 struct cpufreq_frequency_table *freq_table;
69 unsigned int resume;
70 unsigned int cpu_feature;
Pan Xinhui8cfcfd32015-07-10 14:36:20 +080071 unsigned int acpi_perf_cpu;
Lan Tianyuf4fd3792013-06-27 15:08:54 +080072 cpumask_var_t freqdomain_cpus;
Rafael J. Wysockied757a22016-03-02 03:05:22 +010073 void (*cpu_freq_write)(struct acpi_pct_register *reg, u32 val);
74 u32 (*cpu_freq_read)(struct acpi_pct_register *reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075};
76
Fenghua Yu50109292007-08-07 18:40:30 -040077/* acpi_perf_data is a pointer to percpu data. */
Namhyung Kim3f6c4df2010-08-13 23:00:11 +090078static struct acpi_processor_performance __percpu *acpi_perf_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Rafael J. Wysocki34276162015-07-22 22:11:56 +020080static inline struct acpi_processor_performance *to_perf_data(struct acpi_cpufreq_data *data)
81{
82 return per_cpu_ptr(acpi_perf_data, data->acpi_perf_cpu);
83}
84
Linus Torvalds1da177e2005-04-16 15:20:36 -070085static struct cpufreq_driver acpi_cpufreq_driver;
86
Venkatesh Pallipadid395bf12005-08-25 15:59:00 -040087static unsigned int acpi_pstate_strict;
Andre Przywara615b7302012-09-04 08:28:07 +000088static struct msr __percpu *msrs;
89
90static bool boost_state(unsigned int cpu)
91{
92 u32 lo, hi;
93 u64 msr;
94
95 switch (boot_cpu_data.x86_vendor) {
96 case X86_VENDOR_INTEL:
97 rdmsr_on_cpu(cpu, MSR_IA32_MISC_ENABLE, &lo, &hi);
98 msr = lo | ((u64)hi << 32);
99 return !(msr & MSR_IA32_MISC_ENABLE_TURBO_DISABLE);
100 case X86_VENDOR_AMD:
101 rdmsr_on_cpu(cpu, MSR_K7_HWCR, &lo, &hi);
102 msr = lo | ((u64)hi << 32);
103 return !(msr & MSR_K7_HWCR_CPB_DIS);
104 }
105 return false;
106}
107
108static void boost_set_msrs(bool enable, const struct cpumask *cpumask)
109{
110 u32 cpu;
111 u32 msr_addr;
112 u64 msr_mask;
113
114 switch (boot_cpu_data.x86_vendor) {
115 case X86_VENDOR_INTEL:
116 msr_addr = MSR_IA32_MISC_ENABLE;
117 msr_mask = MSR_IA32_MISC_ENABLE_TURBO_DISABLE;
118 break;
119 case X86_VENDOR_AMD:
120 msr_addr = MSR_K7_HWCR;
121 msr_mask = MSR_K7_HWCR_CPB_DIS;
122 break;
123 default:
124 return;
125 }
126
127 rdmsr_on_cpus(cpumask, msr_addr, msrs);
128
129 for_each_cpu(cpu, cpumask) {
130 struct msr *reg = per_cpu_ptr(msrs, cpu);
131 if (enable)
132 reg->q &= ~msr_mask;
133 else
134 reg->q |= msr_mask;
135 }
136
137 wrmsr_on_cpus(cpumask, msr_addr, msrs);
138}
139
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100140static int set_boost(int val)
Andre Przywara615b7302012-09-04 08:28:07 +0000141{
Andre Przywara615b7302012-09-04 08:28:07 +0000142 get_online_cpus();
Andre Przywara615b7302012-09-04 08:28:07 +0000143 boost_set_msrs(val, cpu_online_mask);
Andre Przywara615b7302012-09-04 08:28:07 +0000144 put_online_cpus();
Andre Przywara615b7302012-09-04 08:28:07 +0000145 pr_debug("Core Boosting %sabled.\n", val ? "en" : "dis");
146
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100147 return 0;
Andre Przywara615b7302012-09-04 08:28:07 +0000148}
149
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800150static ssize_t show_freqdomain_cpus(struct cpufreq_policy *policy, char *buf)
151{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800152 struct acpi_cpufreq_data *data = policy->driver_data;
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800153
Srinivas Pandruvadae2530362015-10-07 13:50:43 -0700154 if (unlikely(!data))
155 return -ENODEV;
156
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800157 return cpufreq_show_cpus(data->freqdomain_cpus, buf);
158}
159
160cpufreq_freq_attr_ro(freqdomain_cpus);
161
Andre Przywara11269ff2012-09-04 08:28:08 +0000162#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100163static ssize_t store_cpb(struct cpufreq_policy *policy, const char *buf,
164 size_t count)
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100165{
166 int ret;
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100167 unsigned int val = 0;
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100168
Rafael J. Wysocki7a6c79f2015-12-27 00:27:38 +0100169 if (!acpi_cpufreq_driver.set_boost)
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100170 return -EINVAL;
171
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100172 ret = kstrtouint(buf, 10, &val);
173 if (ret || val > 1)
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100174 return -EINVAL;
175
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100176 set_boost(val);
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100177
178 return count;
179}
180
Andre Przywara11269ff2012-09-04 08:28:08 +0000181static ssize_t show_cpb(struct cpufreq_policy *policy, char *buf)
182{
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100183 return sprintf(buf, "%u\n", acpi_cpufreq_driver.boost_enabled);
Andre Przywara11269ff2012-09-04 08:28:08 +0000184}
185
Lan Tianyu59027d32013-08-13 10:05:53 +0800186cpufreq_freq_attr_rw(cpb);
Andre Przywara11269ff2012-09-04 08:28:08 +0000187#endif
188
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700189static int check_est_cpu(unsigned int cpuid)
190{
Mike Travis92cb7612007-10-19 20:35:04 +0200191 struct cpuinfo_x86 *cpu = &cpu_data(cpuid);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700192
Harald Welte0de51082009-06-08 18:27:54 +0800193 return cpu_has(cpu, X86_FEATURE_EST);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700194}
195
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000196static int check_amd_hwpstate_cpu(unsigned int cpuid)
197{
198 struct cpuinfo_x86 *cpu = &cpu_data(cpuid);
199
200 return cpu_has(cpu, X86_FEATURE_HW_PSTATE);
201}
202
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700203static unsigned extract_io(u32 value, struct acpi_cpufreq_data *data)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700204{
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)
212 return data->freq_table[i].frequency;
213 }
214 return 0;
215}
216
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700217static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
218{
Stratos Karafotis041526f2014-04-25 23:15:38 +0300219 struct cpufreq_frequency_table *pos;
Venkatesh Pallipadia6f6e6e62006-10-03 12:37:42 -0700220 struct acpi_processor_performance *perf;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700221
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000222 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
223 msr &= AMD_MSR_RANGE;
224 else
225 msr &= INTEL_MSR_RANGE;
226
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200227 perf = to_perf_data(data);
Venkatesh Pallipadia6f6e6e62006-10-03 12:37:42 -0700228
Stratos Karafotis041526f2014-04-25 23:15:38 +0300229 cpufreq_for_each_entry(pos, data->freq_table)
230 if (msr == perf->states[pos->driver_data].status)
231 return pos->frequency;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700232 return data->freq_table[0].frequency;
233}
234
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700235static unsigned extract_freq(u32 val, struct acpi_cpufreq_data *data)
236{
237 switch (data->cpu_feature) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700238 case SYSTEM_INTEL_MSR_CAPABLE:
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000239 case SYSTEM_AMD_MSR_CAPABLE:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700240 return extract_msr(val, data);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700241 case SYSTEM_IO_CAPABLE:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700242 return extract_io(val, data);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700243 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700244 return 0;
245 }
246}
247
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100248u32 cpu_freq_read_intel(struct acpi_pct_register *not_used)
249{
250 u32 val, dummy;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700251
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100252 rdmsr(MSR_IA32_PERF_CTL, val, dummy);
253 return val;
254}
255
256void cpu_freq_write_intel(struct acpi_pct_register *not_used, u32 val)
257{
258 u32 lo, hi;
259
260 rdmsr(MSR_IA32_PERF_CTL, lo, hi);
261 lo = (lo & ~INTEL_MSR_RANGE) | (val & INTEL_MSR_RANGE);
262 wrmsr(MSR_IA32_PERF_CTL, lo, hi);
263}
264
265u32 cpu_freq_read_amd(struct acpi_pct_register *not_used)
266{
267 u32 val, dummy;
268
269 rdmsr(MSR_AMD_PERF_CTL, val, dummy);
270 return val;
271}
272
273void cpu_freq_write_amd(struct acpi_pct_register *not_used, u32 val)
274{
275 wrmsr(MSR_AMD_PERF_CTL, val, 0);
276}
277
278u32 cpu_freq_read_io(struct acpi_pct_register *reg)
279{
280 u32 val;
281
282 acpi_os_read_port(reg->address, &val, reg->bit_width);
283 return val;
284}
285
286void cpu_freq_write_io(struct acpi_pct_register *reg, u32 val)
287{
288 acpi_os_write_port(reg->address, val, reg->bit_width);
289}
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700290
291struct drv_cmd {
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100292 struct acpi_pct_register *reg;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700293 u32 val;
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100294 union {
295 void (*write)(struct acpi_pct_register *reg, u32 val);
296 u32 (*read)(struct acpi_pct_register *reg);
297 } func;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700298};
299
Andrew Morton01599fc2009-04-13 10:27:49 -0700300/* Called via smp_call_function_single(), on the target CPU */
301static void do_drv_read(void *_cmd)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700302{
Mike Travis72859082009-01-16 15:31:15 -0800303 struct drv_cmd *cmd = _cmd;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700304
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100305 cmd->val = cmd->func.read(cmd->reg);
306}
307
308static u32 drv_read(struct acpi_cpufreq_data *data, const struct cpumask *mask)
309{
310 struct acpi_processor_performance *perf = to_perf_data(data);
311 struct drv_cmd cmd = {
312 .reg = &perf->control_register,
313 .func.read = data->cpu_freq_read,
314 };
315 int err;
316
317 err = smp_call_function_any(mask, do_drv_read, &cmd, 1);
318 WARN_ON_ONCE(err); /* smp_call_function_any() was buggy? */
319 return cmd.val;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700320}
321
Andrew Morton01599fc2009-04-13 10:27:49 -0700322/* Called via smp_call_function_many(), on the target CPUs */
323static void do_drv_write(void *_cmd)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700324{
Mike Travis72859082009-01-16 15:31:15 -0800325 struct drv_cmd *cmd = _cmd;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700326
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100327 cmd->func.write(cmd->reg, cmd->val);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700328}
329
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100330static void drv_write(struct acpi_cpufreq_data *data,
331 const struct cpumask *mask, u32 val)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700332{
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100333 struct acpi_processor_performance *perf = to_perf_data(data);
334 struct drv_cmd cmd = {
335 .reg = &perf->control_register,
336 .val = val,
337 .func.write = data->cpu_freq_write,
338 };
Linus Torvaldsea34f432009-04-15 08:05:13 -0700339 int this_cpu;
340
341 this_cpu = get_cpu();
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100342 if (cpumask_test_cpu(this_cpu, mask))
343 do_drv_write(&cmd);
344
345 smp_call_function_many(mask, do_drv_write, &cmd, 1);
Linus Torvaldsea34f432009-04-15 08:05:13 -0700346 put_cpu();
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700347}
348
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100349static u32 get_cur_val(const struct cpumask *mask, struct acpi_cpufreq_data *data)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700350{
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100351 u32 val;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700352
Mike Travis4d8bb532009-01-04 05:18:08 -0800353 if (unlikely(cpumask_empty(mask)))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700354 return 0;
355
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100356 val = drv_read(data, mask);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700357
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100358 pr_debug("get_cur_val = %u\n", val);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700359
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100360 return val;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700361}
362
363static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
364{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800365 struct acpi_cpufreq_data *data;
366 struct cpufreq_policy *policy;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700367 unsigned int freq;
Venkatesh Pallipadie56a7272008-04-28 15:13:43 -0400368 unsigned int cached_freq;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700369
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200370 pr_debug("get_cur_freq_on_cpu (%d)\n", cpu);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700371
Rafael J. Wysocki1f0bd442015-09-16 02:17:49 +0200372 policy = cpufreq_cpu_get_raw(cpu);
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800373 if (unlikely(!policy))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700374 return 0;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800375
376 data = policy->driver_data;
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200377 if (unlikely(!data || !data->freq_table))
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800378 return 0;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700379
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200380 cached_freq = data->freq_table[to_perf_data(data)->state].frequency;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800381 freq = extract_freq(get_cur_val(cpumask_of(cpu), data), data);
Venkatesh Pallipadie56a7272008-04-28 15:13:43 -0400382 if (freq != cached_freq) {
383 /*
384 * The dreaded BIOS frequency change behind our back.
385 * Force set the frequency on next target call.
386 */
387 data->resume = 1;
388 }
389
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200390 pr_debug("cur freq = %u\n", freq);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700391
392 return freq;
393}
394
Mike Travis72859082009-01-16 15:31:15 -0800395static unsigned int check_freqs(const struct cpumask *mask, unsigned int freq,
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700396 struct acpi_cpufreq_data *data)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700397{
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700398 unsigned int cur_freq;
399 unsigned int i;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700400
Dave Jones3a58df32009-01-17 22:36:14 -0500401 for (i = 0; i < 100; i++) {
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800402 cur_freq = extract_freq(get_cur_val(mask, data), data);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700403 if (cur_freq == freq)
404 return 1;
405 udelay(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 }
407 return 0;
408}
409
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700410static int acpi_cpufreq_target(struct cpufreq_policy *policy,
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530411 unsigned int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800413 struct acpi_cpufreq_data *data = policy->driver_data;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700414 struct acpi_processor_performance *perf;
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100415 const struct cpumask *mask;
Venkatesh Pallipadi8edc59d92006-12-19 12:58:55 -0800416 unsigned int next_perf_state = 0; /* Index into perf table */
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700417 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200419 if (unlikely(data == NULL || data->freq_table == NULL)) {
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700420 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 }
422
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200423 perf = to_perf_data(data);
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530424 next_perf_state = data->freq_table[index].driver_data;
Venkatesh Pallipadi7650b282006-10-03 12:36:30 -0700425 if (perf->state == next_perf_state) {
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700426 if (unlikely(data->resume)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200427 pr_debug("Called after resume, resetting to P%d\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700428 next_perf_state);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700429 data->resume = 0;
430 } else {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200431 pr_debug("Already at target state (P%d)\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700432 next_perf_state);
Rafael J. Wysocki9a909a12016-02-26 00:03:58 +0100433 return 0;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700434 }
435 }
436
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100437 /*
438 * The core won't allow CPUs to go away until the governor has been
439 * stopped, so we can rely on the stability of policy->cpus.
440 */
441 mask = policy->shared_type == CPUFREQ_SHARED_TYPE_ANY ?
442 cpumask_of(policy->cpu) : policy->cpus;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700443
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100444 drv_write(data, mask, perf->states[next_perf_state].control);
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500445
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700446 if (acpi_pstate_strict) {
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100447 if (!check_freqs(mask, data->freq_table[index].frequency,
Viresh Kumard4019f02013-08-14 19:38:24 +0530448 data)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200449 pr_debug("acpi_cpufreq_target failed (%d)\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700450 policy->cpu);
Mike Travis4d8bb532009-01-04 05:18:08 -0800451 result = -EAGAIN;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500452 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500453 }
454
Viresh Kumare15d8302013-06-19 14:22:55 +0530455 if (!result)
456 perf->state = next_perf_state;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500457
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700458 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459}
460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461static unsigned long
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700462acpi_cpufreq_guess_freq(struct acpi_cpufreq_data *data, unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463{
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200464 struct acpi_processor_performance *perf;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500465
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200466 perf = to_perf_data(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (cpu_khz) {
468 /* search the closest match to cpu_khz */
469 unsigned int i;
470 unsigned long freq;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500471 unsigned long freqn = perf->states[0].core_frequency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Dave Jones3a58df32009-01-17 22:36:14 -0500473 for (i = 0; i < (perf->state_count-1); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 freq = freqn;
Dave Jones95dd7222006-10-18 00:41:48 -0400475 freqn = perf->states[i+1].core_frequency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 if ((2 * cpu_khz) > (freqn + freq)) {
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500477 perf->state = i;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700478 return freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 }
480 }
Dave Jones95dd7222006-10-18 00:41:48 -0400481 perf->state = perf->state_count-1;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700482 return freqn;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500483 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 /* assume CPU is at P0... */
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500485 perf->state = 0;
486 return perf->states[0].core_frequency * 1000;
487 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488}
489
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800490static void free_acpi_perf_data(void)
491{
492 unsigned int i;
493
494 /* Freeing a NULL pointer is OK, and alloc_percpu zeroes. */
495 for_each_possible_cpu(i)
496 free_cpumask_var(per_cpu_ptr(acpi_perf_data, i)
497 ->shared_cpu_map);
498 free_percpu(acpi_perf_data);
499}
500
Andre Przywara615b7302012-09-04 08:28:07 +0000501static int boost_notify(struct notifier_block *nb, unsigned long action,
502 void *hcpu)
503{
504 unsigned cpu = (long)hcpu;
505 const struct cpumask *cpumask;
506
507 cpumask = get_cpu_mask(cpu);
508
509 /*
510 * Clear the boost-disable bit on the CPU_DOWN path so that
511 * this cpu cannot block the remaining ones from boosting. On
512 * the CPU_UP path we simply keep the boost-disable flag in
513 * sync with the current global state.
514 */
515
516 switch (action) {
517 case CPU_UP_PREPARE:
518 case CPU_UP_PREPARE_FROZEN:
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100519 boost_set_msrs(acpi_cpufreq_driver.boost_enabled, cpumask);
Andre Przywara615b7302012-09-04 08:28:07 +0000520 break;
521
522 case CPU_DOWN_PREPARE:
523 case CPU_DOWN_PREPARE_FROZEN:
524 boost_set_msrs(1, cpumask);
525 break;
526
527 default:
528 break;
529 }
530
531 return NOTIFY_OK;
532}
533
534
535static struct notifier_block boost_nb = {
536 .notifier_call = boost_notify,
537};
538
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500539/*
540 * acpi_cpufreq_early_init - initialize ACPI P-States library
541 *
542 * Initialize the ACPI P-States library (drivers/acpi/processor_perflib.c)
543 * in order to determine correct frequency and voltage pairings. We can
544 * do _PDC and _PSD and find out the processor dependency for the
545 * actual init that will happen later...
546 */
Fenghua Yu50109292007-08-07 18:40:30 -0400547static int __init acpi_cpufreq_early_init(void)
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500548{
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800549 unsigned int i;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200550 pr_debug("acpi_cpufreq_early_init\n");
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500551
Fenghua Yu50109292007-08-07 18:40:30 -0400552 acpi_perf_data = alloc_percpu(struct acpi_processor_performance);
553 if (!acpi_perf_data) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200554 pr_debug("Memory allocation error for acpi_perf_data.\n");
Fenghua Yu50109292007-08-07 18:40:30 -0400555 return -ENOMEM;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500556 }
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800557 for_each_possible_cpu(i) {
Yinghai Lueaa95842009-06-06 14:51:36 -0700558 if (!zalloc_cpumask_var_node(
Mike Travis80855f72008-12-31 18:08:47 -0800559 &per_cpu_ptr(acpi_perf_data, i)->shared_cpu_map,
560 GFP_KERNEL, cpu_to_node(i))) {
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800561
562 /* Freeing a NULL pointer is OK: alloc_percpu zeroes. */
563 free_acpi_perf_data();
564 return -ENOMEM;
565 }
566 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500567
568 /* Do initialization in ACPI core */
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700569 acpi_processor_preregister_performance(acpi_perf_data);
570 return 0;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500571}
572
Dave Jones95625b82006-10-21 01:37:39 -0400573#ifdef CONFIG_SMP
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700574/*
575 * Some BIOSes do SW_ANY coordination internally, either set it up in hw
576 * or do it in BIOS firmware and won't inform about it to OS. If not
577 * detected, this has a side effect of making CPU run at a different speed
578 * than OS intended it to run at. Detect it and handle it cleanly.
579 */
580static int bios_with_sw_any_bug;
581
Jeff Garzik18552562007-10-03 15:15:40 -0400582static int sw_any_bug_found(const struct dmi_system_id *d)
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700583{
584 bios_with_sw_any_bug = 1;
585 return 0;
586}
587
Jeff Garzik18552562007-10-03 15:15:40 -0400588static const struct dmi_system_id sw_any_bug_dmi_table[] = {
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700589 {
590 .callback = sw_any_bug_found,
591 .ident = "Supermicro Server X6DLP",
592 .matches = {
593 DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
594 DMI_MATCH(DMI_BIOS_VERSION, "080010"),
595 DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"),
596 },
597 },
598 { }
599};
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400600
601static int acpi_cpufreq_blacklist(struct cpuinfo_x86 *c)
602{
John Villalovos293afe42009-09-25 13:30:08 -0400603 /* Intel Xeon Processor 7100 Series Specification Update
604 * http://www.intel.com/Assets/PDF/specupdate/314554.pdf
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400605 * AL30: A Machine Check Exception (MCE) Occurring during an
606 * Enhanced Intel SpeedStep Technology Ratio Change May Cause
John Villalovos293afe42009-09-25 13:30:08 -0400607 * Both Processor Cores to Lock Up. */
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400608 if (c->x86_vendor == X86_VENDOR_INTEL) {
609 if ((c->x86 == 15) &&
610 (c->x86_model == 6) &&
John Villalovos293afe42009-09-25 13:30:08 -0400611 (c->x86_mask == 8)) {
612 printk(KERN_INFO "acpi-cpufreq: Intel(R) "
613 "Xeon(R) 7100 Errata AL30, processors may "
614 "lock up on frequency changes: disabling "
615 "acpi-cpufreq.\n");
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400616 return -ENODEV;
John Villalovos293afe42009-09-25 13:30:08 -0400617 }
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400618 }
619 return 0;
620}
Dave Jones95625b82006-10-21 01:37:39 -0400621#endif
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700622
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700623static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624{
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700625 unsigned int i;
626 unsigned int valid_states = 0;
627 unsigned int cpu = policy->cpu;
628 struct acpi_cpufreq_data *data;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700629 unsigned int result = 0;
Mike Travis92cb7612007-10-19 20:35:04 +0200630 struct cpuinfo_x86 *c = &cpu_data(policy->cpu);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700631 struct acpi_processor_performance *perf;
John Villalovos293afe42009-09-25 13:30:08 -0400632#ifdef CONFIG_SMP
633 static int blacklisted;
634#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200636 pr_debug("acpi_cpufreq_cpu_init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400638#ifdef CONFIG_SMP
John Villalovos293afe42009-09-25 13:30:08 -0400639 if (blacklisted)
640 return blacklisted;
641 blacklisted = acpi_cpufreq_blacklist(c);
642 if (blacklisted)
643 return blacklisted;
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400644#endif
645
Viresh Kumard5b73cd2013-08-06 22:53:06 +0530646 data = kzalloc(sizeof(*data), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (!data)
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700648 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800650 if (!zalloc_cpumask_var(&data->freqdomain_cpus, GFP_KERNEL)) {
651 result = -ENOMEM;
652 goto err_free;
653 }
654
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200655 perf = per_cpu_ptr(acpi_perf_data, cpu);
Pan Xinhui8cfcfd32015-07-10 14:36:20 +0800656 data->acpi_perf_cpu = cpu;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800657 policy->driver_data = data;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700658
Dave Jones95dd7222006-10-18 00:41:48 -0400659 if (cpu_has(c, X86_FEATURE_CONSTANT_TSC))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700660 acpi_cpufreq_driver.flags |= CPUFREQ_CONST_LOOPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200662 result = acpi_processor_register_performance(perf, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 if (result)
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800664 goto err_free_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500666 policy->shared_type = perf->shared_type;
Dave Jones95dd7222006-10-18 00:41:48 -0400667
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400668 /*
Dave Jones95dd7222006-10-18 00:41:48 -0400669 * Will let policy->cpus know about dependency only when software
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400670 * coordination is required.
671 */
672 if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700673 policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
Rusty Russell835481d2009-01-04 05:18:06 -0800674 cpumask_copy(policy->cpus, perf->shared_cpu_map);
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700675 }
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800676 cpumask_copy(data->freqdomain_cpus, perf->shared_cpu_map);
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700677
678#ifdef CONFIG_SMP
679 dmi_check_system(sw_any_bug_dmi_table);
Fabio Baltieri2624f902013-01-31 09:44:40 +0000680 if (bios_with_sw_any_bug && !policy_is_shared(policy)) {
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700681 policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
Bartosz Golaszewski3280c3c2015-05-26 15:11:33 +0200682 cpumask_copy(policy->cpus, topology_core_cpumask(cpu));
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700683 }
Andre Przywaraacd31622012-09-04 08:28:03 +0000684
685 if (check_amd_hwpstate_cpu(cpu) && !acpi_pstate_strict) {
686 cpumask_clear(policy->cpus);
687 cpumask_set_cpu(cpu, policy->cpus);
Bartosz Golaszewski3280c3c2015-05-26 15:11:33 +0200688 cpumask_copy(data->freqdomain_cpus,
689 topology_sibling_cpumask(cpu));
Andre Przywaraacd31622012-09-04 08:28:03 +0000690 policy->shared_type = CPUFREQ_SHARED_TYPE_HW;
691 pr_info_once(PFX "overriding BIOS provided _PSD data\n");
692 }
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700693#endif
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500694
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 /* capability check */
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500696 if (perf->state_count <= 1) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200697 pr_debug("No P-States\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 result = -ENODEV;
699 goto err_unreg;
700 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500701
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700702 if (perf->control_register.space_id != perf->status_register.space_id) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 result = -ENODEV;
704 goto err_unreg;
705 }
706
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700707 switch (perf->control_register.space_id) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700708 case ACPI_ADR_SPACE_SYSTEM_IO:
Matthew Garrettc40a4512013-01-20 10:24:26 +0000709 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
710 boot_cpu_data.x86 == 0xf) {
711 pr_debug("AMD K8 systems must use native drivers.\n");
712 result = -ENODEV;
713 goto err_unreg;
714 }
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200715 pr_debug("SYSTEM IO addr space\n");
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700716 data->cpu_feature = SYSTEM_IO_CAPABLE;
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100717 data->cpu_freq_read = cpu_freq_read_io;
718 data->cpu_freq_write = cpu_freq_write_io;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700719 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700720 case ACPI_ADR_SPACE_FIXED_HARDWARE:
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200721 pr_debug("HARDWARE addr space\n");
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000722 if (check_est_cpu(cpu)) {
723 data->cpu_feature = SYSTEM_INTEL_MSR_CAPABLE;
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100724 data->cpu_freq_read = cpu_freq_read_intel;
725 data->cpu_freq_write = cpu_freq_write_intel;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000726 break;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700727 }
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000728 if (check_amd_hwpstate_cpu(cpu)) {
729 data->cpu_feature = SYSTEM_AMD_MSR_CAPABLE;
Rafael J. Wysockied757a22016-03-02 03:05:22 +0100730 data->cpu_freq_read = cpu_freq_read_amd;
731 data->cpu_freq_write = cpu_freq_write_amd;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000732 break;
733 }
734 result = -ENODEV;
735 goto err_unreg;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700736 default:
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200737 pr_debug("Unknown addr space %d\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700738 (u32) (perf->control_register.space_id));
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700739 result = -ENODEV;
740 goto err_unreg;
741 }
742
Viresh Kumar71508a12014-03-28 19:11:46 +0530743 data->freq_table = kzalloc(sizeof(*data->freq_table) *
Dave Jones95dd7222006-10-18 00:41:48 -0400744 (perf->state_count+1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 if (!data->freq_table) {
746 result = -ENOMEM;
747 goto err_unreg;
748 }
749
750 /* detect transition latency */
751 policy->cpuinfo.transition_latency = 0;
Dave Jones3a58df32009-01-17 22:36:14 -0500752 for (i = 0; i < perf->state_count; i++) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700753 if ((perf->states[i].transition_latency * 1000) >
754 policy->cpuinfo.transition_latency)
755 policy->cpuinfo.transition_latency =
756 perf->states[i].transition_latency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700759 /* Check for high latency (>20uS) from buggy BIOSes, like on T42 */
760 if (perf->control_register.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE &&
761 policy->cpuinfo.transition_latency > 20 * 1000) {
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700762 policy->cpuinfo.transition_latency = 20 * 1000;
Joe Perches61c8c672009-05-26 14:58:39 -0700763 printk_once(KERN_INFO
764 "P-state transition latency capped at 20 uS\n");
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700765 }
766
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 /* table init */
Dave Jones3a58df32009-01-17 22:36:14 -0500768 for (i = 0; i < perf->state_count; i++) {
769 if (i > 0 && perf->states[i].core_frequency >=
Zhang Rui3cdf5522007-06-13 21:24:02 -0400770 data->freq_table[valid_states-1].frequency / 1000)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700771 continue;
772
Viresh Kumar50701582013-03-30 16:25:15 +0530773 data->freq_table[valid_states].driver_data = i;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700774 data->freq_table[valid_states].frequency =
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700775 perf->states[i].core_frequency * 1000;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700776 valid_states++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 }
Venkatesh Pallipadi3d4a7ef2006-11-13 17:47:44 -0800778 data->freq_table[valid_states].frequency = CPUFREQ_TABLE_END;
Venkatesh Pallipadi8edc59d92006-12-19 12:58:55 -0800779 perf->state = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Viresh Kumar776b57b2013-09-16 18:56:07 +0530781 result = cpufreq_table_validate_and_show(policy, data->freq_table);
Dave Jones95dd7222006-10-18 00:41:48 -0400782 if (result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 goto err_freqfree;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
Thomas Renningerd876dfb2009-04-17 16:22:08 +0200785 if (perf->states[0].core_frequency * 1000 != policy->cpuinfo.max_freq)
786 printk(KERN_WARNING FW_WARN "P-state 0 is not max freq\n");
787
Mattia Dongilia507ac42006-12-15 19:52:45 +0100788 switch (perf->control_register.space_id) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700789 case ACPI_ADR_SPACE_SYSTEM_IO:
Viresh Kumar1bab64d2013-10-16 23:58:10 +0200790 /*
791 * The core will not set policy->cur, because
792 * cpufreq_driver->get is NULL, so we need to set it here.
793 * However, we have to guess it, because the current speed is
794 * unknown and not detectable via IO ports.
795 */
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700796 policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);
797 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700798 case ACPI_ADR_SPACE_FIXED_HARDWARE:
Venkatesh Pallipadi7650b282006-10-03 12:36:30 -0700799 acpi_cpufreq_driver.get = get_cur_freq_on_cpu;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700800 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700801 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700802 break;
803 }
804
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 /* notify BIOS that we exist */
806 acpi_processor_notify_smm(THIS_MODULE);
807
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200808 pr_debug("CPU%u - ACPI performance management activated.\n", cpu);
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500809 for (i = 0; i < perf->state_count; i++)
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200810 pr_debug(" %cP%d: %d MHz, %d mW, %d uS\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700811 (i == perf->state ? '*' : ' '), i,
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500812 (u32) perf->states[i].core_frequency,
813 (u32) perf->states[i].power,
814 (u32) perf->states[i].transition_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Dominik Brodowski4b31e772005-05-18 13:49:00 -0400816 /*
817 * the first call to ->target() should result in us actually
818 * writing something to the appropriate registers.
819 */
820 data->resume = 1;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700821
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700822 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
Dave Jones95dd7222006-10-18 00:41:48 -0400824err_freqfree:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 kfree(data->freq_table);
Dave Jones95dd7222006-10-18 00:41:48 -0400826err_unreg:
Rafael J. Wysockib2f8dc42015-07-22 22:11:16 +0200827 acpi_processor_unregister_performance(cpu);
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800828err_free_mask:
829 free_cpumask_var(data->freqdomain_cpus);
Dave Jones95dd7222006-10-18 00:41:48 -0400830err_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 kfree(data);
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800832 policy->driver_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700834 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835}
836
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700837static int acpi_cpufreq_cpu_exit(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800839 struct acpi_cpufreq_data *data = policy->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200841 pr_debug("acpi_cpufreq_cpu_exit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
843 if (data) {
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800844 policy->driver_data = NULL;
Rafael J. Wysockib2f8dc42015-07-22 22:11:16 +0200845 acpi_processor_unregister_performance(data->acpi_perf_cpu);
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800846 free_cpumask_var(data->freqdomain_cpus);
Zhang Ruidab5fff2010-10-12 09:09:37 +0800847 kfree(data->freq_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 kfree(data);
849 }
850
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700851 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852}
853
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700854static int acpi_cpufreq_resume(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800856 struct acpi_cpufreq_data *data = policy->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200858 pr_debug("acpi_cpufreq_resume\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
860 data->resume = 1;
861
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700862 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863}
864
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700865static struct freq_attr *acpi_cpufreq_attr[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 &cpufreq_freq_attr_scaling_available_freqs,
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800867 &freqdomain_cpus,
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200868#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
869 &cpb,
870#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 NULL,
872};
873
874static struct cpufreq_driver acpi_cpufreq_driver = {
Viresh Kumardb9be212013-10-03 20:27:56 +0530875 .verify = cpufreq_generic_frequency_table_verify,
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530876 .target_index = acpi_cpufreq_target,
Thomas Renningere2f74f32009-11-19 12:31:01 +0100877 .bios_limit = acpi_processor_get_bios_limit,
878 .init = acpi_cpufreq_cpu_init,
879 .exit = acpi_cpufreq_cpu_exit,
880 .resume = acpi_cpufreq_resume,
881 .name = "acpi-cpufreq",
Thomas Renningere2f74f32009-11-19 12:31:01 +0100882 .attr = acpi_cpufreq_attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883};
884
Andre Przywara615b7302012-09-04 08:28:07 +0000885static void __init acpi_cpufreq_boost_init(void)
886{
887 if (boot_cpu_has(X86_FEATURE_CPB) || boot_cpu_has(X86_FEATURE_IDA)) {
888 msrs = msrs_alloc();
889
890 if (!msrs)
891 return;
892
Rafael J. Wysocki7a6c79f2015-12-27 00:27:38 +0100893 acpi_cpufreq_driver.set_boost = set_boost;
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100894 acpi_cpufreq_driver.boost_enabled = boost_state(0);
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530895
896 cpu_notifier_register_begin();
Andre Przywara615b7302012-09-04 08:28:07 +0000897
898 /* Force all MSRs to the same value */
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100899 boost_set_msrs(acpi_cpufreq_driver.boost_enabled,
900 cpu_online_mask);
Andre Przywara615b7302012-09-04 08:28:07 +0000901
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530902 __register_cpu_notifier(&boost_nb);
Andre Przywara615b7302012-09-04 08:28:07 +0000903
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530904 cpu_notifier_register_done();
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100905 }
Andre Przywara615b7302012-09-04 08:28:07 +0000906}
907
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500908static void acpi_cpufreq_boost_exit(void)
Andre Przywara615b7302012-09-04 08:28:07 +0000909{
Andre Przywara615b7302012-09-04 08:28:07 +0000910 if (msrs) {
911 unregister_cpu_notifier(&boost_nb);
912
913 msrs_free(msrs);
914 msrs = NULL;
915 }
916}
917
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700918static int __init acpi_cpufreq_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919{
Fenghua Yu50109292007-08-07 18:40:30 -0400920 int ret;
921
Rafael J. Wysocki75c07582013-10-25 16:22:47 +0200922 if (acpi_disabled)
923 return -ENODEV;
924
Yinghai Lu8a61e122013-09-20 10:43:56 -0700925 /* don't keep reloading if cpufreq_driver exists */
926 if (cpufreq_get_current_driver())
Rafael J. Wysocki75c07582013-10-25 16:22:47 +0200927 return -EEXIST;
Yinghai Luee297532008-09-24 19:04:31 -0700928
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200929 pr_debug("acpi_cpufreq_init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930
Fenghua Yu50109292007-08-07 18:40:30 -0400931 ret = acpi_cpufreq_early_init();
932 if (ret)
933 return ret;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500934
Andre Przywara11269ff2012-09-04 08:28:08 +0000935#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
936 /* this is a sysfs file with a strange name and an even stranger
937 * semantic - per CPU instantiation, but system global effect.
938 * Lets enable it only on AMD CPUs for compatibility reasons and
939 * only if configured. This is considered legacy code, which
940 * will probably be removed at some point in the future.
941 */
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200942 if (!check_amd_hwpstate_cpu(0)) {
943 struct freq_attr **attr;
Andre Przywara11269ff2012-09-04 08:28:08 +0000944
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200945 pr_debug("CPB unsupported, do not expose it\n");
Andre Przywara11269ff2012-09-04 08:28:08 +0000946
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200947 for (attr = acpi_cpufreq_attr; *attr; attr++)
948 if (*attr == &cpb) {
949 *attr = NULL;
950 break;
951 }
Andre Przywara11269ff2012-09-04 08:28:08 +0000952 }
953#endif
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100954 acpi_cpufreq_boost_init();
Andre Przywara11269ff2012-09-04 08:28:08 +0000955
Akinobu Mita847aef62008-07-14 11:59:44 +0900956 ret = cpufreq_register_driver(&acpi_cpufreq_driver);
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500957 if (ret) {
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800958 free_acpi_perf_data();
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500959 acpi_cpufreq_boost_exit();
960 }
Akinobu Mita847aef62008-07-14 11:59:44 +0900961 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962}
963
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700964static void __exit acpi_cpufreq_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965{
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200966 pr_debug("acpi_cpufreq_exit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
Andre Przywara615b7302012-09-04 08:28:07 +0000968 acpi_cpufreq_boost_exit();
969
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 cpufreq_unregister_driver(&acpi_cpufreq_driver);
971
Luming Yu50f4ddd2011-07-08 16:37:44 -0400972 free_acpi_perf_data();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973}
974
Venkatesh Pallipadid395bf12005-08-25 15:59:00 -0400975module_param(acpi_pstate_strict, uint, 0644);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700976MODULE_PARM_DESC(acpi_pstate_strict,
Dave Jones95dd7222006-10-18 00:41:48 -0400977 "value 0 or non-zero. non-zero -> strict ACPI checks are "
978 "performed during frequency changes.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
980late_initcall(acpi_cpufreq_init);
981module_exit(acpi_cpufreq_exit);
982
Matthew Garrettefa17192013-01-22 22:33:46 +0100983static const struct x86_cpu_id acpi_cpufreq_ids[] = {
984 X86_FEATURE_MATCH(X86_FEATURE_ACPI),
985 X86_FEATURE_MATCH(X86_FEATURE_HW_PSTATE),
986 {}
987};
988MODULE_DEVICE_TABLE(x86cpu, acpi_cpufreq_ids);
989
Rafael J. Wysockic655aff2013-06-07 13:13:31 +0200990static const struct acpi_device_id processor_device_ids[] = {
991 {ACPI_PROCESSOR_OBJECT_HID, },
992 {ACPI_PROCESSOR_DEVICE_HID, },
993 {},
994};
995MODULE_DEVICE_TABLE(acpi, processor_device_ids);
996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997MODULE_ALIAS("acpi");