blob: 798277227de7f3a897a4ad79fcaabe787412fcfb [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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073};
74
Fenghua Yu50109292007-08-07 18:40:30 -040075/* acpi_perf_data is a pointer to percpu data. */
Namhyung Kim3f6c4df2010-08-13 23:00:11 +090076static struct acpi_processor_performance __percpu *acpi_perf_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Rafael J. Wysocki34276162015-07-22 22:11:56 +020078static inline struct acpi_processor_performance *to_perf_data(struct acpi_cpufreq_data *data)
79{
80 return per_cpu_ptr(acpi_perf_data, data->acpi_perf_cpu);
81}
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083static struct cpufreq_driver acpi_cpufreq_driver;
84
Venkatesh Pallipadid395bf12005-08-25 15:59:00 -040085static unsigned int acpi_pstate_strict;
Andre Przywara615b7302012-09-04 08:28:07 +000086static struct msr __percpu *msrs;
87
88static bool boost_state(unsigned int cpu)
89{
90 u32 lo, hi;
91 u64 msr;
92
93 switch (boot_cpu_data.x86_vendor) {
94 case X86_VENDOR_INTEL:
95 rdmsr_on_cpu(cpu, MSR_IA32_MISC_ENABLE, &lo, &hi);
96 msr = lo | ((u64)hi << 32);
97 return !(msr & MSR_IA32_MISC_ENABLE_TURBO_DISABLE);
98 case X86_VENDOR_AMD:
99 rdmsr_on_cpu(cpu, MSR_K7_HWCR, &lo, &hi);
100 msr = lo | ((u64)hi << 32);
101 return !(msr & MSR_K7_HWCR_CPB_DIS);
102 }
103 return false;
104}
105
106static void boost_set_msrs(bool enable, const struct cpumask *cpumask)
107{
108 u32 cpu;
109 u32 msr_addr;
110 u64 msr_mask;
111
112 switch (boot_cpu_data.x86_vendor) {
113 case X86_VENDOR_INTEL:
114 msr_addr = MSR_IA32_MISC_ENABLE;
115 msr_mask = MSR_IA32_MISC_ENABLE_TURBO_DISABLE;
116 break;
117 case X86_VENDOR_AMD:
118 msr_addr = MSR_K7_HWCR;
119 msr_mask = MSR_K7_HWCR_CPB_DIS;
120 break;
121 default:
122 return;
123 }
124
125 rdmsr_on_cpus(cpumask, msr_addr, msrs);
126
127 for_each_cpu(cpu, cpumask) {
128 struct msr *reg = per_cpu_ptr(msrs, cpu);
129 if (enable)
130 reg->q &= ~msr_mask;
131 else
132 reg->q |= msr_mask;
133 }
134
135 wrmsr_on_cpus(cpumask, msr_addr, msrs);
136}
137
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100138static int _store_boost(int val)
Andre Przywara615b7302012-09-04 08:28:07 +0000139{
Andre Przywara615b7302012-09-04 08:28:07 +0000140 get_online_cpus();
Andre Przywara615b7302012-09-04 08:28:07 +0000141 boost_set_msrs(val, cpu_online_mask);
Andre Przywara615b7302012-09-04 08:28:07 +0000142 put_online_cpus();
Andre Przywara615b7302012-09-04 08:28:07 +0000143 pr_debug("Core Boosting %sabled.\n", val ? "en" : "dis");
144
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100145 return 0;
Andre Przywara615b7302012-09-04 08:28:07 +0000146}
147
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800148static ssize_t show_freqdomain_cpus(struct cpufreq_policy *policy, char *buf)
149{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800150 struct acpi_cpufreq_data *data = policy->driver_data;
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800151
152 return cpufreq_show_cpus(data->freqdomain_cpus, buf);
153}
154
155cpufreq_freq_attr_ro(freqdomain_cpus);
156
Andre Przywara11269ff2012-09-04 08:28:08 +0000157#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100158static ssize_t store_boost(const char *buf, size_t count)
159{
160 int ret;
161 unsigned long val = 0;
162
163 if (!acpi_cpufreq_driver.boost_supported)
164 return -EINVAL;
165
166 ret = kstrtoul(buf, 10, &val);
167 if (ret || (val > 1))
168 return -EINVAL;
169
170 _store_boost((int) val);
171
172 return count;
173}
174
Andre Przywara11269ff2012-09-04 08:28:08 +0000175static ssize_t store_cpb(struct cpufreq_policy *policy, const char *buf,
176 size_t count)
177{
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100178 return store_boost(buf, count);
Andre Przywara11269ff2012-09-04 08:28:08 +0000179}
180
181static 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
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700248struct msr_addr {
249 u32 reg;
250};
251
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700252struct io_addr {
253 u16 port;
254 u8 bit_width;
255};
256
257struct drv_cmd {
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700258 unsigned int type;
Ingo Molnarbfa318a2009-01-15 15:46:08 +0100259 const struct cpumask *mask;
Dave Jones3a58df32009-01-17 22:36:14 -0500260 union {
261 struct msr_addr msr;
262 struct io_addr io;
263 } addr;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700264 u32 val;
265};
266
Andrew Morton01599fc2009-04-13 10:27:49 -0700267/* Called via smp_call_function_single(), on the target CPU */
268static void do_drv_read(void *_cmd)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700269{
Mike Travis72859082009-01-16 15:31:15 -0800270 struct drv_cmd *cmd = _cmd;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700271 u32 h;
272
273 switch (cmd->type) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700274 case SYSTEM_INTEL_MSR_CAPABLE:
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000275 case SYSTEM_AMD_MSR_CAPABLE:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700276 rdmsr(cmd->addr.msr.reg, cmd->val, h);
277 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700278 case SYSTEM_IO_CAPABLE:
Venkatesh Pallipadi4e581ff2006-12-13 10:41:16 -0800279 acpi_os_read_port((acpi_io_address)cmd->addr.io.port,
280 &cmd->val,
281 (u32)cmd->addr.io.bit_width);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700282 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700283 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700284 break;
285 }
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700286}
287
Andrew Morton01599fc2009-04-13 10:27:49 -0700288/* Called via smp_call_function_many(), on the target CPUs */
289static void do_drv_write(void *_cmd)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700290{
Mike Travis72859082009-01-16 15:31:15 -0800291 struct drv_cmd *cmd = _cmd;
Venki Pallipadi13424f62007-05-23 15:42:13 -0700292 u32 lo, hi;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700293
294 switch (cmd->type) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700295 case SYSTEM_INTEL_MSR_CAPABLE:
Venki Pallipadi13424f62007-05-23 15:42:13 -0700296 rdmsr(cmd->addr.msr.reg, lo, hi);
297 lo = (lo & ~INTEL_MSR_RANGE) | (cmd->val & INTEL_MSR_RANGE);
298 wrmsr(cmd->addr.msr.reg, lo, hi);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700299 break;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000300 case SYSTEM_AMD_MSR_CAPABLE:
301 wrmsr(cmd->addr.msr.reg, cmd->val, 0);
302 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700303 case SYSTEM_IO_CAPABLE:
Venkatesh Pallipadi4e581ff2006-12-13 10:41:16 -0800304 acpi_os_write_port((acpi_io_address)cmd->addr.io.port,
305 cmd->val,
306 (u32)cmd->addr.io.bit_width);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700307 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700308 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700309 break;
310 }
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700311}
312
Dave Jones95dd7222006-10-18 00:41:48 -0400313static void drv_read(struct drv_cmd *cmd)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700314{
Andrew Morton4a283952009-12-21 16:19:58 -0800315 int err;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700316 cmd->val = 0;
317
Andrew Morton4a283952009-12-21 16:19:58 -0800318 err = smp_call_function_any(cmd->mask, do_drv_read, cmd, 1);
319 WARN_ON_ONCE(err); /* smp_call_function_any() was buggy? */
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700320}
321
322static void drv_write(struct drv_cmd *cmd)
323{
Linus Torvaldsea34f432009-04-15 08:05:13 -0700324 int this_cpu;
325
326 this_cpu = get_cpu();
327 if (cpumask_test_cpu(this_cpu, cmd->mask))
328 do_drv_write(cmd);
Andrew Morton01599fc2009-04-13 10:27:49 -0700329 smp_call_function_many(cmd->mask, do_drv_write, cmd, 1);
Linus Torvaldsea34f432009-04-15 08:05:13 -0700330 put_cpu();
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700331}
332
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800333static u32
334get_cur_val(const struct cpumask *mask, struct acpi_cpufreq_data *data)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700335{
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700336 struct acpi_processor_performance *perf;
337 struct drv_cmd cmd;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700338
Mike Travis4d8bb532009-01-04 05:18:08 -0800339 if (unlikely(cpumask_empty(mask)))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700340 return 0;
341
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800342 switch (data->cpu_feature) {
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700343 case SYSTEM_INTEL_MSR_CAPABLE:
344 cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
Ross Lagerwall8673b832013-05-31 20:45:17 +0100345 cmd.addr.msr.reg = MSR_IA32_PERF_CTL;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700346 break;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000347 case SYSTEM_AMD_MSR_CAPABLE:
348 cmd.type = SYSTEM_AMD_MSR_CAPABLE;
Ross Lagerwall8673b832013-05-31 20:45:17 +0100349 cmd.addr.msr.reg = MSR_AMD_PERF_CTL;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000350 break;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700351 case SYSTEM_IO_CAPABLE:
352 cmd.type = SYSTEM_IO_CAPABLE;
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200353 perf = to_perf_data(data);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700354 cmd.addr.io.port = perf->control_register.address;
355 cmd.addr.io.bit_width = perf->control_register.bit_width;
356 break;
357 default:
358 return 0;
359 }
360
Ingo Molnarbfa318a2009-01-15 15:46:08 +0100361 cmd.mask = mask;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700362 drv_read(&cmd);
363
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200364 pr_debug("get_cur_val = %u\n", cmd.val);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700365
366 return cmd.val;
367}
368
369static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
370{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800371 struct acpi_cpufreq_data *data;
372 struct cpufreq_policy *policy;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700373 unsigned int freq;
Venkatesh Pallipadie56a7272008-04-28 15:13:43 -0400374 unsigned int cached_freq;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700375
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200376 pr_debug("get_cur_freq_on_cpu (%d)\n", cpu);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700377
Rafael J. Wysocki1f0bd442015-09-16 02:17:49 +0200378 policy = cpufreq_cpu_get_raw(cpu);
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800379 if (unlikely(!policy))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700380 return 0;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800381
382 data = policy->driver_data;
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200383 if (unlikely(!data || !data->freq_table))
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800384 return 0;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700385
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200386 cached_freq = data->freq_table[to_perf_data(data)->state].frequency;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800387 freq = extract_freq(get_cur_val(cpumask_of(cpu), data), data);
Venkatesh Pallipadie56a7272008-04-28 15:13:43 -0400388 if (freq != cached_freq) {
389 /*
390 * The dreaded BIOS frequency change behind our back.
391 * Force set the frequency on next target call.
392 */
393 data->resume = 1;
394 }
395
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200396 pr_debug("cur freq = %u\n", freq);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700397
398 return freq;
399}
400
Mike Travis72859082009-01-16 15:31:15 -0800401static unsigned int check_freqs(const struct cpumask *mask, unsigned int freq,
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700402 struct acpi_cpufreq_data *data)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700403{
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700404 unsigned int cur_freq;
405 unsigned int i;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700406
Dave Jones3a58df32009-01-17 22:36:14 -0500407 for (i = 0; i < 100; i++) {
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800408 cur_freq = extract_freq(get_cur_val(mask, data), data);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700409 if (cur_freq == freq)
410 return 1;
411 udelay(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 }
413 return 0;
414}
415
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700416static int acpi_cpufreq_target(struct cpufreq_policy *policy,
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530417 unsigned int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800419 struct acpi_cpufreq_data *data = policy->driver_data;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700420 struct acpi_processor_performance *perf;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700421 struct drv_cmd cmd;
Venkatesh Pallipadi8edc59d92006-12-19 12:58:55 -0800422 unsigned int next_perf_state = 0; /* Index into perf table */
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700423 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200425 if (unlikely(data == NULL || data->freq_table == NULL)) {
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700426 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 }
428
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200429 perf = to_perf_data(data);
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530430 next_perf_state = data->freq_table[index].driver_data;
Venkatesh Pallipadi7650b282006-10-03 12:36:30 -0700431 if (perf->state == next_perf_state) {
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700432 if (unlikely(data->resume)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200433 pr_debug("Called after resume, resetting to P%d\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700434 next_perf_state);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700435 data->resume = 0;
436 } else {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200437 pr_debug("Already at target state (P%d)\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700438 next_perf_state);
Mike Travis4d8bb532009-01-04 05:18:08 -0800439 goto out;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700440 }
441 }
442
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700443 switch (data->cpu_feature) {
444 case SYSTEM_INTEL_MSR_CAPABLE:
445 cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
446 cmd.addr.msr.reg = MSR_IA32_PERF_CTL;
Venki Pallipadi13424f62007-05-23 15:42:13 -0700447 cmd.val = (u32) perf->states[next_perf_state].control;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700448 break;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000449 case SYSTEM_AMD_MSR_CAPABLE:
450 cmd.type = SYSTEM_AMD_MSR_CAPABLE;
451 cmd.addr.msr.reg = MSR_AMD_PERF_CTL;
452 cmd.val = (u32) perf->states[next_perf_state].control;
453 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700454 case SYSTEM_IO_CAPABLE:
455 cmd.type = SYSTEM_IO_CAPABLE;
456 cmd.addr.io.port = perf->control_register.address;
457 cmd.addr.io.bit_width = perf->control_register.bit_width;
458 cmd.val = (u32) perf->states[next_perf_state].control;
459 break;
460 default:
Mike Travis4d8bb532009-01-04 05:18:08 -0800461 result = -ENODEV;
462 goto out;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700463 }
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700464
Mike Travis4d8bb532009-01-04 05:18:08 -0800465 /* cpufreq holds the hotplug lock, so we are safe from here on */
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700466 if (policy->shared_type != CPUFREQ_SHARED_TYPE_ANY)
Ingo Molnarbfa318a2009-01-15 15:46:08 +0100467 cmd.mask = policy->cpus;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700468 else
Ingo Molnarbfa318a2009-01-15 15:46:08 +0100469 cmd.mask = cpumask_of(policy->cpu);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700470
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700471 drv_write(&cmd);
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500472
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700473 if (acpi_pstate_strict) {
Viresh Kumard4019f02013-08-14 19:38:24 +0530474 if (!check_freqs(cmd.mask, data->freq_table[index].frequency,
475 data)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200476 pr_debug("acpi_cpufreq_target failed (%d)\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700477 policy->cpu);
Mike Travis4d8bb532009-01-04 05:18:08 -0800478 result = -EAGAIN;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500479 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500480 }
481
Viresh Kumare15d8302013-06-19 14:22:55 +0530482 if (!result)
483 perf->state = next_perf_state;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500484
Mike Travis4d8bb532009-01-04 05:18:08 -0800485out:
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700486 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487}
488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489static unsigned long
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700490acpi_cpufreq_guess_freq(struct acpi_cpufreq_data *data, unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200492 struct acpi_processor_performance *perf;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500493
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200494 perf = to_perf_data(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 if (cpu_khz) {
496 /* search the closest match to cpu_khz */
497 unsigned int i;
498 unsigned long freq;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500499 unsigned long freqn = perf->states[0].core_frequency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Dave Jones3a58df32009-01-17 22:36:14 -0500501 for (i = 0; i < (perf->state_count-1); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 freq = freqn;
Dave Jones95dd7222006-10-18 00:41:48 -0400503 freqn = perf->states[i+1].core_frequency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 if ((2 * cpu_khz) > (freqn + freq)) {
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500505 perf->state = i;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700506 return freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 }
508 }
Dave Jones95dd7222006-10-18 00:41:48 -0400509 perf->state = perf->state_count-1;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700510 return freqn;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500511 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 /* assume CPU is at P0... */
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500513 perf->state = 0;
514 return perf->states[0].core_frequency * 1000;
515 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516}
517
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800518static void free_acpi_perf_data(void)
519{
520 unsigned int i;
521
522 /* Freeing a NULL pointer is OK, and alloc_percpu zeroes. */
523 for_each_possible_cpu(i)
524 free_cpumask_var(per_cpu_ptr(acpi_perf_data, i)
525 ->shared_cpu_map);
526 free_percpu(acpi_perf_data);
527}
528
Andre Przywara615b7302012-09-04 08:28:07 +0000529static int boost_notify(struct notifier_block *nb, unsigned long action,
530 void *hcpu)
531{
532 unsigned cpu = (long)hcpu;
533 const struct cpumask *cpumask;
534
535 cpumask = get_cpu_mask(cpu);
536
537 /*
538 * Clear the boost-disable bit on the CPU_DOWN path so that
539 * this cpu cannot block the remaining ones from boosting. On
540 * the CPU_UP path we simply keep the boost-disable flag in
541 * sync with the current global state.
542 */
543
544 switch (action) {
545 case CPU_UP_PREPARE:
546 case CPU_UP_PREPARE_FROZEN:
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100547 boost_set_msrs(acpi_cpufreq_driver.boost_enabled, cpumask);
Andre Przywara615b7302012-09-04 08:28:07 +0000548 break;
549
550 case CPU_DOWN_PREPARE:
551 case CPU_DOWN_PREPARE_FROZEN:
552 boost_set_msrs(1, cpumask);
553 break;
554
555 default:
556 break;
557 }
558
559 return NOTIFY_OK;
560}
561
562
563static struct notifier_block boost_nb = {
564 .notifier_call = boost_notify,
565};
566
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500567/*
568 * acpi_cpufreq_early_init - initialize ACPI P-States library
569 *
570 * Initialize the ACPI P-States library (drivers/acpi/processor_perflib.c)
571 * in order to determine correct frequency and voltage pairings. We can
572 * do _PDC and _PSD and find out the processor dependency for the
573 * actual init that will happen later...
574 */
Fenghua Yu50109292007-08-07 18:40:30 -0400575static int __init acpi_cpufreq_early_init(void)
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500576{
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800577 unsigned int i;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200578 pr_debug("acpi_cpufreq_early_init\n");
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500579
Fenghua Yu50109292007-08-07 18:40:30 -0400580 acpi_perf_data = alloc_percpu(struct acpi_processor_performance);
581 if (!acpi_perf_data) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200582 pr_debug("Memory allocation error for acpi_perf_data.\n");
Fenghua Yu50109292007-08-07 18:40:30 -0400583 return -ENOMEM;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500584 }
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800585 for_each_possible_cpu(i) {
Yinghai Lueaa95842009-06-06 14:51:36 -0700586 if (!zalloc_cpumask_var_node(
Mike Travis80855f72008-12-31 18:08:47 -0800587 &per_cpu_ptr(acpi_perf_data, i)->shared_cpu_map,
588 GFP_KERNEL, cpu_to_node(i))) {
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800589
590 /* Freeing a NULL pointer is OK: alloc_percpu zeroes. */
591 free_acpi_perf_data();
592 return -ENOMEM;
593 }
594 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500595
596 /* Do initialization in ACPI core */
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700597 acpi_processor_preregister_performance(acpi_perf_data);
598 return 0;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500599}
600
Dave Jones95625b82006-10-21 01:37:39 -0400601#ifdef CONFIG_SMP
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700602/*
603 * Some BIOSes do SW_ANY coordination internally, either set it up in hw
604 * or do it in BIOS firmware and won't inform about it to OS. If not
605 * detected, this has a side effect of making CPU run at a different speed
606 * than OS intended it to run at. Detect it and handle it cleanly.
607 */
608static int bios_with_sw_any_bug;
609
Jeff Garzik18552562007-10-03 15:15:40 -0400610static int sw_any_bug_found(const struct dmi_system_id *d)
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700611{
612 bios_with_sw_any_bug = 1;
613 return 0;
614}
615
Jeff Garzik18552562007-10-03 15:15:40 -0400616static const struct dmi_system_id sw_any_bug_dmi_table[] = {
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700617 {
618 .callback = sw_any_bug_found,
619 .ident = "Supermicro Server X6DLP",
620 .matches = {
621 DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
622 DMI_MATCH(DMI_BIOS_VERSION, "080010"),
623 DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"),
624 },
625 },
626 { }
627};
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400628
629static int acpi_cpufreq_blacklist(struct cpuinfo_x86 *c)
630{
John Villalovos293afe42009-09-25 13:30:08 -0400631 /* Intel Xeon Processor 7100 Series Specification Update
632 * http://www.intel.com/Assets/PDF/specupdate/314554.pdf
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400633 * AL30: A Machine Check Exception (MCE) Occurring during an
634 * Enhanced Intel SpeedStep Technology Ratio Change May Cause
John Villalovos293afe42009-09-25 13:30:08 -0400635 * Both Processor Cores to Lock Up. */
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400636 if (c->x86_vendor == X86_VENDOR_INTEL) {
637 if ((c->x86 == 15) &&
638 (c->x86_model == 6) &&
John Villalovos293afe42009-09-25 13:30:08 -0400639 (c->x86_mask == 8)) {
640 printk(KERN_INFO "acpi-cpufreq: Intel(R) "
641 "Xeon(R) 7100 Errata AL30, processors may "
642 "lock up on frequency changes: disabling "
643 "acpi-cpufreq.\n");
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400644 return -ENODEV;
John Villalovos293afe42009-09-25 13:30:08 -0400645 }
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400646 }
647 return 0;
648}
Dave Jones95625b82006-10-21 01:37:39 -0400649#endif
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700650
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700651static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652{
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700653 unsigned int i;
654 unsigned int valid_states = 0;
655 unsigned int cpu = policy->cpu;
656 struct acpi_cpufreq_data *data;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700657 unsigned int result = 0;
Mike Travis92cb7612007-10-19 20:35:04 +0200658 struct cpuinfo_x86 *c = &cpu_data(policy->cpu);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700659 struct acpi_processor_performance *perf;
John Villalovos293afe42009-09-25 13:30:08 -0400660#ifdef CONFIG_SMP
661 static int blacklisted;
662#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200664 pr_debug("acpi_cpufreq_cpu_init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400666#ifdef CONFIG_SMP
John Villalovos293afe42009-09-25 13:30:08 -0400667 if (blacklisted)
668 return blacklisted;
669 blacklisted = acpi_cpufreq_blacklist(c);
670 if (blacklisted)
671 return blacklisted;
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400672#endif
673
Viresh Kumard5b73cd2013-08-06 22:53:06 +0530674 data = kzalloc(sizeof(*data), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 if (!data)
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700676 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800678 if (!zalloc_cpumask_var(&data->freqdomain_cpus, GFP_KERNEL)) {
679 result = -ENOMEM;
680 goto err_free;
681 }
682
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200683 perf = per_cpu_ptr(acpi_perf_data, cpu);
Pan Xinhui8cfcfd32015-07-10 14:36:20 +0800684 data->acpi_perf_cpu = cpu;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800685 policy->driver_data = data;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700686
Dave Jones95dd7222006-10-18 00:41:48 -0400687 if (cpu_has(c, X86_FEATURE_CONSTANT_TSC))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700688 acpi_cpufreq_driver.flags |= CPUFREQ_CONST_LOOPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200690 result = acpi_processor_register_performance(perf, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 if (result)
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800692 goto err_free_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500694 policy->shared_type = perf->shared_type;
Dave Jones95dd7222006-10-18 00:41:48 -0400695
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400696 /*
Dave Jones95dd7222006-10-18 00:41:48 -0400697 * Will let policy->cpus know about dependency only when software
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400698 * coordination is required.
699 */
700 if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700701 policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
Rusty Russell835481d2009-01-04 05:18:06 -0800702 cpumask_copy(policy->cpus, perf->shared_cpu_map);
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700703 }
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800704 cpumask_copy(data->freqdomain_cpus, perf->shared_cpu_map);
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700705
706#ifdef CONFIG_SMP
707 dmi_check_system(sw_any_bug_dmi_table);
Fabio Baltieri2624f902013-01-31 09:44:40 +0000708 if (bios_with_sw_any_bug && !policy_is_shared(policy)) {
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700709 policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
Bartosz Golaszewski3280c3c2015-05-26 15:11:33 +0200710 cpumask_copy(policy->cpus, topology_core_cpumask(cpu));
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700711 }
Andre Przywaraacd31622012-09-04 08:28:03 +0000712
713 if (check_amd_hwpstate_cpu(cpu) && !acpi_pstate_strict) {
714 cpumask_clear(policy->cpus);
715 cpumask_set_cpu(cpu, policy->cpus);
Bartosz Golaszewski3280c3c2015-05-26 15:11:33 +0200716 cpumask_copy(data->freqdomain_cpus,
717 topology_sibling_cpumask(cpu));
Andre Przywaraacd31622012-09-04 08:28:03 +0000718 policy->shared_type = CPUFREQ_SHARED_TYPE_HW;
719 pr_info_once(PFX "overriding BIOS provided _PSD data\n");
720 }
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700721#endif
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500722
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 /* capability check */
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500724 if (perf->state_count <= 1) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200725 pr_debug("No P-States\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 result = -ENODEV;
727 goto err_unreg;
728 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500729
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700730 if (perf->control_register.space_id != perf->status_register.space_id) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 result = -ENODEV;
732 goto err_unreg;
733 }
734
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700735 switch (perf->control_register.space_id) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700736 case ACPI_ADR_SPACE_SYSTEM_IO:
Matthew Garrettc40a4512013-01-20 10:24:26 +0000737 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
738 boot_cpu_data.x86 == 0xf) {
739 pr_debug("AMD K8 systems must use native drivers.\n");
740 result = -ENODEV;
741 goto err_unreg;
742 }
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200743 pr_debug("SYSTEM IO addr space\n");
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700744 data->cpu_feature = SYSTEM_IO_CAPABLE;
745 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700746 case ACPI_ADR_SPACE_FIXED_HARDWARE:
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200747 pr_debug("HARDWARE addr space\n");
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000748 if (check_est_cpu(cpu)) {
749 data->cpu_feature = SYSTEM_INTEL_MSR_CAPABLE;
750 break;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700751 }
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000752 if (check_amd_hwpstate_cpu(cpu)) {
753 data->cpu_feature = SYSTEM_AMD_MSR_CAPABLE;
754 break;
755 }
756 result = -ENODEV;
757 goto err_unreg;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700758 default:
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200759 pr_debug("Unknown addr space %d\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700760 (u32) (perf->control_register.space_id));
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700761 result = -ENODEV;
762 goto err_unreg;
763 }
764
Viresh Kumar71508a12014-03-28 19:11:46 +0530765 data->freq_table = kzalloc(sizeof(*data->freq_table) *
Dave Jones95dd7222006-10-18 00:41:48 -0400766 (perf->state_count+1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 if (!data->freq_table) {
768 result = -ENOMEM;
769 goto err_unreg;
770 }
771
772 /* detect transition latency */
773 policy->cpuinfo.transition_latency = 0;
Dave Jones3a58df32009-01-17 22:36:14 -0500774 for (i = 0; i < perf->state_count; i++) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700775 if ((perf->states[i].transition_latency * 1000) >
776 policy->cpuinfo.transition_latency)
777 policy->cpuinfo.transition_latency =
778 perf->states[i].transition_latency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700781 /* Check for high latency (>20uS) from buggy BIOSes, like on T42 */
782 if (perf->control_register.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE &&
783 policy->cpuinfo.transition_latency > 20 * 1000) {
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700784 policy->cpuinfo.transition_latency = 20 * 1000;
Joe Perches61c8c672009-05-26 14:58:39 -0700785 printk_once(KERN_INFO
786 "P-state transition latency capped at 20 uS\n");
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700787 }
788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 /* table init */
Dave Jones3a58df32009-01-17 22:36:14 -0500790 for (i = 0; i < perf->state_count; i++) {
791 if (i > 0 && perf->states[i].core_frequency >=
Zhang Rui3cdf5522007-06-13 21:24:02 -0400792 data->freq_table[valid_states-1].frequency / 1000)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700793 continue;
794
Viresh Kumar50701582013-03-30 16:25:15 +0530795 data->freq_table[valid_states].driver_data = i;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700796 data->freq_table[valid_states].frequency =
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700797 perf->states[i].core_frequency * 1000;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700798 valid_states++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
Venkatesh Pallipadi3d4a7ef2006-11-13 17:47:44 -0800800 data->freq_table[valid_states].frequency = CPUFREQ_TABLE_END;
Venkatesh Pallipadi8edc59d92006-12-19 12:58:55 -0800801 perf->state = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Viresh Kumar776b57b2013-09-16 18:56:07 +0530803 result = cpufreq_table_validate_and_show(policy, data->freq_table);
Dave Jones95dd7222006-10-18 00:41:48 -0400804 if (result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 goto err_freqfree;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
Thomas Renningerd876dfb2009-04-17 16:22:08 +0200807 if (perf->states[0].core_frequency * 1000 != policy->cpuinfo.max_freq)
808 printk(KERN_WARNING FW_WARN "P-state 0 is not max freq\n");
809
Mattia Dongilia507ac42006-12-15 19:52:45 +0100810 switch (perf->control_register.space_id) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700811 case ACPI_ADR_SPACE_SYSTEM_IO:
Viresh Kumar1bab64d2013-10-16 23:58:10 +0200812 /*
813 * The core will not set policy->cur, because
814 * cpufreq_driver->get is NULL, so we need to set it here.
815 * However, we have to guess it, because the current speed is
816 * unknown and not detectable via IO ports.
817 */
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700818 policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);
819 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700820 case ACPI_ADR_SPACE_FIXED_HARDWARE:
Venkatesh Pallipadi7650b282006-10-03 12:36:30 -0700821 acpi_cpufreq_driver.get = get_cur_freq_on_cpu;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700822 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700823 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700824 break;
825 }
826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 /* notify BIOS that we exist */
828 acpi_processor_notify_smm(THIS_MODULE);
829
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200830 pr_debug("CPU%u - ACPI performance management activated.\n", cpu);
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500831 for (i = 0; i < perf->state_count; i++)
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200832 pr_debug(" %cP%d: %d MHz, %d mW, %d uS\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700833 (i == perf->state ? '*' : ' '), i,
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500834 (u32) perf->states[i].core_frequency,
835 (u32) perf->states[i].power,
836 (u32) perf->states[i].transition_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
Dominik Brodowski4b31e772005-05-18 13:49:00 -0400838 /*
839 * the first call to ->target() should result in us actually
840 * writing something to the appropriate registers.
841 */
842 data->resume = 1;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700843
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700844 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845
Dave Jones95dd7222006-10-18 00:41:48 -0400846err_freqfree:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 kfree(data->freq_table);
Dave Jones95dd7222006-10-18 00:41:48 -0400848err_unreg:
Rafael J. Wysockib2f8dc42015-07-22 22:11:16 +0200849 acpi_processor_unregister_performance(cpu);
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800850err_free_mask:
851 free_cpumask_var(data->freqdomain_cpus);
Dave Jones95dd7222006-10-18 00:41:48 -0400852err_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 kfree(data);
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800854 policy->driver_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700856 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857}
858
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700859static int acpi_cpufreq_cpu_exit(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800861 struct acpi_cpufreq_data *data = policy->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200863 pr_debug("acpi_cpufreq_cpu_exit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
865 if (data) {
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800866 policy->driver_data = NULL;
Rafael J. Wysockib2f8dc42015-07-22 22:11:16 +0200867 acpi_processor_unregister_performance(data->acpi_perf_cpu);
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800868 free_cpumask_var(data->freqdomain_cpus);
Zhang Ruidab5fff2010-10-12 09:09:37 +0800869 kfree(data->freq_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 kfree(data);
871 }
872
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700873 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874}
875
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700876static int acpi_cpufreq_resume(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800878 struct acpi_cpufreq_data *data = policy->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200880 pr_debug("acpi_cpufreq_resume\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
882 data->resume = 1;
883
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700884 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885}
886
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700887static struct freq_attr *acpi_cpufreq_attr[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 &cpufreq_freq_attr_scaling_available_freqs,
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800889 &freqdomain_cpus,
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200890#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
891 &cpb,
892#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 NULL,
894};
895
896static struct cpufreq_driver acpi_cpufreq_driver = {
Viresh Kumardb9be212013-10-03 20:27:56 +0530897 .verify = cpufreq_generic_frequency_table_verify,
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530898 .target_index = acpi_cpufreq_target,
Thomas Renningere2f74f32009-11-19 12:31:01 +0100899 .bios_limit = acpi_processor_get_bios_limit,
900 .init = acpi_cpufreq_cpu_init,
901 .exit = acpi_cpufreq_cpu_exit,
902 .resume = acpi_cpufreq_resume,
903 .name = "acpi-cpufreq",
Thomas Renningere2f74f32009-11-19 12:31:01 +0100904 .attr = acpi_cpufreq_attr,
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100905 .set_boost = _store_boost,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906};
907
Andre Przywara615b7302012-09-04 08:28:07 +0000908static void __init acpi_cpufreq_boost_init(void)
909{
910 if (boot_cpu_has(X86_FEATURE_CPB) || boot_cpu_has(X86_FEATURE_IDA)) {
911 msrs = msrs_alloc();
912
913 if (!msrs)
914 return;
915
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100916 acpi_cpufreq_driver.boost_supported = true;
917 acpi_cpufreq_driver.boost_enabled = boost_state(0);
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530918
919 cpu_notifier_register_begin();
Andre Przywara615b7302012-09-04 08:28:07 +0000920
921 /* Force all MSRs to the same value */
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100922 boost_set_msrs(acpi_cpufreq_driver.boost_enabled,
923 cpu_online_mask);
Andre Przywara615b7302012-09-04 08:28:07 +0000924
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530925 __register_cpu_notifier(&boost_nb);
Andre Przywara615b7302012-09-04 08:28:07 +0000926
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530927 cpu_notifier_register_done();
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100928 }
Andre Przywara615b7302012-09-04 08:28:07 +0000929}
930
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500931static void acpi_cpufreq_boost_exit(void)
Andre Przywara615b7302012-09-04 08:28:07 +0000932{
Andre Przywara615b7302012-09-04 08:28:07 +0000933 if (msrs) {
934 unregister_cpu_notifier(&boost_nb);
935
936 msrs_free(msrs);
937 msrs = NULL;
938 }
939}
940
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700941static int __init acpi_cpufreq_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942{
Fenghua Yu50109292007-08-07 18:40:30 -0400943 int ret;
944
Rafael J. Wysocki75c07582013-10-25 16:22:47 +0200945 if (acpi_disabled)
946 return -ENODEV;
947
Yinghai Lu8a61e122013-09-20 10:43:56 -0700948 /* don't keep reloading if cpufreq_driver exists */
949 if (cpufreq_get_current_driver())
Rafael J. Wysocki75c07582013-10-25 16:22:47 +0200950 return -EEXIST;
Yinghai Luee297532008-09-24 19:04:31 -0700951
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200952 pr_debug("acpi_cpufreq_init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
Fenghua Yu50109292007-08-07 18:40:30 -0400954 ret = acpi_cpufreq_early_init();
955 if (ret)
956 return ret;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500957
Andre Przywara11269ff2012-09-04 08:28:08 +0000958#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
959 /* this is a sysfs file with a strange name and an even stranger
960 * semantic - per CPU instantiation, but system global effect.
961 * Lets enable it only on AMD CPUs for compatibility reasons and
962 * only if configured. This is considered legacy code, which
963 * will probably be removed at some point in the future.
964 */
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200965 if (!check_amd_hwpstate_cpu(0)) {
966 struct freq_attr **attr;
Andre Przywara11269ff2012-09-04 08:28:08 +0000967
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200968 pr_debug("CPB unsupported, do not expose it\n");
Andre Przywara11269ff2012-09-04 08:28:08 +0000969
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200970 for (attr = acpi_cpufreq_attr; *attr; attr++)
971 if (*attr == &cpb) {
972 *attr = NULL;
973 break;
974 }
Andre Przywara11269ff2012-09-04 08:28:08 +0000975 }
976#endif
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100977 acpi_cpufreq_boost_init();
Andre Przywara11269ff2012-09-04 08:28:08 +0000978
Akinobu Mita847aef62008-07-14 11:59:44 +0900979 ret = cpufreq_register_driver(&acpi_cpufreq_driver);
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500980 if (ret) {
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800981 free_acpi_perf_data();
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500982 acpi_cpufreq_boost_exit();
983 }
Akinobu Mita847aef62008-07-14 11:59:44 +0900984 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985}
986
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700987static void __exit acpi_cpufreq_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988{
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200989 pr_debug("acpi_cpufreq_exit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
Andre Przywara615b7302012-09-04 08:28:07 +0000991 acpi_cpufreq_boost_exit();
992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 cpufreq_unregister_driver(&acpi_cpufreq_driver);
994
Luming Yu50f4ddd2011-07-08 16:37:44 -0400995 free_acpi_perf_data();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996}
997
Venkatesh Pallipadid395bf12005-08-25 15:59:00 -0400998module_param(acpi_pstate_strict, uint, 0644);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700999MODULE_PARM_DESC(acpi_pstate_strict,
Dave Jones95dd7222006-10-18 00:41:48 -04001000 "value 0 or non-zero. non-zero -> strict ACPI checks are "
1001 "performed during frequency changes.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002
1003late_initcall(acpi_cpufreq_init);
1004module_exit(acpi_cpufreq_exit);
1005
Matthew Garrettefa17192013-01-22 22:33:46 +01001006static const struct x86_cpu_id acpi_cpufreq_ids[] = {
1007 X86_FEATURE_MATCH(X86_FEATURE_ACPI),
1008 X86_FEATURE_MATCH(X86_FEATURE_HW_PSTATE),
1009 {}
1010};
1011MODULE_DEVICE_TABLE(x86cpu, acpi_cpufreq_ids);
1012
Rafael J. Wysockic655aff2013-06-07 13:13:31 +02001013static const struct acpi_device_id processor_device_ids[] = {
1014 {ACPI_PROCESSOR_OBJECT_HID, },
1015 {ACPI_PROCESSOR_DEVICE_HID, },
1016 {},
1017};
1018MODULE_DEVICE_TABLE(acpi, processor_device_ids);
1019
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020MODULE_ALIAS("acpi");