Linux-2.6.12-rc2
[linux-2.6.git] / drivers / acpi / processor_perflib.c
1 /*
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
29
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/init.h>
33 #include <linux/cpufreq.h>
34
35 #ifdef CONFIG_X86_ACPI_CPUFREQ_PROC_INTF
36 #include <linux/proc_fs.h>
37 #include <linux/seq_file.h>
38
39 #include <asm/uaccess.h>
40 #endif
41
42 #include <acpi/acpi_bus.h>
43 #include <acpi/processor.h>
44
45
46 #define ACPI_PROCESSOR_COMPONENT        0x01000000
47 #define ACPI_PROCESSOR_CLASS            "processor"
48 #define ACPI_PROCESSOR_DRIVER_NAME      "ACPI Processor Driver"
49 #define ACPI_PROCESSOR_FILE_PERFORMANCE "performance"
50 #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
51 ACPI_MODULE_NAME                ("acpi_processor")
52
53
54 static DECLARE_MUTEX(performance_sem);
55
56 /*
57  * _PPC support is implemented as a CPUfreq policy notifier:
58  * This means each time a CPUfreq driver registered also with
59  * the ACPI core is asked to change the speed policy, the maximum
60  * value is adjusted so that it is within the platform limit.
61  *
62  * Also, when a new platform limit value is detected, the CPUfreq
63  * policy is adjusted accordingly.
64  */
65
66 #define PPC_REGISTERED   1
67 #define PPC_IN_USE       2
68
69 static int acpi_processor_ppc_status = 0;
70
71 static int acpi_processor_ppc_notifier(struct notifier_block *nb,
72         unsigned long event,
73         void *data)
74 {
75         struct cpufreq_policy *policy = data;
76         struct acpi_processor *pr;
77         unsigned int ppc = 0;
78
79         down(&performance_sem);
80
81         if (event != CPUFREQ_INCOMPATIBLE)
82                 goto out;
83
84         pr = processors[policy->cpu];
85         if (!pr || !pr->performance)
86                 goto out;
87
88         ppc = (unsigned int) pr->performance_platform_limit;
89         if (!ppc)
90                 goto out;
91
92         if (ppc > pr->performance->state_count)
93                 goto out;
94
95         cpufreq_verify_within_limits(policy, 0,
96                 pr->performance->states[ppc].core_frequency * 1000);
97
98  out:
99         up(&performance_sem);
100
101         return 0;
102 }
103
104
105 static struct notifier_block acpi_ppc_notifier_block = {
106         .notifier_call = acpi_processor_ppc_notifier,
107 };
108
109
110 static int
111 acpi_processor_get_platform_limit (
112         struct acpi_processor*  pr)
113 {
114         acpi_status             status = 0;
115         unsigned long           ppc = 0;
116
117         ACPI_FUNCTION_TRACE("acpi_processor_get_platform_limit");
118
119         if (!pr)
120                 return_VALUE(-EINVAL);
121
122         /*
123          * _PPC indicates the maximum state currently supported by the platform
124          * (e.g. 0 = states 0..n; 1 = states 1..n; etc.
125          */
126         status = acpi_evaluate_integer(pr->handle, "_PPC", NULL, &ppc);
127
128         if (status != AE_NOT_FOUND)
129                 acpi_processor_ppc_status |= PPC_IN_USE;
130
131         if(ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
132                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PPC\n"));
133                 return_VALUE(-ENODEV);
134         }
135
136         pr->performance_platform_limit = (int) ppc;
137
138         return_VALUE(0);
139 }
140
141
142 int acpi_processor_ppc_has_changed(
143         struct acpi_processor *pr)
144 {
145         int ret = acpi_processor_get_platform_limit(pr);
146         if (ret < 0)
147                 return (ret);
148         else
149                 return cpufreq_update_policy(pr->id);
150 }
151
152
153 void acpi_processor_ppc_init(void) {
154         if (!cpufreq_register_notifier(&acpi_ppc_notifier_block, CPUFREQ_POLICY_NOTIFIER))
155                 acpi_processor_ppc_status |= PPC_REGISTERED;
156         else
157                 printk(KERN_DEBUG "Warning: Processor Platform Limit not supported.\n");
158 }
159
160
161 void acpi_processor_ppc_exit(void) {
162         if (acpi_processor_ppc_status & PPC_REGISTERED)
163                 cpufreq_unregister_notifier(&acpi_ppc_notifier_block, CPUFREQ_POLICY_NOTIFIER);
164
165         acpi_processor_ppc_status &= ~PPC_REGISTERED;
166 }
167
168 /*
169  * when registering a cpufreq driver with this ACPI processor driver, the
170  * _PCT and _PSS structures are read out and written into struct
171  * acpi_processor_performance.
172  */
173 static int acpi_processor_set_pdc (struct acpi_processor *pr)
174 {
175         acpi_status             status = AE_OK;
176         u32                     arg0_buf[3];
177         union acpi_object       arg0 = {ACPI_TYPE_BUFFER};
178         struct acpi_object_list no_object = {1, &arg0};
179         struct acpi_object_list *pdc;
180
181         ACPI_FUNCTION_TRACE("acpi_processor_set_pdc");
182
183         arg0.buffer.length = 12;
184         arg0.buffer.pointer = (u8 *) arg0_buf;
185         arg0_buf[0] = ACPI_PDC_REVISION_ID;
186         arg0_buf[1] = 0;
187         arg0_buf[2] = 0;
188
189         pdc = (pr->performance->pdc) ? pr->performance->pdc : &no_object;
190
191         status = acpi_evaluate_object(pr->handle, "_PDC", pdc, NULL);
192
193         if ((ACPI_FAILURE(status)) && (pr->performance->pdc))
194                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Error evaluating _PDC, using legacy perf. control...\n"));
195
196         return_VALUE(status);
197 }
198
199
200 static int
201 acpi_processor_get_performance_control (
202         struct acpi_processor *pr)
203 {
204         int                     result = 0;
205         acpi_status             status = 0;
206         struct acpi_buffer      buffer = {ACPI_ALLOCATE_BUFFER, NULL};
207         union acpi_object       *pct = NULL;
208         union acpi_object       obj = {0};
209
210         ACPI_FUNCTION_TRACE("acpi_processor_get_performance_control");
211
212         status = acpi_evaluate_object(pr->handle, "_PCT", NULL, &buffer);
213         if(ACPI_FAILURE(status)) {
214                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PCT\n"));
215                 return_VALUE(-ENODEV);
216         }
217
218         pct = (union acpi_object *) buffer.pointer;
219         if (!pct || (pct->type != ACPI_TYPE_PACKAGE)
220                 || (pct->package.count != 2)) {
221                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PCT data\n"));
222                 result = -EFAULT;
223                 goto end;
224         }
225
226         /*
227          * control_register
228          */
229
230         obj = pct->package.elements[0];
231
232         if ((obj.type != ACPI_TYPE_BUFFER)
233                 || (obj.buffer.length < sizeof(struct acpi_pct_register))
234                 || (obj.buffer.pointer == NULL)) {
235                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
236                         "Invalid _PCT data (control_register)\n"));
237                 result = -EFAULT;
238                 goto end;
239         }
240         memcpy(&pr->performance->control_register, obj.buffer.pointer, sizeof(struct acpi_pct_register));
241
242
243         /*
244          * status_register
245          */
246
247         obj = pct->package.elements[1];
248
249         if ((obj.type != ACPI_TYPE_BUFFER)
250                 || (obj.buffer.length < sizeof(struct acpi_pct_register))
251                 || (obj.buffer.pointer == NULL)) {
252                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
253                         "Invalid _PCT data (status_register)\n"));
254                 result = -EFAULT;
255                 goto end;
256         }
257
258         memcpy(&pr->performance->status_register, obj.buffer.pointer, sizeof(struct acpi_pct_register));
259
260 end:
261         acpi_os_free(buffer.pointer);
262
263         return_VALUE(result);
264 }
265
266
267 static int
268 acpi_processor_get_performance_states (
269         struct acpi_processor   *pr)
270 {
271         int                     result = 0;
272         acpi_status             status = AE_OK;
273         struct acpi_buffer      buffer = {ACPI_ALLOCATE_BUFFER, NULL};
274         struct acpi_buffer      format = {sizeof("NNNNNN"), "NNNNNN"};
275         struct acpi_buffer      state = {0, NULL};
276         union acpi_object       *pss = NULL;
277         int                     i;
278
279         ACPI_FUNCTION_TRACE("acpi_processor_get_performance_states");
280
281         status = acpi_evaluate_object(pr->handle, "_PSS", NULL, &buffer);
282         if(ACPI_FAILURE(status)) {
283                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PSS\n"));
284                 return_VALUE(-ENODEV);
285         }
286
287         pss = (union acpi_object *) buffer.pointer;
288         if (!pss || (pss->type != ACPI_TYPE_PACKAGE)) {
289                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSS data\n"));
290                 result = -EFAULT;
291                 goto end;
292         }
293
294         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d performance states\n",
295                 pss->package.count));
296
297         pr->performance->state_count = pss->package.count;
298         pr->performance->states = kmalloc(sizeof(struct acpi_processor_px) * pss->package.count, GFP_KERNEL);
299         if (!pr->performance->states) {
300                 result = -ENOMEM;
301                 goto end;
302         }
303
304         for (i = 0; i < pr->performance->state_count; i++) {
305
306                 struct acpi_processor_px *px = &(pr->performance->states[i]);
307
308                 state.length = sizeof(struct acpi_processor_px);
309                 state.pointer = px;
310
311                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
312
313                 status = acpi_extract_package(&(pss->package.elements[i]),
314                         &format, &state);
315                 if (ACPI_FAILURE(status)) {
316                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSS data\n"));
317                         result = -EFAULT;
318                         kfree(pr->performance->states);
319                         goto end;
320                 }
321
322                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
323                         "State [%d]: core_frequency[%d] power[%d] transition_latency[%d] bus_master_latency[%d] control[0x%x] status[0x%x]\n",
324                         i,
325                         (u32) px->core_frequency,
326                         (u32) px->power,
327                         (u32) px->transition_latency,
328                         (u32) px->bus_master_latency,
329                         (u32) px->control,
330                         (u32) px->status));
331
332                 if (!px->core_frequency) {
333                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSS data: freq is zero\n"));
334                         result = -EFAULT;
335                         kfree(pr->performance->states);
336                         goto end;
337                 }
338         }
339
340 end:
341         acpi_os_free(buffer.pointer);
342
343         return_VALUE(result);
344 }
345
346
347 static int
348 acpi_processor_get_performance_info (
349         struct acpi_processor   *pr)
350 {
351         int                     result = 0;
352         acpi_status             status = AE_OK;
353         acpi_handle             handle = NULL;
354
355         ACPI_FUNCTION_TRACE("acpi_processor_get_performance_info");
356
357         if (!pr || !pr->performance || !pr->handle)
358                 return_VALUE(-EINVAL);
359
360         acpi_processor_set_pdc(pr);
361
362         status = acpi_get_handle(pr->handle, "_PCT", &handle);
363         if (ACPI_FAILURE(status)) {
364                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
365                         "ACPI-based processor performance control unavailable\n"));
366                 return_VALUE(-ENODEV);
367         }
368
369         result = acpi_processor_get_performance_control(pr);
370         if (result)
371                 return_VALUE(result);
372
373         result = acpi_processor_get_performance_states(pr);
374         if (result)
375                 return_VALUE(result);
376
377         result = acpi_processor_get_platform_limit(pr);
378         if (result)
379                 return_VALUE(result);
380
381         return_VALUE(0);
382 }
383
384
385 int acpi_processor_notify_smm(struct module *calling_module) {
386         acpi_status             status;
387         static int              is_done = 0;
388
389         ACPI_FUNCTION_TRACE("acpi_processor_notify_smm");
390
391         if (!(acpi_processor_ppc_status & PPC_REGISTERED))
392                 return_VALUE(-EBUSY);
393
394         if (!try_module_get(calling_module))
395                 return_VALUE(-EINVAL);
396
397         /* is_done is set to negative if an error occured,
398          * and to postitive if _no_ error occured, but SMM
399          * was already notified. This avoids double notification
400          * which might lead to unexpected results...
401          */
402         if (is_done > 0) {
403                 module_put(calling_module);
404                 return_VALUE(0);
405         }
406         else if (is_done < 0) {
407                 module_put(calling_module);
408                 return_VALUE(is_done);
409         }
410
411         is_done = -EIO;
412
413         /* Can't write pstate_cnt to smi_cmd if either value is zero */
414         if ((!acpi_fadt.smi_cmd) ||
415             (!acpi_fadt.pstate_cnt)) {
416                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
417                         "No SMI port or pstate_cnt\n"));
418                 module_put(calling_module);
419                 return_VALUE(0);
420         }
421
422         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Writing pstate_cnt [0x%x] to smi_cmd [0x%x]\n", acpi_fadt.pstate_cnt, acpi_fadt.smi_cmd));
423
424         /* FADT v1 doesn't support pstate_cnt, many BIOS vendors use
425          * it anyway, so we need to support it... */
426         if (acpi_fadt_is_v1) {
427                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Using v1.0 FADT reserved value for pstate_cnt\n"));
428         }
429
430         status = acpi_os_write_port (acpi_fadt.smi_cmd,
431                                      (u32) acpi_fadt.pstate_cnt, 8);
432         if (ACPI_FAILURE (status)) {
433                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
434                                   "Failed to write pstate_cnt [0x%x] to "
435                                   "smi_cmd [0x%x]\n", acpi_fadt.pstate_cnt, acpi_fadt.smi_cmd));
436                 module_put(calling_module);
437                 return_VALUE(status);
438         }
439
440         /* Success. If there's no _PPC, we need to fear nothing, so
441          * we can allow the cpufreq driver to be rmmod'ed. */
442         is_done = 1;
443
444         if (!(acpi_processor_ppc_status & PPC_IN_USE))
445                 module_put(calling_module);
446
447         return_VALUE(0);
448 }
449 EXPORT_SYMBOL(acpi_processor_notify_smm);
450
451
452 #ifdef CONFIG_X86_ACPI_CPUFREQ_PROC_INTF
453 /* /proc/acpi/processor/../performance interface (DEPRECATED) */
454
455 static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file);
456 static struct file_operations acpi_processor_perf_fops = {
457         .open           = acpi_processor_perf_open_fs,
458         .read           = seq_read,
459         .llseek         = seq_lseek,
460         .release        = single_release,
461 };
462
463 static int acpi_processor_perf_seq_show(struct seq_file *seq, void *offset)
464 {
465         struct acpi_processor   *pr = (struct acpi_processor *)seq->private;
466         int                     i;
467
468         ACPI_FUNCTION_TRACE("acpi_processor_perf_seq_show");
469
470         if (!pr)
471                 goto end;
472
473         if (!pr->performance) {
474                 seq_puts(seq, "<not supported>\n");
475                 goto end;
476         }
477
478         seq_printf(seq, "state count:             %d\n"
479                         "active state:            P%d\n",
480                         pr->performance->state_count,
481                         pr->performance->state);
482
483         seq_puts(seq, "states:\n");
484         for (i = 0; i < pr->performance->state_count; i++)
485                 seq_printf(seq, "   %cP%d:                  %d MHz, %d mW, %d uS\n",
486                         (i == pr->performance->state?'*':' '), i,
487                         (u32) pr->performance->states[i].core_frequency,
488                         (u32) pr->performance->states[i].power,
489                         (u32) pr->performance->states[i].transition_latency);
490
491 end:
492         return_VALUE(0);
493 }
494
495 static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file)
496 {
497         return single_open(file, acpi_processor_perf_seq_show,
498                                                 PDE(inode)->data);
499 }
500
501 static ssize_t
502 acpi_processor_write_performance (
503         struct file             *file,
504         const char              __user *buffer,
505         size_t                  count,
506         loff_t                  *data)
507 {
508         int                     result = 0;
509         struct seq_file         *m = (struct seq_file *) file->private_data;
510         struct acpi_processor   *pr = (struct acpi_processor *) m->private;
511         struct acpi_processor_performance *perf;
512         char                    state_string[12] = {'\0'};
513         unsigned int            new_state = 0;
514         struct cpufreq_policy   policy;
515
516         ACPI_FUNCTION_TRACE("acpi_processor_write_performance");
517
518         if (!pr || (count > sizeof(state_string) - 1))
519                 return_VALUE(-EINVAL);
520
521         perf = pr->performance;
522         if (!perf)
523                 return_VALUE(-EINVAL);
524
525         if (copy_from_user(state_string, buffer, count))
526                 return_VALUE(-EFAULT);
527
528         state_string[count] = '\0';
529         new_state = simple_strtoul(state_string, NULL, 0);
530
531         if (new_state >= perf->state_count)
532                 return_VALUE(-EINVAL);
533
534         cpufreq_get_policy(&policy, pr->id);
535
536         policy.cpu = pr->id;
537         policy.min = perf->states[new_state].core_frequency * 1000;
538         policy.max = perf->states[new_state].core_frequency * 1000;
539
540         result = cpufreq_set_policy(&policy);
541         if (result)
542                 return_VALUE(result);
543
544         return_VALUE(count);
545 }
546
547 static void
548 acpi_cpufreq_add_file (
549         struct acpi_processor *pr)
550 {
551         struct proc_dir_entry   *entry = NULL;
552         struct acpi_device      *device = NULL;
553
554         ACPI_FUNCTION_TRACE("acpi_cpufreq_addfile");
555
556         if (acpi_bus_get_device(pr->handle, &device))
557                 return_VOID;
558
559         /* add file 'performance' [R/W] */
560         entry = create_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE,
561                   S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device));
562         if (!entry)
563                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
564                         "Unable to create '%s' fs entry\n",
565                         ACPI_PROCESSOR_FILE_PERFORMANCE));
566         else {
567                 entry->proc_fops = &acpi_processor_perf_fops;
568                 entry->proc_fops->write = acpi_processor_write_performance;
569                 entry->data = acpi_driver_data(device);
570                 entry->owner = THIS_MODULE;
571         }
572         return_VOID;
573 }
574
575 static void
576 acpi_cpufreq_remove_file (
577         struct acpi_processor *pr)
578 {
579         struct acpi_device      *device = NULL;
580
581         ACPI_FUNCTION_TRACE("acpi_cpufreq_addfile");
582
583         if (acpi_bus_get_device(pr->handle, &device))
584                 return_VOID;
585
586         /* remove file 'performance' */
587         remove_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE,
588                   acpi_device_dir(device));
589
590         return_VOID;
591 }
592
593 #else
594 static void acpi_cpufreq_add_file (struct acpi_processor *pr) { return; }
595 static void acpi_cpufreq_remove_file (struct acpi_processor *pr) { return; }
596 #endif /* CONFIG_X86_ACPI_CPUFREQ_PROC_INTF */
597
598
599 int
600 acpi_processor_register_performance (
601         struct acpi_processor_performance * performance,
602         unsigned int cpu)
603 {
604         struct acpi_processor *pr;
605
606         ACPI_FUNCTION_TRACE("acpi_processor_register_performance");
607
608         if (!(acpi_processor_ppc_status & PPC_REGISTERED))
609                 return_VALUE(-EINVAL);
610
611         down(&performance_sem);
612
613         pr = processors[cpu];
614         if (!pr) {
615                 up(&performance_sem);
616                 return_VALUE(-ENODEV);
617         }
618
619         if (pr->performance) {
620                 up(&performance_sem);
621                 return_VALUE(-EBUSY);
622         }
623
624         pr->performance = performance;
625
626         if (acpi_processor_get_performance_info(pr)) {
627                 pr->performance = NULL;
628                 up(&performance_sem);
629                 return_VALUE(-EIO);
630         }
631
632         acpi_cpufreq_add_file(pr);
633
634         up(&performance_sem);
635         return_VALUE(0);
636 }
637 EXPORT_SYMBOL(acpi_processor_register_performance);
638
639
640 void
641 acpi_processor_unregister_performance (
642         struct acpi_processor_performance * performance,
643         unsigned int cpu)
644 {
645         struct acpi_processor *pr;
646
647         ACPI_FUNCTION_TRACE("acpi_processor_unregister_performance");
648
649         down(&performance_sem);
650
651         pr = processors[cpu];
652         if (!pr) {
653                 up(&performance_sem);
654                 return_VOID;
655         }
656
657         kfree(pr->performance->states);
658         pr->performance = NULL;
659
660         acpi_cpufreq_remove_file(pr);
661
662         up(&performance_sem);
663
664         return_VOID;
665 }
666 EXPORT_SYMBOL(acpi_processor_unregister_performance);