blob: 51eef87bbc374f85826b16b27141f024aefd9bbe [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
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100138static int set_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
Srinivas Pandruvadae2530362015-10-07 13:50:43 -0700152 if (unlikely(!data))
153 return -ENODEV;
154
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800155 return cpufreq_show_cpus(data->freqdomain_cpus, buf);
156}
157
158cpufreq_freq_attr_ro(freqdomain_cpus);
159
Andre Przywara11269ff2012-09-04 08:28:08 +0000160#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100161static ssize_t store_cpb(struct cpufreq_policy *policy, const char *buf,
162 size_t count)
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100163{
164 int ret;
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100165 unsigned int val = 0;
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100166
Rafael J. Wysocki7a6c79f2015-12-27 00:27:38 +0100167 if (!acpi_cpufreq_driver.set_boost)
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100168 return -EINVAL;
169
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100170 ret = kstrtouint(buf, 10, &val);
171 if (ret || val > 1)
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100172 return -EINVAL;
173
Rafael J. Wysocki17135782015-12-27 00:25:35 +0100174 set_boost(val);
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100175
176 return count;
177}
178
Andre Przywara11269ff2012-09-04 08:28:08 +0000179static ssize_t show_cpb(struct cpufreq_policy *policy, char *buf)
180{
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100181 return sprintf(buf, "%u\n", acpi_cpufreq_driver.boost_enabled);
Andre Przywara11269ff2012-09-04 08:28:08 +0000182}
183
Lan Tianyu59027d32013-08-13 10:05:53 +0800184cpufreq_freq_attr_rw(cpb);
Andre Przywara11269ff2012-09-04 08:28:08 +0000185#endif
186
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700187static int check_est_cpu(unsigned int cpuid)
188{
Mike Travis92cb7612007-10-19 20:35:04 +0200189 struct cpuinfo_x86 *cpu = &cpu_data(cpuid);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700190
Harald Welte0de51082009-06-08 18:27:54 +0800191 return cpu_has(cpu, X86_FEATURE_EST);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700192}
193
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000194static int check_amd_hwpstate_cpu(unsigned int cpuid)
195{
196 struct cpuinfo_x86 *cpu = &cpu_data(cpuid);
197
198 return cpu_has(cpu, X86_FEATURE_HW_PSTATE);
199}
200
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700201static unsigned extract_io(u32 value, struct acpi_cpufreq_data *data)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700202{
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700203 struct acpi_processor_performance *perf;
204 int i;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700205
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200206 perf = to_perf_data(data);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700207
Dave Jones3a58df32009-01-17 22:36:14 -0500208 for (i = 0; i < perf->state_count; i++) {
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700209 if (value == perf->states[i].status)
210 return data->freq_table[i].frequency;
211 }
212 return 0;
213}
214
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700215static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
216{
Stratos Karafotis041526f2014-04-25 23:15:38 +0300217 struct cpufreq_frequency_table *pos;
Venkatesh Pallipadia6f6e6e62006-10-03 12:37:42 -0700218 struct acpi_processor_performance *perf;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700219
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000220 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
221 msr &= AMD_MSR_RANGE;
222 else
223 msr &= INTEL_MSR_RANGE;
224
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200225 perf = to_perf_data(data);
Venkatesh Pallipadia6f6e6e62006-10-03 12:37:42 -0700226
Stratos Karafotis041526f2014-04-25 23:15:38 +0300227 cpufreq_for_each_entry(pos, data->freq_table)
228 if (msr == perf->states[pos->driver_data].status)
229 return pos->frequency;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700230 return data->freq_table[0].frequency;
231}
232
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700233static unsigned extract_freq(u32 val, struct acpi_cpufreq_data *data)
234{
235 switch (data->cpu_feature) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700236 case SYSTEM_INTEL_MSR_CAPABLE:
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000237 case SYSTEM_AMD_MSR_CAPABLE:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700238 return extract_msr(val, data);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700239 case SYSTEM_IO_CAPABLE:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700240 return extract_io(val, data);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700241 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700242 return 0;
243 }
244}
245
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700246struct msr_addr {
247 u32 reg;
248};
249
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700250struct io_addr {
251 u16 port;
252 u8 bit_width;
253};
254
255struct drv_cmd {
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700256 unsigned int type;
Ingo Molnarbfa318a2009-01-15 15:46:08 +0100257 const struct cpumask *mask;
Dave Jones3a58df32009-01-17 22:36:14 -0500258 union {
259 struct msr_addr msr;
260 struct io_addr io;
261 } addr;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700262 u32 val;
263};
264
Andrew Morton01599fc2009-04-13 10:27:49 -0700265/* Called via smp_call_function_single(), on the target CPU */
266static void do_drv_read(void *_cmd)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700267{
Mike Travis72859082009-01-16 15:31:15 -0800268 struct drv_cmd *cmd = _cmd;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700269 u32 h;
270
271 switch (cmd->type) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700272 case SYSTEM_INTEL_MSR_CAPABLE:
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000273 case SYSTEM_AMD_MSR_CAPABLE:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700274 rdmsr(cmd->addr.msr.reg, cmd->val, h);
275 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700276 case SYSTEM_IO_CAPABLE:
Venkatesh Pallipadi4e581ff2006-12-13 10:41:16 -0800277 acpi_os_read_port((acpi_io_address)cmd->addr.io.port,
278 &cmd->val,
279 (u32)cmd->addr.io.bit_width);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700280 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700281 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700282 break;
283 }
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700284}
285
Andrew Morton01599fc2009-04-13 10:27:49 -0700286/* Called via smp_call_function_many(), on the target CPUs */
287static void do_drv_write(void *_cmd)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700288{
Mike Travis72859082009-01-16 15:31:15 -0800289 struct drv_cmd *cmd = _cmd;
Venki Pallipadi13424f62007-05-23 15:42:13 -0700290 u32 lo, hi;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700291
292 switch (cmd->type) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700293 case SYSTEM_INTEL_MSR_CAPABLE:
Venki Pallipadi13424f62007-05-23 15:42:13 -0700294 rdmsr(cmd->addr.msr.reg, lo, hi);
295 lo = (lo & ~INTEL_MSR_RANGE) | (cmd->val & INTEL_MSR_RANGE);
296 wrmsr(cmd->addr.msr.reg, lo, hi);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700297 break;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000298 case SYSTEM_AMD_MSR_CAPABLE:
299 wrmsr(cmd->addr.msr.reg, cmd->val, 0);
300 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700301 case SYSTEM_IO_CAPABLE:
Venkatesh Pallipadi4e581ff2006-12-13 10:41:16 -0800302 acpi_os_write_port((acpi_io_address)cmd->addr.io.port,
303 cmd->val,
304 (u32)cmd->addr.io.bit_width);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700305 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700306 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700307 break;
308 }
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700309}
310
Dave Jones95dd7222006-10-18 00:41:48 -0400311static void drv_read(struct drv_cmd *cmd)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700312{
Andrew Morton4a283952009-12-21 16:19:58 -0800313 int err;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700314 cmd->val = 0;
315
Andrew Morton4a283952009-12-21 16:19:58 -0800316 err = smp_call_function_any(cmd->mask, do_drv_read, cmd, 1);
317 WARN_ON_ONCE(err); /* smp_call_function_any() was buggy? */
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700318}
319
320static void drv_write(struct drv_cmd *cmd)
321{
Linus Torvaldsea34f432009-04-15 08:05:13 -0700322 int this_cpu;
323
324 this_cpu = get_cpu();
325 if (cpumask_test_cpu(this_cpu, cmd->mask))
326 do_drv_write(cmd);
Andrew Morton01599fc2009-04-13 10:27:49 -0700327 smp_call_function_many(cmd->mask, do_drv_write, cmd, 1);
Linus Torvaldsea34f432009-04-15 08:05:13 -0700328 put_cpu();
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700329}
330
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800331static u32
332get_cur_val(const struct cpumask *mask, struct acpi_cpufreq_data *data)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700333{
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700334 struct acpi_processor_performance *perf;
335 struct drv_cmd cmd;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700336
Mike Travis4d8bb532009-01-04 05:18:08 -0800337 if (unlikely(cpumask_empty(mask)))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700338 return 0;
339
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800340 switch (data->cpu_feature) {
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700341 case SYSTEM_INTEL_MSR_CAPABLE:
342 cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
Ross Lagerwall8673b832013-05-31 20:45:17 +0100343 cmd.addr.msr.reg = MSR_IA32_PERF_CTL;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700344 break;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000345 case SYSTEM_AMD_MSR_CAPABLE:
346 cmd.type = SYSTEM_AMD_MSR_CAPABLE;
Ross Lagerwall8673b832013-05-31 20:45:17 +0100347 cmd.addr.msr.reg = MSR_AMD_PERF_CTL;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000348 break;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700349 case SYSTEM_IO_CAPABLE:
350 cmd.type = SYSTEM_IO_CAPABLE;
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200351 perf = to_perf_data(data);
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700352 cmd.addr.io.port = perf->control_register.address;
353 cmd.addr.io.bit_width = perf->control_register.bit_width;
354 break;
355 default:
356 return 0;
357 }
358
Ingo Molnarbfa318a2009-01-15 15:46:08 +0100359 cmd.mask = mask;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700360 drv_read(&cmd);
361
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200362 pr_debug("get_cur_val = %u\n", cmd.val);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700363
364 return cmd.val;
365}
366
367static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
368{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800369 struct acpi_cpufreq_data *data;
370 struct cpufreq_policy *policy;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700371 unsigned int freq;
Venkatesh Pallipadie56a7272008-04-28 15:13:43 -0400372 unsigned int cached_freq;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700373
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200374 pr_debug("get_cur_freq_on_cpu (%d)\n", cpu);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700375
Rafael J. Wysocki1f0bd442015-09-16 02:17:49 +0200376 policy = cpufreq_cpu_get_raw(cpu);
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800377 if (unlikely(!policy))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700378 return 0;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800379
380 data = policy->driver_data;
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200381 if (unlikely(!data || !data->freq_table))
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800382 return 0;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700383
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200384 cached_freq = data->freq_table[to_perf_data(data)->state].frequency;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800385 freq = extract_freq(get_cur_val(cpumask_of(cpu), data), data);
Venkatesh Pallipadie56a7272008-04-28 15:13:43 -0400386 if (freq != cached_freq) {
387 /*
388 * The dreaded BIOS frequency change behind our back.
389 * Force set the frequency on next target call.
390 */
391 data->resume = 1;
392 }
393
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200394 pr_debug("cur freq = %u\n", freq);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700395
396 return freq;
397}
398
Mike Travis72859082009-01-16 15:31:15 -0800399static unsigned int check_freqs(const struct cpumask *mask, unsigned int freq,
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700400 struct acpi_cpufreq_data *data)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700401{
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700402 unsigned int cur_freq;
403 unsigned int i;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700404
Dave Jones3a58df32009-01-17 22:36:14 -0500405 for (i = 0; i < 100; i++) {
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800406 cur_freq = extract_freq(get_cur_val(mask, data), data);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700407 if (cur_freq == freq)
408 return 1;
409 udelay(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 }
411 return 0;
412}
413
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700414static int acpi_cpufreq_target(struct cpufreq_policy *policy,
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530415 unsigned int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800417 struct acpi_cpufreq_data *data = policy->driver_data;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700418 struct acpi_processor_performance *perf;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700419 struct drv_cmd cmd;
Venkatesh Pallipadi8edc59d92006-12-19 12:58:55 -0800420 unsigned int next_perf_state = 0; /* Index into perf table */
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700421 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200423 if (unlikely(data == NULL || data->freq_table == NULL)) {
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700424 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 }
426
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200427 perf = to_perf_data(data);
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530428 next_perf_state = data->freq_table[index].driver_data;
Venkatesh Pallipadi7650b282006-10-03 12:36:30 -0700429 if (perf->state == next_perf_state) {
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700430 if (unlikely(data->resume)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200431 pr_debug("Called after resume, resetting to P%d\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700432 next_perf_state);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700433 data->resume = 0;
434 } else {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200435 pr_debug("Already at target state (P%d)\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700436 next_perf_state);
Mike Travis4d8bb532009-01-04 05:18:08 -0800437 goto out;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700438 }
439 }
440
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700441 switch (data->cpu_feature) {
442 case SYSTEM_INTEL_MSR_CAPABLE:
443 cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
444 cmd.addr.msr.reg = MSR_IA32_PERF_CTL;
Venki Pallipadi13424f62007-05-23 15:42:13 -0700445 cmd.val = (u32) perf->states[next_perf_state].control;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700446 break;
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000447 case SYSTEM_AMD_MSR_CAPABLE:
448 cmd.type = SYSTEM_AMD_MSR_CAPABLE;
449 cmd.addr.msr.reg = MSR_AMD_PERF_CTL;
450 cmd.val = (u32) perf->states[next_perf_state].control;
451 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700452 case SYSTEM_IO_CAPABLE:
453 cmd.type = SYSTEM_IO_CAPABLE;
454 cmd.addr.io.port = perf->control_register.address;
455 cmd.addr.io.bit_width = perf->control_register.bit_width;
456 cmd.val = (u32) perf->states[next_perf_state].control;
457 break;
458 default:
Mike Travis4d8bb532009-01-04 05:18:08 -0800459 result = -ENODEV;
460 goto out;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700461 }
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700462
Mike Travis4d8bb532009-01-04 05:18:08 -0800463 /* cpufreq holds the hotplug lock, so we are safe from here on */
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700464 if (policy->shared_type != CPUFREQ_SHARED_TYPE_ANY)
Ingo Molnarbfa318a2009-01-15 15:46:08 +0100465 cmd.mask = policy->cpus;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700466 else
Ingo Molnarbfa318a2009-01-15 15:46:08 +0100467 cmd.mask = cpumask_of(policy->cpu);
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700468
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700469 drv_write(&cmd);
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500470
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700471 if (acpi_pstate_strict) {
Viresh Kumard4019f02013-08-14 19:38:24 +0530472 if (!check_freqs(cmd.mask, data->freq_table[index].frequency,
473 data)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200474 pr_debug("acpi_cpufreq_target failed (%d)\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700475 policy->cpu);
Mike Travis4d8bb532009-01-04 05:18:08 -0800476 result = -EAGAIN;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500477 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500478 }
479
Viresh Kumare15d8302013-06-19 14:22:55 +0530480 if (!result)
481 perf->state = next_perf_state;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500482
Mike Travis4d8bb532009-01-04 05:18:08 -0800483out:
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700484 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485}
486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487static unsigned long
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700488acpi_cpufreq_guess_freq(struct acpi_cpufreq_data *data, unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489{
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200490 struct acpi_processor_performance *perf;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500491
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200492 perf = to_perf_data(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 if (cpu_khz) {
494 /* search the closest match to cpu_khz */
495 unsigned int i;
496 unsigned long freq;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500497 unsigned long freqn = perf->states[0].core_frequency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Dave Jones3a58df32009-01-17 22:36:14 -0500499 for (i = 0; i < (perf->state_count-1); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 freq = freqn;
Dave Jones95dd7222006-10-18 00:41:48 -0400501 freqn = perf->states[i+1].core_frequency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 if ((2 * cpu_khz) > (freqn + freq)) {
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500503 perf->state = i;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700504 return freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 }
506 }
Dave Jones95dd7222006-10-18 00:41:48 -0400507 perf->state = perf->state_count-1;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700508 return freqn;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500509 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 /* assume CPU is at P0... */
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500511 perf->state = 0;
512 return perf->states[0].core_frequency * 1000;
513 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514}
515
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800516static void free_acpi_perf_data(void)
517{
518 unsigned int i;
519
520 /* Freeing a NULL pointer is OK, and alloc_percpu zeroes. */
521 for_each_possible_cpu(i)
522 free_cpumask_var(per_cpu_ptr(acpi_perf_data, i)
523 ->shared_cpu_map);
524 free_percpu(acpi_perf_data);
525}
526
Andre Przywara615b7302012-09-04 08:28:07 +0000527static int boost_notify(struct notifier_block *nb, unsigned long action,
528 void *hcpu)
529{
530 unsigned cpu = (long)hcpu;
531 const struct cpumask *cpumask;
532
533 cpumask = get_cpu_mask(cpu);
534
535 /*
536 * Clear the boost-disable bit on the CPU_DOWN path so that
537 * this cpu cannot block the remaining ones from boosting. On
538 * the CPU_UP path we simply keep the boost-disable flag in
539 * sync with the current global state.
540 */
541
542 switch (action) {
543 case CPU_UP_PREPARE:
544 case CPU_UP_PREPARE_FROZEN:
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100545 boost_set_msrs(acpi_cpufreq_driver.boost_enabled, cpumask);
Andre Przywara615b7302012-09-04 08:28:07 +0000546 break;
547
548 case CPU_DOWN_PREPARE:
549 case CPU_DOWN_PREPARE_FROZEN:
550 boost_set_msrs(1, cpumask);
551 break;
552
553 default:
554 break;
555 }
556
557 return NOTIFY_OK;
558}
559
560
561static struct notifier_block boost_nb = {
562 .notifier_call = boost_notify,
563};
564
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500565/*
566 * acpi_cpufreq_early_init - initialize ACPI P-States library
567 *
568 * Initialize the ACPI P-States library (drivers/acpi/processor_perflib.c)
569 * in order to determine correct frequency and voltage pairings. We can
570 * do _PDC and _PSD and find out the processor dependency for the
571 * actual init that will happen later...
572 */
Fenghua Yu50109292007-08-07 18:40:30 -0400573static int __init acpi_cpufreq_early_init(void)
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500574{
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800575 unsigned int i;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200576 pr_debug("acpi_cpufreq_early_init\n");
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500577
Fenghua Yu50109292007-08-07 18:40:30 -0400578 acpi_perf_data = alloc_percpu(struct acpi_processor_performance);
579 if (!acpi_perf_data) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200580 pr_debug("Memory allocation error for acpi_perf_data.\n");
Fenghua Yu50109292007-08-07 18:40:30 -0400581 return -ENOMEM;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500582 }
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800583 for_each_possible_cpu(i) {
Yinghai Lueaa95842009-06-06 14:51:36 -0700584 if (!zalloc_cpumask_var_node(
Mike Travis80855f72008-12-31 18:08:47 -0800585 &per_cpu_ptr(acpi_perf_data, i)->shared_cpu_map,
586 GFP_KERNEL, cpu_to_node(i))) {
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800587
588 /* Freeing a NULL pointer is OK: alloc_percpu zeroes. */
589 free_acpi_perf_data();
590 return -ENOMEM;
591 }
592 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500593
594 /* Do initialization in ACPI core */
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700595 acpi_processor_preregister_performance(acpi_perf_data);
596 return 0;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500597}
598
Dave Jones95625b82006-10-21 01:37:39 -0400599#ifdef CONFIG_SMP
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700600/*
601 * Some BIOSes do SW_ANY coordination internally, either set it up in hw
602 * or do it in BIOS firmware and won't inform about it to OS. If not
603 * detected, this has a side effect of making CPU run at a different speed
604 * than OS intended it to run at. Detect it and handle it cleanly.
605 */
606static int bios_with_sw_any_bug;
607
Jeff Garzik18552562007-10-03 15:15:40 -0400608static int sw_any_bug_found(const struct dmi_system_id *d)
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700609{
610 bios_with_sw_any_bug = 1;
611 return 0;
612}
613
Jeff Garzik18552562007-10-03 15:15:40 -0400614static const struct dmi_system_id sw_any_bug_dmi_table[] = {
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700615 {
616 .callback = sw_any_bug_found,
617 .ident = "Supermicro Server X6DLP",
618 .matches = {
619 DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
620 DMI_MATCH(DMI_BIOS_VERSION, "080010"),
621 DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"),
622 },
623 },
624 { }
625};
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400626
627static int acpi_cpufreq_blacklist(struct cpuinfo_x86 *c)
628{
John Villalovos293afe42009-09-25 13:30:08 -0400629 /* Intel Xeon Processor 7100 Series Specification Update
630 * http://www.intel.com/Assets/PDF/specupdate/314554.pdf
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400631 * AL30: A Machine Check Exception (MCE) Occurring during an
632 * Enhanced Intel SpeedStep Technology Ratio Change May Cause
John Villalovos293afe42009-09-25 13:30:08 -0400633 * Both Processor Cores to Lock Up. */
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400634 if (c->x86_vendor == X86_VENDOR_INTEL) {
635 if ((c->x86 == 15) &&
636 (c->x86_model == 6) &&
John Villalovos293afe42009-09-25 13:30:08 -0400637 (c->x86_mask == 8)) {
638 printk(KERN_INFO "acpi-cpufreq: Intel(R) "
639 "Xeon(R) 7100 Errata AL30, processors may "
640 "lock up on frequency changes: disabling "
641 "acpi-cpufreq.\n");
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400642 return -ENODEV;
John Villalovos293afe42009-09-25 13:30:08 -0400643 }
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400644 }
645 return 0;
646}
Dave Jones95625b82006-10-21 01:37:39 -0400647#endif
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700648
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700649static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650{
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700651 unsigned int i;
652 unsigned int valid_states = 0;
653 unsigned int cpu = policy->cpu;
654 struct acpi_cpufreq_data *data;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700655 unsigned int result = 0;
Mike Travis92cb7612007-10-19 20:35:04 +0200656 struct cpuinfo_x86 *c = &cpu_data(policy->cpu);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700657 struct acpi_processor_performance *perf;
John Villalovos293afe42009-09-25 13:30:08 -0400658#ifdef CONFIG_SMP
659 static int blacklisted;
660#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200662 pr_debug("acpi_cpufreq_cpu_init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400664#ifdef CONFIG_SMP
John Villalovos293afe42009-09-25 13:30:08 -0400665 if (blacklisted)
666 return blacklisted;
667 blacklisted = acpi_cpufreq_blacklist(c);
668 if (blacklisted)
669 return blacklisted;
Prarit Bhargava1a8e42f2009-08-26 13:19:37 -0400670#endif
671
Viresh Kumard5b73cd2013-08-06 22:53:06 +0530672 data = kzalloc(sizeof(*data), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 if (!data)
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700674 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800676 if (!zalloc_cpumask_var(&data->freqdomain_cpus, GFP_KERNEL)) {
677 result = -ENOMEM;
678 goto err_free;
679 }
680
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200681 perf = per_cpu_ptr(acpi_perf_data, cpu);
Pan Xinhui8cfcfd32015-07-10 14:36:20 +0800682 data->acpi_perf_cpu = cpu;
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800683 policy->driver_data = data;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700684
Dave Jones95dd7222006-10-18 00:41:48 -0400685 if (cpu_has(c, X86_FEATURE_CONSTANT_TSC))
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700686 acpi_cpufreq_driver.flags |= CPUFREQ_CONST_LOOPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Rafael J. Wysocki34276162015-07-22 22:11:56 +0200688 result = acpi_processor_register_performance(perf, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 if (result)
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800690 goto err_free_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500692 policy->shared_type = perf->shared_type;
Dave Jones95dd7222006-10-18 00:41:48 -0400693
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400694 /*
Dave Jones95dd7222006-10-18 00:41:48 -0400695 * Will let policy->cpus know about dependency only when software
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400696 * coordination is required.
697 */
698 if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700699 policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
Rusty Russell835481d2009-01-04 05:18:06 -0800700 cpumask_copy(policy->cpus, perf->shared_cpu_map);
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700701 }
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800702 cpumask_copy(data->freqdomain_cpus, perf->shared_cpu_map);
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700703
704#ifdef CONFIG_SMP
705 dmi_check_system(sw_any_bug_dmi_table);
Fabio Baltieri2624f902013-01-31 09:44:40 +0000706 if (bios_with_sw_any_bug && !policy_is_shared(policy)) {
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700707 policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
Bartosz Golaszewski3280c3c2015-05-26 15:11:33 +0200708 cpumask_copy(policy->cpus, topology_core_cpumask(cpu));
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700709 }
Andre Przywaraacd31622012-09-04 08:28:03 +0000710
711 if (check_amd_hwpstate_cpu(cpu) && !acpi_pstate_strict) {
712 cpumask_clear(policy->cpus);
713 cpumask_set_cpu(cpu, policy->cpus);
Bartosz Golaszewski3280c3c2015-05-26 15:11:33 +0200714 cpumask_copy(data->freqdomain_cpus,
715 topology_sibling_cpumask(cpu));
Andre Przywaraacd31622012-09-04 08:28:03 +0000716 policy->shared_type = CPUFREQ_SHARED_TYPE_HW;
717 pr_info_once(PFX "overriding BIOS provided _PSD data\n");
718 }
Venkatesh Pallipadi8adcc0c2006-09-01 14:02:24 -0700719#endif
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500720
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 /* capability check */
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500722 if (perf->state_count <= 1) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200723 pr_debug("No P-States\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 result = -ENODEV;
725 goto err_unreg;
726 }
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500727
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700728 if (perf->control_register.space_id != perf->status_register.space_id) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 result = -ENODEV;
730 goto err_unreg;
731 }
732
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700733 switch (perf->control_register.space_id) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700734 case ACPI_ADR_SPACE_SYSTEM_IO:
Matthew Garrettc40a4512013-01-20 10:24:26 +0000735 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
736 boot_cpu_data.x86 == 0xf) {
737 pr_debug("AMD K8 systems must use native drivers.\n");
738 result = -ENODEV;
739 goto err_unreg;
740 }
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200741 pr_debug("SYSTEM IO addr space\n");
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700742 data->cpu_feature = SYSTEM_IO_CAPABLE;
743 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700744 case ACPI_ADR_SPACE_FIXED_HARDWARE:
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200745 pr_debug("HARDWARE addr space\n");
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000746 if (check_est_cpu(cpu)) {
747 data->cpu_feature = SYSTEM_INTEL_MSR_CAPABLE;
748 break;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700749 }
Matthew Garrett3dc9a632012-09-04 08:28:02 +0000750 if (check_amd_hwpstate_cpu(cpu)) {
751 data->cpu_feature = SYSTEM_AMD_MSR_CAPABLE;
752 break;
753 }
754 result = -ENODEV;
755 goto err_unreg;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700756 default:
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200757 pr_debug("Unknown addr space %d\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700758 (u32) (perf->control_register.space_id));
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700759 result = -ENODEV;
760 goto err_unreg;
761 }
762
Viresh Kumar71508a12014-03-28 19:11:46 +0530763 data->freq_table = kzalloc(sizeof(*data->freq_table) *
Dave Jones95dd7222006-10-18 00:41:48 -0400764 (perf->state_count+1), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 if (!data->freq_table) {
766 result = -ENOMEM;
767 goto err_unreg;
768 }
769
770 /* detect transition latency */
771 policy->cpuinfo.transition_latency = 0;
Dave Jones3a58df32009-01-17 22:36:14 -0500772 for (i = 0; i < perf->state_count; i++) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700773 if ((perf->states[i].transition_latency * 1000) >
774 policy->cpuinfo.transition_latency)
775 policy->cpuinfo.transition_latency =
776 perf->states[i].transition_latency * 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700779 /* Check for high latency (>20uS) from buggy BIOSes, like on T42 */
780 if (perf->control_register.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE &&
781 policy->cpuinfo.transition_latency > 20 * 1000) {
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700782 policy->cpuinfo.transition_latency = 20 * 1000;
Joe Perches61c8c672009-05-26 14:58:39 -0700783 printk_once(KERN_INFO
784 "P-state transition latency capped at 20 uS\n");
Pallipadi, Venkatesha59d1632009-03-19 14:41:40 -0700785 }
786
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 /* table init */
Dave Jones3a58df32009-01-17 22:36:14 -0500788 for (i = 0; i < perf->state_count; i++) {
789 if (i > 0 && perf->states[i].core_frequency >=
Zhang Rui3cdf5522007-06-13 21:24:02 -0400790 data->freq_table[valid_states-1].frequency / 1000)
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700791 continue;
792
Viresh Kumar50701582013-03-30 16:25:15 +0530793 data->freq_table[valid_states].driver_data = i;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700794 data->freq_table[valid_states].frequency =
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700795 perf->states[i].core_frequency * 1000;
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700796 valid_states++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 }
Venkatesh Pallipadi3d4a7ef2006-11-13 17:47:44 -0800798 data->freq_table[valid_states].frequency = CPUFREQ_TABLE_END;
Venkatesh Pallipadi8edc59d92006-12-19 12:58:55 -0800799 perf->state = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
Viresh Kumar776b57b2013-09-16 18:56:07 +0530801 result = cpufreq_table_validate_and_show(policy, data->freq_table);
Dave Jones95dd7222006-10-18 00:41:48 -0400802 if (result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 goto err_freqfree;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Thomas Renningerd876dfb2009-04-17 16:22:08 +0200805 if (perf->states[0].core_frequency * 1000 != policy->cpuinfo.max_freq)
806 printk(KERN_WARNING FW_WARN "P-state 0 is not max freq\n");
807
Mattia Dongilia507ac42006-12-15 19:52:45 +0100808 switch (perf->control_register.space_id) {
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700809 case ACPI_ADR_SPACE_SYSTEM_IO:
Viresh Kumar1bab64d2013-10-16 23:58:10 +0200810 /*
811 * The core will not set policy->cur, because
812 * cpufreq_driver->get is NULL, so we need to set it here.
813 * However, we have to guess it, because the current speed is
814 * unknown and not detectable via IO ports.
815 */
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700816 policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);
817 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700818 case ACPI_ADR_SPACE_FIXED_HARDWARE:
Venkatesh Pallipadi7650b282006-10-03 12:36:30 -0700819 acpi_cpufreq_driver.get = get_cur_freq_on_cpu;
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700820 break;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700821 default:
Venkatesh Pallipadidde9f7b2006-10-03 12:33:14 -0700822 break;
823 }
824
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 /* notify BIOS that we exist */
826 acpi_processor_notify_smm(THIS_MODULE);
827
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200828 pr_debug("CPU%u - ACPI performance management activated.\n", cpu);
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500829 for (i = 0; i < perf->state_count; i++)
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200830 pr_debug(" %cP%d: %d MHz, %d mW, %d uS\n",
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700831 (i == perf->state ? '*' : ' '), i,
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500832 (u32) perf->states[i].core_frequency,
833 (u32) perf->states[i].power,
834 (u32) perf->states[i].transition_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Dominik Brodowski4b31e772005-05-18 13:49:00 -0400836 /*
837 * the first call to ->target() should result in us actually
838 * writing something to the appropriate registers.
839 */
840 data->resume = 1;
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700841
Venkatesh Pallipadife27cb32006-10-03 12:29:15 -0700842 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
Dave Jones95dd7222006-10-18 00:41:48 -0400844err_freqfree:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 kfree(data->freq_table);
Dave Jones95dd7222006-10-18 00:41:48 -0400846err_unreg:
Rafael J. Wysockib2f8dc42015-07-22 22:11:16 +0200847 acpi_processor_unregister_performance(cpu);
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800848err_free_mask:
849 free_cpumask_var(data->freqdomain_cpus);
Dave Jones95dd7222006-10-18 00:41:48 -0400850err_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 kfree(data);
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800852 policy->driver_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700854 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855}
856
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700857static int acpi_cpufreq_cpu_exit(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800859 struct acpi_cpufreq_data *data = policy->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200861 pr_debug("acpi_cpufreq_cpu_exit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
863 if (data) {
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800864 policy->driver_data = NULL;
Rafael J. Wysockib2f8dc42015-07-22 22:11:16 +0200865 acpi_processor_unregister_performance(data->acpi_perf_cpu);
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800866 free_cpumask_var(data->freqdomain_cpus);
Zhang Ruidab5fff2010-10-12 09:09:37 +0800867 kfree(data->freq_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 kfree(data);
869 }
870
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700871 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872}
873
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700874static int acpi_cpufreq_resume(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875{
Pan Xinhuieb0b3e72015-07-07 20:43:26 +0800876 struct acpi_cpufreq_data *data = policy->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200878 pr_debug("acpi_cpufreq_resume\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
880 data->resume = 1;
881
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700882 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883}
884
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700885static struct freq_attr *acpi_cpufreq_attr[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 &cpufreq_freq_attr_scaling_available_freqs,
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800887 &freqdomain_cpus,
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200888#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
889 &cpb,
890#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 NULL,
892};
893
894static struct cpufreq_driver acpi_cpufreq_driver = {
Viresh Kumardb9be212013-10-03 20:27:56 +0530895 .verify = cpufreq_generic_frequency_table_verify,
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530896 .target_index = acpi_cpufreq_target,
Thomas Renningere2f74f32009-11-19 12:31:01 +0100897 .bios_limit = acpi_processor_get_bios_limit,
898 .init = acpi_cpufreq_cpu_init,
899 .exit = acpi_cpufreq_cpu_exit,
900 .resume = acpi_cpufreq_resume,
901 .name = "acpi-cpufreq",
Thomas Renningere2f74f32009-11-19 12:31:01 +0100902 .attr = acpi_cpufreq_attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903};
904
Andre Przywara615b7302012-09-04 08:28:07 +0000905static void __init acpi_cpufreq_boost_init(void)
906{
907 if (boot_cpu_has(X86_FEATURE_CPB) || boot_cpu_has(X86_FEATURE_IDA)) {
908 msrs = msrs_alloc();
909
910 if (!msrs)
911 return;
912
Rafael J. Wysocki7a6c79f2015-12-27 00:27:38 +0100913 acpi_cpufreq_driver.set_boost = set_boost;
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100914 acpi_cpufreq_driver.boost_enabled = boost_state(0);
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530915
916 cpu_notifier_register_begin();
Andre Przywara615b7302012-09-04 08:28:07 +0000917
918 /* Force all MSRs to the same value */
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100919 boost_set_msrs(acpi_cpufreq_driver.boost_enabled,
920 cpu_online_mask);
Andre Przywara615b7302012-09-04 08:28:07 +0000921
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530922 __register_cpu_notifier(&boost_nb);
Andre Przywara615b7302012-09-04 08:28:07 +0000923
Srivatsa S. Bhat0197fbd2014-03-11 02:10:06 +0530924 cpu_notifier_register_done();
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100925 }
Andre Przywara615b7302012-09-04 08:28:07 +0000926}
927
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500928static void acpi_cpufreq_boost_exit(void)
Andre Przywara615b7302012-09-04 08:28:07 +0000929{
Andre Przywara615b7302012-09-04 08:28:07 +0000930 if (msrs) {
931 unregister_cpu_notifier(&boost_nb);
932
933 msrs_free(msrs);
934 msrs = NULL;
935 }
936}
937
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700938static int __init acpi_cpufreq_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939{
Fenghua Yu50109292007-08-07 18:40:30 -0400940 int ret;
941
Rafael J. Wysocki75c07582013-10-25 16:22:47 +0200942 if (acpi_disabled)
943 return -ENODEV;
944
Yinghai Lu8a61e122013-09-20 10:43:56 -0700945 /* don't keep reloading if cpufreq_driver exists */
946 if (cpufreq_get_current_driver())
Rafael J. Wysocki75c07582013-10-25 16:22:47 +0200947 return -EEXIST;
Yinghai Luee297532008-09-24 19:04:31 -0700948
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200949 pr_debug("acpi_cpufreq_init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
Fenghua Yu50109292007-08-07 18:40:30 -0400951 ret = acpi_cpufreq_early_init();
952 if (ret)
953 return ret;
Venkatesh Pallipadi09b4d1e2005-12-14 15:05:00 -0500954
Andre Przywara11269ff2012-09-04 08:28:08 +0000955#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
956 /* this is a sysfs file with a strange name and an even stranger
957 * semantic - per CPU instantiation, but system global effect.
958 * Lets enable it only on AMD CPUs for compatibility reasons and
959 * only if configured. This is considered legacy code, which
960 * will probably be removed at some point in the future.
961 */
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200962 if (!check_amd_hwpstate_cpu(0)) {
963 struct freq_attr **attr;
Andre Przywara11269ff2012-09-04 08:28:08 +0000964
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200965 pr_debug("CPB unsupported, do not expose it\n");
Andre Przywara11269ff2012-09-04 08:28:08 +0000966
Rafael J. Wysockif56c50e2015-07-22 22:12:10 +0200967 for (attr = acpi_cpufreq_attr; *attr; attr++)
968 if (*attr == &cpb) {
969 *attr = NULL;
970 break;
971 }
Andre Przywara11269ff2012-09-04 08:28:08 +0000972 }
973#endif
Lukasz Majewskicfc9c8e2013-12-20 15:24:50 +0100974 acpi_cpufreq_boost_init();
Andre Przywara11269ff2012-09-04 08:28:08 +0000975
Akinobu Mita847aef62008-07-14 11:59:44 +0900976 ret = cpufreq_register_driver(&acpi_cpufreq_driver);
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500977 if (ret) {
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800978 free_acpi_perf_data();
Konrad Rzeszutek Wilkeb8c68e2014-01-27 22:50:35 -0500979 acpi_cpufreq_boost_exit();
980 }
Akinobu Mita847aef62008-07-14 11:59:44 +0900981 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982}
983
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700984static void __exit acpi_cpufreq_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985{
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200986 pr_debug("acpi_cpufreq_exit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987
Andre Przywara615b7302012-09-04 08:28:07 +0000988 acpi_cpufreq_boost_exit();
989
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 cpufreq_unregister_driver(&acpi_cpufreq_driver);
991
Luming Yu50f4ddd2011-07-08 16:37:44 -0400992 free_acpi_perf_data();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993}
994
Venkatesh Pallipadid395bf12005-08-25 15:59:00 -0400995module_param(acpi_pstate_strict, uint, 0644);
Venkatesh Pallipadi64be7ee2006-10-03 12:35:23 -0700996MODULE_PARM_DESC(acpi_pstate_strict,
Dave Jones95dd7222006-10-18 00:41:48 -0400997 "value 0 or non-zero. non-zero -> strict ACPI checks are "
998 "performed during frequency changes.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999
1000late_initcall(acpi_cpufreq_init);
1001module_exit(acpi_cpufreq_exit);
1002
Matthew Garrettefa17192013-01-22 22:33:46 +01001003static const struct x86_cpu_id acpi_cpufreq_ids[] = {
1004 X86_FEATURE_MATCH(X86_FEATURE_ACPI),
1005 X86_FEATURE_MATCH(X86_FEATURE_HW_PSTATE),
1006 {}
1007};
1008MODULE_DEVICE_TABLE(x86cpu, acpi_cpufreq_ids);
1009
Rafael J. Wysockic655aff2013-06-07 13:13:31 +02001010static const struct acpi_device_id processor_device_ids[] = {
1011 {ACPI_PROCESSOR_OBJECT_HID, },
1012 {ACPI_PROCESSOR_DEVICE_HID, },
1013 {},
1014};
1015MODULE_DEVICE_TABLE(acpi, processor_device_ids);
1016
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017MODULE_ALIAS("acpi");