blob: d80b2d1441afbadb561cf58abfdb135dd20aeb8e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * processor_perflib.c - ACPI Processor P-States Library ($Revision: 71 $)
3 *
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) 2004 Dominik Brodowski <linux@brodo.de>
7 * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
8 * - Added processor hotplug support
9 *
10 *
11 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or (at
16 * your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License along
24 * with this program; if not, write to the Free Software Foundation, Inc.,
25 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
26 *
27 */
28
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/kernel.h>
30#include <linux/module.h>
31#include <linux/init.h>
32#include <linux/cpufreq.h>
33
34#ifdef CONFIG_X86_ACPI_CPUFREQ_PROC_INTF
35#include <linux/proc_fs.h>
36#include <linux/seq_file.h>
Arjan van de Ven65c19bb2006-04-27 05:25:00 -040037#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#include <asm/uaccess.h>
40#endif
41
42#include <acpi/acpi_bus.h>
43#include <acpi/processor.h>
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define ACPI_PROCESSOR_COMPONENT 0x01000000
46#define ACPI_PROCESSOR_CLASS "processor"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#define ACPI_PROCESSOR_FILE_PERFORMANCE "performance"
48#define _COMPONENT ACPI_PROCESSOR_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050049ACPI_MODULE_NAME("processor_perflib");
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Arjan van de Ven65c19bb2006-04-27 05:25:00 -040051static DEFINE_MUTEX(performance_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Thomas Renninger919158d2007-10-31 15:41:42 +010053/* Use cpufreq debug layer for _PPC changes. */
54#define cpufreq_printk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
55 "cpufreq-core", msg)
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057/*
58 * _PPC support is implemented as a CPUfreq policy notifier:
59 * This means each time a CPUfreq driver registered also with
60 * the ACPI core is asked to change the speed policy, the maximum
61 * value is adjusted so that it is within the platform limit.
62 *
63 * Also, when a new platform limit value is detected, the CPUfreq
64 * policy is adjusted accordingly.
65 */
66
Thomas Renninger623b78c2007-05-18 21:59:28 -050067static unsigned int ignore_ppc = 0;
68module_param(ignore_ppc, uint, 0644);
69MODULE_PARM_DESC(ignore_ppc, "If the frequency of your machine gets wrongly" \
70 "limited by BIOS, this should help");
71
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#define PPC_REGISTERED 1
73#define PPC_IN_USE 2
74
75static int acpi_processor_ppc_status = 0;
76
77static int acpi_processor_ppc_notifier(struct notifier_block *nb,
Len Brown4be44fc2005-08-05 00:44:28 -040078 unsigned long event, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070079{
80 struct cpufreq_policy *policy = data;
81 struct acpi_processor *pr;
82 unsigned int ppc = 0;
83
Thomas Renninger623b78c2007-05-18 21:59:28 -050084 if (ignore_ppc)
85 return 0;
86
Arjan van de Ven65c19bb2006-04-27 05:25:00 -040087 mutex_lock(&performance_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89 if (event != CPUFREQ_INCOMPATIBLE)
90 goto out;
91
92 pr = processors[policy->cpu];
93 if (!pr || !pr->performance)
94 goto out;
95
Len Brown4be44fc2005-08-05 00:44:28 -040096 ppc = (unsigned int)pr->performance_platform_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Dave Jones0916bd32006-11-22 20:42:01 -050098 if (ppc >= pr->performance->state_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 goto out;
100
101 cpufreq_verify_within_limits(policy, 0,
Len Brown4be44fc2005-08-05 00:44:28 -0400102 pr->performance->states[ppc].
103 core_frequency * 1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
Len Brown4be44fc2005-08-05 00:44:28 -0400105 out:
Arjan van de Ven65c19bb2006-04-27 05:25:00 -0400106 mutex_unlock(&performance_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108 return 0;
109}
110
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111static struct notifier_block acpi_ppc_notifier_block = {
112 .notifier_call = acpi_processor_ppc_notifier,
113};
114
Len Brown4be44fc2005-08-05 00:44:28 -0400115static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
Len Brown4be44fc2005-08-05 00:44:28 -0400117 acpi_status status = 0;
118 unsigned long ppc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
121 if (!pr)
Patrick Mocheld550d982006-06-27 00:41:40 -0400122 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124 /*
125 * _PPC indicates the maximum state currently supported by the platform
126 * (e.g. 0 = states 0..n; 1 = states 1..n; etc.
127 */
128 status = acpi_evaluate_integer(pr->handle, "_PPC", NULL, &ppc);
129
130 if (status != AE_NOT_FOUND)
131 acpi_processor_ppc_status |= PPC_IN_USE;
132
Len Brown4be44fc2005-08-05 00:44:28 -0400133 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400134 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PPC"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400135 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 }
137
Thomas Renninger919158d2007-10-31 15:41:42 +0100138 cpufreq_printk("CPU %d: _PPC is %d - frequency %s limited\n", pr->id,
139 (int)ppc, ppc ? "" : "not");
140
Len Brown4be44fc2005-08-05 00:44:28 -0400141 pr->performance_platform_limit = (int)ppc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
Patrick Mocheld550d982006-06-27 00:41:40 -0400143 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144}
145
Len Brown4be44fc2005-08-05 00:44:28 -0400146int acpi_processor_ppc_has_changed(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
Thomas Renninger623b78c2007-05-18 21:59:28 -0500148 int ret;
149
150 if (ignore_ppc)
151 return 0;
152
153 ret = acpi_processor_get_platform_limit(pr);
154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 if (ret < 0)
156 return (ret);
157 else
158 return cpufreq_update_policy(pr->id);
159}
160
Len Brown4be44fc2005-08-05 00:44:28 -0400161void acpi_processor_ppc_init(void)
162{
163 if (!cpufreq_register_notifier
164 (&acpi_ppc_notifier_block, CPUFREQ_POLICY_NOTIFIER))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 acpi_processor_ppc_status |= PPC_REGISTERED;
166 else
Len Brown4be44fc2005-08-05 00:44:28 -0400167 printk(KERN_DEBUG
168 "Warning: Processor Platform Limit not supported.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169}
170
Len Brown4be44fc2005-08-05 00:44:28 -0400171void acpi_processor_ppc_exit(void)
172{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 if (acpi_processor_ppc_status & PPC_REGISTERED)
Len Brown4be44fc2005-08-05 00:44:28 -0400174 cpufreq_unregister_notifier(&acpi_ppc_notifier_block,
175 CPUFREQ_POLICY_NOTIFIER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
177 acpi_processor_ppc_status &= ~PPC_REGISTERED;
178}
179
Len Brown4be44fc2005-08-05 00:44:28 -0400180static int acpi_processor_get_performance_control(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181{
Len Brown4be44fc2005-08-05 00:44:28 -0400182 int result = 0;
183 acpi_status status = 0;
184 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
185 union acpi_object *pct = NULL;
186 union acpi_object obj = { 0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
189 status = acpi_evaluate_object(pr->handle, "_PCT", NULL, &buffer);
Len Brown4be44fc2005-08-05 00:44:28 -0400190 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400191 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PCT"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400192 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 }
194
Len Brown4be44fc2005-08-05 00:44:28 -0400195 pct = (union acpi_object *)buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 if (!pct || (pct->type != ACPI_TYPE_PACKAGE)
Len Brown4be44fc2005-08-05 00:44:28 -0400197 || (pct->package.count != 2)) {
Len Brown64684632006-06-26 23:41:38 -0400198 printk(KERN_ERR PREFIX "Invalid _PCT data\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 result = -EFAULT;
200 goto end;
201 }
202
203 /*
204 * control_register
205 */
206
207 obj = pct->package.elements[0];
208
209 if ((obj.type != ACPI_TYPE_BUFFER)
Len Brown4be44fc2005-08-05 00:44:28 -0400210 || (obj.buffer.length < sizeof(struct acpi_pct_register))
211 || (obj.buffer.pointer == NULL)) {
Len Brown64684632006-06-26 23:41:38 -0400212 printk(KERN_ERR PREFIX "Invalid _PCT data (control_register)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 result = -EFAULT;
214 goto end;
215 }
Len Brown4be44fc2005-08-05 00:44:28 -0400216 memcpy(&pr->performance->control_register, obj.buffer.pointer,
217 sizeof(struct acpi_pct_register));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
219 /*
220 * status_register
221 */
222
223 obj = pct->package.elements[1];
224
225 if ((obj.type != ACPI_TYPE_BUFFER)
Len Brown4be44fc2005-08-05 00:44:28 -0400226 || (obj.buffer.length < sizeof(struct acpi_pct_register))
227 || (obj.buffer.pointer == NULL)) {
Len Brown64684632006-06-26 23:41:38 -0400228 printk(KERN_ERR PREFIX "Invalid _PCT data (status_register)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 result = -EFAULT;
230 goto end;
231 }
232
Len Brown4be44fc2005-08-05 00:44:28 -0400233 memcpy(&pr->performance->status_register, obj.buffer.pointer,
234 sizeof(struct acpi_pct_register));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
Len Brown4be44fc2005-08-05 00:44:28 -0400236 end:
Len Brown02438d82006-06-30 03:19:10 -0400237 kfree(buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Patrick Mocheld550d982006-06-27 00:41:40 -0400239 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240}
241
Len Brown4be44fc2005-08-05 00:44:28 -0400242static int acpi_processor_get_performance_states(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
Len Brown4be44fc2005-08-05 00:44:28 -0400244 int result = 0;
245 acpi_status status = AE_OK;
246 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
247 struct acpi_buffer format = { sizeof("NNNNNN"), "NNNNNN" };
248 struct acpi_buffer state = { 0, NULL };
249 union acpi_object *pss = NULL;
250 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 status = acpi_evaluate_object(pr->handle, "_PSS", NULL, &buffer);
Len Brown4be44fc2005-08-05 00:44:28 -0400254 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400255 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PSS"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400256 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
258
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200259 pss = buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 if (!pss || (pss->type != ACPI_TYPE_PACKAGE)) {
Len Brown64684632006-06-26 23:41:38 -0400261 printk(KERN_ERR PREFIX "Invalid _PSS data\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 result = -EFAULT;
263 goto end;
264 }
265
266 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d performance states\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400267 pss->package.count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
269 pr->performance->state_count = pss->package.count;
Len Brown4be44fc2005-08-05 00:44:28 -0400270 pr->performance->states =
271 kmalloc(sizeof(struct acpi_processor_px) * pss->package.count,
272 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 if (!pr->performance->states) {
274 result = -ENOMEM;
275 goto end;
276 }
277
278 for (i = 0; i < pr->performance->state_count; i++) {
279
280 struct acpi_processor_px *px = &(pr->performance->states[i]);
281
282 state.length = sizeof(struct acpi_processor_px);
283 state.pointer = px;
284
285 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
286
287 status = acpi_extract_package(&(pss->package.elements[i]),
Len Brown4be44fc2005-08-05 00:44:28 -0400288 &format, &state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400290 ACPI_EXCEPTION((AE_INFO, status, "Invalid _PSS data"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 result = -EFAULT;
292 kfree(pr->performance->states);
293 goto end;
294 }
295
296 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400297 "State [%d]: core_frequency[%d] power[%d] transition_latency[%d] bus_master_latency[%d] control[0x%x] status[0x%x]\n",
298 i,
299 (u32) px->core_frequency,
300 (u32) px->power,
301 (u32) px->transition_latency,
302 (u32) px->bus_master_latency,
303 (u32) px->control, (u32) px->status));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
305 if (!px->core_frequency) {
Len Brown64684632006-06-26 23:41:38 -0400306 printk(KERN_ERR PREFIX
307 "Invalid _PSS data: freq is zero\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 result = -EFAULT;
309 kfree(pr->performance->states);
310 goto end;
311 }
312 }
313
Len Brown4be44fc2005-08-05 00:44:28 -0400314 end:
Len Brown02438d82006-06-30 03:19:10 -0400315 kfree(buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
Patrick Mocheld550d982006-06-27 00:41:40 -0400317 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318}
319
Len Brown4be44fc2005-08-05 00:44:28 -0400320static int acpi_processor_get_performance_info(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321{
Len Brown4be44fc2005-08-05 00:44:28 -0400322 int result = 0;
323 acpi_status status = AE_OK;
324 acpi_handle handle = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 if (!pr || !pr->performance || !pr->handle)
Patrick Mocheld550d982006-06-27 00:41:40 -0400328 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 status = acpi_get_handle(pr->handle, "_PCT", &handle);
331 if (ACPI_FAILURE(status)) {
332 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400333 "ACPI-based processor performance control unavailable\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400334 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 }
336
337 result = acpi_processor_get_performance_control(pr);
338 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400339 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
341 result = acpi_processor_get_performance_states(pr);
342 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400343 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Patrick Mocheld550d982006-06-27 00:41:40 -0400345 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346}
347
Len Brown4be44fc2005-08-05 00:44:28 -0400348int acpi_processor_notify_smm(struct module *calling_module)
349{
350 acpi_status status;
351 static int is_done = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
354 if (!(acpi_processor_ppc_status & PPC_REGISTERED))
Patrick Mocheld550d982006-06-27 00:41:40 -0400355 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
357 if (!try_module_get(calling_module))
Patrick Mocheld550d982006-06-27 00:41:40 -0400358 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
360 /* is_done is set to negative if an error occured,
361 * and to postitive if _no_ error occured, but SMM
362 * was already notified. This avoids double notification
363 * which might lead to unexpected results...
364 */
365 if (is_done > 0) {
366 module_put(calling_module);
Patrick Mocheld550d982006-06-27 00:41:40 -0400367 return 0;
Len Brown4be44fc2005-08-05 00:44:28 -0400368 } else if (is_done < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 module_put(calling_module);
Patrick Mocheld550d982006-06-27 00:41:40 -0400370 return is_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 }
372
373 is_done = -EIO;
374
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300375 /* Can't write pstate_control to smi_command if either value is zero */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300376 if ((!acpi_gbl_FADT.smi_command) || (!acpi_gbl_FADT.pstate_control)) {
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300377 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No SMI port or pstate_control\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 module_put(calling_module);
Patrick Mocheld550d982006-06-27 00:41:40 -0400379 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 }
381
Len Brown4be44fc2005-08-05 00:44:28 -0400382 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300383 "Writing pstate_control [0x%x] to smi_command [0x%x]\n",
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300384 acpi_gbl_FADT.pstate_control, acpi_gbl_FADT.smi_command));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300386 status = acpi_os_write_port(acpi_gbl_FADT.smi_command,
387 (u32) acpi_gbl_FADT.pstate_control, 8);
Len Brown4be44fc2005-08-05 00:44:28 -0400388 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400389 ACPI_EXCEPTION((AE_INFO, status,
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300390 "Failed to write pstate_control [0x%x] to "
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300391 "smi_command [0x%x]", acpi_gbl_FADT.pstate_control,
392 acpi_gbl_FADT.smi_command));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 module_put(calling_module);
Patrick Mocheld550d982006-06-27 00:41:40 -0400394 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 }
396
397 /* Success. If there's no _PPC, we need to fear nothing, so
398 * we can allow the cpufreq driver to be rmmod'ed. */
399 is_done = 1;
400
401 if (!(acpi_processor_ppc_status & PPC_IN_USE))
402 module_put(calling_module);
403
Patrick Mocheld550d982006-06-27 00:41:40 -0400404 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
Len Brown4be44fc2005-08-05 00:44:28 -0400407EXPORT_SYMBOL(acpi_processor_notify_smm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
409#ifdef CONFIG_X86_ACPI_CPUFREQ_PROC_INTF
410/* /proc/acpi/processor/../performance interface (DEPRECATED) */
411
412static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file);
413static struct file_operations acpi_processor_perf_fops = {
Denis V. Lunevcf7acfa2008-04-29 01:02:27 -0700414 .owner = THIS_MODULE,
Len Brown4be44fc2005-08-05 00:44:28 -0400415 .open = acpi_processor_perf_open_fs,
416 .read = seq_read,
417 .llseek = seq_lseek,
418 .release = single_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419};
420
421static int acpi_processor_perf_seq_show(struct seq_file *seq, void *offset)
422{
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200423 struct acpi_processor *pr = seq->private;
Len Brown4be44fc2005-08-05 00:44:28 -0400424 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
427 if (!pr)
428 goto end;
429
430 if (!pr->performance) {
431 seq_puts(seq, "<not supported>\n");
432 goto end;
433 }
434
435 seq_printf(seq, "state count: %d\n"
Len Brown4be44fc2005-08-05 00:44:28 -0400436 "active state: P%d\n",
437 pr->performance->state_count, pr->performance->state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
439 seq_puts(seq, "states:\n");
440 for (i = 0; i < pr->performance->state_count; i++)
Len Brown4be44fc2005-08-05 00:44:28 -0400441 seq_printf(seq,
442 " %cP%d: %d MHz, %d mW, %d uS\n",
443 (i == pr->performance->state ? '*' : ' '), i,
444 (u32) pr->performance->states[i].core_frequency,
445 (u32) pr->performance->states[i].power,
446 (u32) pr->performance->states[i].transition_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
Len Brown4be44fc2005-08-05 00:44:28 -0400448 end:
Patrick Mocheld550d982006-06-27 00:41:40 -0400449 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450}
451
452static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file)
453{
454 return single_open(file, acpi_processor_perf_seq_show,
Len Brown4be44fc2005-08-05 00:44:28 -0400455 PDE(inode)->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456}
457
Len Brown4be44fc2005-08-05 00:44:28 -0400458static void acpi_cpufreq_add_file(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459{
Len Brown4be44fc2005-08-05 00:44:28 -0400460 struct acpi_device *device = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
463 if (acpi_bus_get_device(pr->handle, &device))
Patrick Mocheld550d982006-06-27 00:41:40 -0400464 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
466 /* add file 'performance' [R/W] */
Denis V. Lunevcf7acfa2008-04-29 01:02:27 -0700467 proc_create_data(ACPI_PROCESSOR_FILE_PERFORMANCE, S_IFREG | S_IRUGO,
468 acpi_device_dir(device),
469 &acpi_processor_perf_fops, acpi_driver_data(device));
Patrick Mocheld550d982006-06-27 00:41:40 -0400470 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471}
472
Len Brown4be44fc2005-08-05 00:44:28 -0400473static void acpi_cpufreq_remove_file(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474{
Len Brown4be44fc2005-08-05 00:44:28 -0400475 struct acpi_device *device = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
478 if (acpi_bus_get_device(pr->handle, &device))
Patrick Mocheld550d982006-06-27 00:41:40 -0400479 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
481 /* remove file 'performance' */
482 remove_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE,
Len Brown4be44fc2005-08-05 00:44:28 -0400483 acpi_device_dir(device));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
Patrick Mocheld550d982006-06-27 00:41:40 -0400485 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486}
487
488#else
Len Brown4be44fc2005-08-05 00:44:28 -0400489static void acpi_cpufreq_add_file(struct acpi_processor *pr)
490{
491 return;
492}
493static void acpi_cpufreq_remove_file(struct acpi_processor *pr)
494{
495 return;
496}
497#endif /* CONFIG_X86_ACPI_CPUFREQ_PROC_INTF */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500499static int acpi_processor_get_psd(struct acpi_processor *pr)
500{
501 int result = 0;
502 acpi_status status = AE_OK;
503 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
504 struct acpi_buffer format = {sizeof("NNNNN"), "NNNNN"};
505 struct acpi_buffer state = {0, NULL};
506 union acpi_object *psd = NULL;
507 struct acpi_psd_package *pdomain;
508
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500509 status = acpi_evaluate_object(pr->handle, "_PSD", NULL, &buffer);
510 if (ACPI_FAILURE(status)) {
Len Brown9011bff42006-05-11 00:28:12 -0400511 return -ENODEV;
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500512 }
513
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200514 psd = buffer.pointer;
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500515 if (!psd || (psd->type != ACPI_TYPE_PACKAGE)) {
516 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSD data\n"));
517 result = -EFAULT;
518 goto end;
519 }
520
521 if (psd->package.count != 1) {
522 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSD data\n"));
523 result = -EFAULT;
524 goto end;
525 }
526
527 pdomain = &(pr->performance->domain_info);
528
529 state.length = sizeof(struct acpi_psd_package);
530 state.pointer = pdomain;
531
532 status = acpi_extract_package(&(psd->package.elements[0]),
533 &format, &state);
534 if (ACPI_FAILURE(status)) {
535 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSD data\n"));
536 result = -EFAULT;
537 goto end;
538 }
539
540 if (pdomain->num_entries != ACPI_PSD_REV0_ENTRIES) {
541 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unknown _PSD:num_entries\n"));
542 result = -EFAULT;
543 goto end;
544 }
545
546 if (pdomain->revision != ACPI_PSD_REV0_REVISION) {
547 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unknown _PSD:revision\n"));
548 result = -EFAULT;
549 goto end;
550 }
551
552end:
Len Brown02438d82006-06-30 03:19:10 -0400553 kfree(buffer.pointer);
Len Brown9011bff42006-05-11 00:28:12 -0400554 return result;
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500555}
556
557int acpi_processor_preregister_performance(
Fenghua Yu50109292007-08-07 18:40:30 -0400558 struct acpi_processor_performance *performance)
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500559{
560 int count, count_target;
561 int retval = 0;
562 unsigned int i, j;
563 cpumask_t covered_cpus;
564 struct acpi_processor *pr;
565 struct acpi_psd_package *pdomain;
566 struct acpi_processor *match_pr;
567 struct acpi_psd_package *match_pdomain;
568
Len Brown785fccc2006-06-15 22:19:31 -0400569 mutex_lock(&performance_mutex);
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500570
571 retval = 0;
572
573 /* Call _PSD for all CPUs */
KAMEZAWA Hiroyuki193de0c2006-04-27 05:25:00 -0400574 for_each_possible_cpu(i) {
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500575 pr = processors[i];
576 if (!pr) {
577 /* Look only at processors in ACPI namespace */
578 continue;
579 }
580
581 if (pr->performance) {
582 retval = -EBUSY;
583 continue;
584 }
585
Fenghua Yu50109292007-08-07 18:40:30 -0400586 if (!performance || !percpu_ptr(performance, i)) {
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500587 retval = -EINVAL;
588 continue;
589 }
590
Fenghua Yu50109292007-08-07 18:40:30 -0400591 pr->performance = percpu_ptr(performance, i);
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500592 cpu_set(i, pr->performance->shared_cpu_map);
593 if (acpi_processor_get_psd(pr)) {
594 retval = -EINVAL;
595 continue;
596 }
597 }
598 if (retval)
599 goto err_ret;
600
601 /*
602 * Now that we have _PSD data from all CPUs, lets setup P-state
603 * domain info.
604 */
KAMEZAWA Hiroyuki193de0c2006-04-27 05:25:00 -0400605 for_each_possible_cpu(i) {
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500606 pr = processors[i];
607 if (!pr)
608 continue;
609
610 /* Basic validity check for domain info */
611 pdomain = &(pr->performance->domain_info);
612 if ((pdomain->revision != ACPI_PSD_REV0_REVISION) ||
613 (pdomain->num_entries != ACPI_PSD_REV0_ENTRIES)) {
614 retval = -EINVAL;
615 goto err_ret;
616 }
617 if (pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ALL &&
618 pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ANY &&
619 pdomain->coord_type != DOMAIN_COORD_TYPE_HW_ALL) {
620 retval = -EINVAL;
621 goto err_ret;
622 }
623 }
624
625 cpus_clear(covered_cpus);
KAMEZAWA Hiroyuki193de0c2006-04-27 05:25:00 -0400626 for_each_possible_cpu(i) {
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500627 pr = processors[i];
628 if (!pr)
629 continue;
630
631 if (cpu_isset(i, covered_cpus))
632 continue;
633
634 pdomain = &(pr->performance->domain_info);
635 cpu_set(i, pr->performance->shared_cpu_map);
636 cpu_set(i, covered_cpus);
637 if (pdomain->num_processors <= 1)
638 continue;
639
640 /* Validate the Domain info */
641 count_target = pdomain->num_processors;
642 count = 1;
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400643 if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ALL)
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500644 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL;
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400645 else if (pdomain->coord_type == DOMAIN_COORD_TYPE_HW_ALL)
646 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_HW;
647 else if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ANY)
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500648 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ANY;
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500649
KAMEZAWA Hiroyuki193de0c2006-04-27 05:25:00 -0400650 for_each_possible_cpu(j) {
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500651 if (i == j)
652 continue;
653
654 match_pr = processors[j];
655 if (!match_pr)
656 continue;
657
658 match_pdomain = &(match_pr->performance->domain_info);
659 if (match_pdomain->domain != pdomain->domain)
660 continue;
661
662 /* Here i and j are in the same domain */
663
664 if (match_pdomain->num_processors != count_target) {
665 retval = -EINVAL;
666 goto err_ret;
667 }
668
669 if (pdomain->coord_type != match_pdomain->coord_type) {
670 retval = -EINVAL;
671 goto err_ret;
672 }
673
674 cpu_set(j, covered_cpus);
675 cpu_set(j, pr->performance->shared_cpu_map);
676 count++;
677 }
678
KAMEZAWA Hiroyuki193de0c2006-04-27 05:25:00 -0400679 for_each_possible_cpu(j) {
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500680 if (i == j)
681 continue;
682
683 match_pr = processors[j];
684 if (!match_pr)
685 continue;
686
687 match_pdomain = &(match_pr->performance->domain_info);
688 if (match_pdomain->domain != pdomain->domain)
689 continue;
690
691 match_pr->performance->shared_type =
692 pr->performance->shared_type;
693 match_pr->performance->shared_cpu_map =
694 pr->performance->shared_cpu_map;
695 }
696 }
697
698err_ret:
KAMEZAWA Hiroyuki193de0c2006-04-27 05:25:00 -0400699 for_each_possible_cpu(i) {
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500700 pr = processors[i];
701 if (!pr || !pr->performance)
702 continue;
703
704 /* Assume no coordination on any error parsing domain info */
705 if (retval) {
706 cpus_clear(pr->performance->shared_cpu_map);
707 cpu_set(i, pr->performance->shared_cpu_map);
708 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL;
709 }
710 pr->performance = NULL; /* Will be set for real in register */
711 }
712
Len Brown785fccc2006-06-15 22:19:31 -0400713 mutex_unlock(&performance_mutex);
Len Brown9011bff42006-05-11 00:28:12 -0400714 return retval;
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -0500715}
716EXPORT_SYMBOL(acpi_processor_preregister_performance);
717
718
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719int
Len Brown4be44fc2005-08-05 00:44:28 -0400720acpi_processor_register_performance(struct acpi_processor_performance
721 *performance, unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722{
723 struct acpi_processor *pr;
724
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
726 if (!(acpi_processor_ppc_status & PPC_REGISTERED))
Patrick Mocheld550d982006-06-27 00:41:40 -0400727 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Arjan van de Ven65c19bb2006-04-27 05:25:00 -0400729 mutex_lock(&performance_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
731 pr = processors[cpu];
732 if (!pr) {
Arjan van de Ven65c19bb2006-04-27 05:25:00 -0400733 mutex_unlock(&performance_mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400734 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 }
736
737 if (pr->performance) {
Arjan van de Ven65c19bb2006-04-27 05:25:00 -0400738 mutex_unlock(&performance_mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400739 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 }
741
Andrew Mortona913f502006-06-10 09:54:13 -0700742 WARN_ON(!performance);
743
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 pr->performance = performance;
745
746 if (acpi_processor_get_performance_info(pr)) {
747 pr->performance = NULL;
Arjan van de Ven65c19bb2006-04-27 05:25:00 -0400748 mutex_unlock(&performance_mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400749 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 }
751
752 acpi_cpufreq_add_file(pr);
753
Arjan van de Ven65c19bb2006-04-27 05:25:00 -0400754 mutex_unlock(&performance_mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400755 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756}
Len Brown4be44fc2005-08-05 00:44:28 -0400757
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758EXPORT_SYMBOL(acpi_processor_register_performance);
759
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760void
Len Brown4be44fc2005-08-05 00:44:28 -0400761acpi_processor_unregister_performance(struct acpi_processor_performance
762 *performance, unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763{
764 struct acpi_processor *pr;
765
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Arjan van de Ven65c19bb2006-04-27 05:25:00 -0400767 mutex_lock(&performance_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
769 pr = processors[cpu];
770 if (!pr) {
Arjan van de Ven65c19bb2006-04-27 05:25:00 -0400771 mutex_unlock(&performance_mutex);
Patrick Mocheld550d982006-06-27 00:41:40 -0400772 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 }
774
Andrew Mortona913f502006-06-10 09:54:13 -0700775 if (pr->performance)
776 kfree(pr->performance->states);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 pr->performance = NULL;
778
779 acpi_cpufreq_remove_file(pr);
780
Arjan van de Ven65c19bb2006-04-27 05:25:00 -0400781 mutex_unlock(&performance_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
Patrick Mocheld550d982006-06-27 00:41:40 -0400783 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784}
Len Brown4be44fc2005-08-05 00:44:28 -0400785
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786EXPORT_SYMBOL(acpi_processor_unregister_performance);