[CPUFREQ] move policy's governor initialisation out of low-level drivers into cpufreq...
[linux-3.10.git] / arch / i386 / kernel / cpu / cpufreq / acpi-cpufreq.c
1 /*
2  * acpi-cpufreq.c - ACPI Processor P-States Driver ($Revision: 1.4 $)
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) 2002 - 2004 Dominik Brodowski <linux@brodo.de>
7  *  Copyright (C) 2006       Denis Sadykov <denis.m.sadykov@intel.com>
8  *
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
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/smp.h>
32 #include <linux/sched.h>
33 #include <linux/cpufreq.h>
34 #include <linux/compiler.h>
35 #include <linux/dmi.h>
36
37 #include <linux/acpi.h>
38 #include <acpi/processor.h>
39
40 #include <asm/io.h>
41 #include <asm/msr.h>
42 #include <asm/processor.h>
43 #include <asm/cpufeature.h>
44 #include <asm/delay.h>
45 #include <asm/uaccess.h>
46
47 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "acpi-cpufreq", msg)
48
49 MODULE_AUTHOR("Paul Diefenbaugh, Dominik Brodowski");
50 MODULE_DESCRIPTION("ACPI Processor P-States Driver");
51 MODULE_LICENSE("GPL");
52
53 enum {
54         UNDEFINED_CAPABLE = 0,
55         SYSTEM_INTEL_MSR_CAPABLE,
56         SYSTEM_IO_CAPABLE,
57 };
58
59 #define INTEL_MSR_RANGE         (0xffff)
60 #define CPUID_6_ECX_APERFMPERF_CAPABILITY       (0x1)
61
62 struct acpi_cpufreq_data {
63         struct acpi_processor_performance *acpi_data;
64         struct cpufreq_frequency_table *freq_table;
65         unsigned int max_freq;
66         unsigned int resume;
67         unsigned int cpu_feature;
68 };
69
70 static struct acpi_cpufreq_data *drv_data[NR_CPUS];
71 /* acpi_perf_data is a pointer to percpu data. */
72 static struct acpi_processor_performance *acpi_perf_data;
73
74 static struct cpufreq_driver acpi_cpufreq_driver;
75
76 static unsigned int acpi_pstate_strict;
77
78 static int check_est_cpu(unsigned int cpuid)
79 {
80         struct cpuinfo_x86 *cpu = &cpu_data[cpuid];
81
82         if (cpu->x86_vendor != X86_VENDOR_INTEL ||
83             !cpu_has(cpu, X86_FEATURE_EST))
84                 return 0;
85
86         return 1;
87 }
88
89 static unsigned extract_io(u32 value, struct acpi_cpufreq_data *data)
90 {
91         struct acpi_processor_performance *perf;
92         int i;
93
94         perf = data->acpi_data;
95
96         for (i=0; i<perf->state_count; i++) {
97                 if (value == perf->states[i].status)
98                         return data->freq_table[i].frequency;
99         }
100         return 0;
101 }
102
103 static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
104 {
105         int i;
106         struct acpi_processor_performance *perf;
107
108         msr &= INTEL_MSR_RANGE;
109         perf = data->acpi_data;
110
111         for (i=0; data->freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
112                 if (msr == perf->states[data->freq_table[i].index].status)
113                         return data->freq_table[i].frequency;
114         }
115         return data->freq_table[0].frequency;
116 }
117
118 static unsigned extract_freq(u32 val, struct acpi_cpufreq_data *data)
119 {
120         switch (data->cpu_feature) {
121         case SYSTEM_INTEL_MSR_CAPABLE:
122                 return extract_msr(val, data);
123         case SYSTEM_IO_CAPABLE:
124                 return extract_io(val, data);
125         default:
126                 return 0;
127         }
128 }
129
130 struct msr_addr {
131         u32 reg;
132 };
133
134 struct io_addr {
135         u16 port;
136         u8 bit_width;
137 };
138
139 typedef union {
140         struct msr_addr msr;
141         struct io_addr io;
142 } drv_addr_union;
143
144 struct drv_cmd {
145         unsigned int type;
146         cpumask_t mask;
147         drv_addr_union addr;
148         u32 val;
149 };
150
151 static void do_drv_read(struct drv_cmd *cmd)
152 {
153         u32 h;
154
155         switch (cmd->type) {
156         case SYSTEM_INTEL_MSR_CAPABLE:
157                 rdmsr(cmd->addr.msr.reg, cmd->val, h);
158                 break;
159         case SYSTEM_IO_CAPABLE:
160                 acpi_os_read_port((acpi_io_address)cmd->addr.io.port,
161                                 &cmd->val,
162                                 (u32)cmd->addr.io.bit_width);
163                 break;
164         default:
165                 break;
166         }
167 }
168
169 static void do_drv_write(struct drv_cmd *cmd)
170 {
171         u32 lo, hi;
172
173         switch (cmd->type) {
174         case SYSTEM_INTEL_MSR_CAPABLE:
175                 rdmsr(cmd->addr.msr.reg, lo, hi);
176                 lo = (lo & ~INTEL_MSR_RANGE) | (cmd->val & INTEL_MSR_RANGE);
177                 wrmsr(cmd->addr.msr.reg, lo, hi);
178                 break;
179         case SYSTEM_IO_CAPABLE:
180                 acpi_os_write_port((acpi_io_address)cmd->addr.io.port,
181                                 cmd->val,
182                                 (u32)cmd->addr.io.bit_width);
183                 break;
184         default:
185                 break;
186         }
187 }
188
189 static void drv_read(struct drv_cmd *cmd)
190 {
191         cpumask_t saved_mask = current->cpus_allowed;
192         cmd->val = 0;
193
194         set_cpus_allowed(current, cmd->mask);
195         do_drv_read(cmd);
196         set_cpus_allowed(current, saved_mask);
197 }
198
199 static void drv_write(struct drv_cmd *cmd)
200 {
201         cpumask_t saved_mask = current->cpus_allowed;
202         unsigned int i;
203
204         for_each_cpu_mask(i, cmd->mask) {
205                 set_cpus_allowed(current, cpumask_of_cpu(i));
206                 do_drv_write(cmd);
207         }
208
209         set_cpus_allowed(current, saved_mask);
210         return;
211 }
212
213 static u32 get_cur_val(cpumask_t mask)
214 {
215         struct acpi_processor_performance *perf;
216         struct drv_cmd cmd;
217
218         if (unlikely(cpus_empty(mask)))
219                 return 0;
220
221         switch (drv_data[first_cpu(mask)]->cpu_feature) {
222         case SYSTEM_INTEL_MSR_CAPABLE:
223                 cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
224                 cmd.addr.msr.reg = MSR_IA32_PERF_STATUS;
225                 break;
226         case SYSTEM_IO_CAPABLE:
227                 cmd.type = SYSTEM_IO_CAPABLE;
228                 perf = drv_data[first_cpu(mask)]->acpi_data;
229                 cmd.addr.io.port = perf->control_register.address;
230                 cmd.addr.io.bit_width = perf->control_register.bit_width;
231                 break;
232         default:
233                 return 0;
234         }
235
236         cmd.mask = mask;
237
238         drv_read(&cmd);
239
240         dprintk("get_cur_val = %u\n", cmd.val);
241
242         return cmd.val;
243 }
244
245 /*
246  * Return the measured active (C0) frequency on this CPU since last call
247  * to this function.
248  * Input: cpu number
249  * Return: Average CPU frequency in terms of max frequency (zero on error)
250  *
251  * We use IA32_MPERF and IA32_APERF MSRs to get the measured performance
252  * over a period of time, while CPU is in C0 state.
253  * IA32_MPERF counts at the rate of max advertised frequency
254  * IA32_APERF counts at the rate of actual CPU frequency
255  * Only IA32_APERF/IA32_MPERF ratio is architecturally defined and
256  * no meaning should be associated with absolute values of these MSRs.
257  */
258 static unsigned int get_measured_perf(unsigned int cpu)
259 {
260         union {
261                 struct {
262                         u32 lo;
263                         u32 hi;
264                 } split;
265                 u64 whole;
266         } aperf_cur, mperf_cur;
267
268         cpumask_t saved_mask;
269         unsigned int perf_percent;
270         unsigned int retval;
271
272         saved_mask = current->cpus_allowed;
273         set_cpus_allowed(current, cpumask_of_cpu(cpu));
274         if (get_cpu() != cpu) {
275                 /* We were not able to run on requested processor */
276                 put_cpu();
277                 return 0;
278         }
279
280         rdmsr(MSR_IA32_APERF, aperf_cur.split.lo, aperf_cur.split.hi);
281         rdmsr(MSR_IA32_MPERF, mperf_cur.split.lo, mperf_cur.split.hi);
282
283         wrmsr(MSR_IA32_APERF, 0,0);
284         wrmsr(MSR_IA32_MPERF, 0,0);
285
286 #ifdef __i386__
287         /*
288          * We dont want to do 64 bit divide with 32 bit kernel
289          * Get an approximate value. Return failure in case we cannot get
290          * an approximate value.
291          */
292         if (unlikely(aperf_cur.split.hi || mperf_cur.split.hi)) {
293                 int shift_count;
294                 u32 h;
295
296                 h = max_t(u32, aperf_cur.split.hi, mperf_cur.split.hi);
297                 shift_count = fls(h);
298
299                 aperf_cur.whole >>= shift_count;
300                 mperf_cur.whole >>= shift_count;
301         }
302
303         if (((unsigned long)(-1) / 100) < aperf_cur.split.lo) {
304                 int shift_count = 7;
305                 aperf_cur.split.lo >>= shift_count;
306                 mperf_cur.split.lo >>= shift_count;
307         }
308
309         if (aperf_cur.split.lo && mperf_cur.split.lo)
310                 perf_percent = (aperf_cur.split.lo * 100) / mperf_cur.split.lo;
311         else
312                 perf_percent = 0;
313
314 #else
315         if (unlikely(((unsigned long)(-1) / 100) < aperf_cur.whole)) {
316                 int shift_count = 7;
317                 aperf_cur.whole >>= shift_count;
318                 mperf_cur.whole >>= shift_count;
319         }
320
321         if (aperf_cur.whole && mperf_cur.whole)
322                 perf_percent = (aperf_cur.whole * 100) / mperf_cur.whole;
323         else
324                 perf_percent = 0;
325
326 #endif
327
328         retval = drv_data[cpu]->max_freq * perf_percent / 100;
329
330         put_cpu();
331         set_cpus_allowed(current, saved_mask);
332
333         dprintk("cpu %d: performance percent %d\n", cpu, perf_percent);
334         return retval;
335 }
336
337 static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
338 {
339         struct acpi_cpufreq_data *data = drv_data[cpu];
340         unsigned int freq;
341
342         dprintk("get_cur_freq_on_cpu (%d)\n", cpu);
343
344         if (unlikely(data == NULL ||
345                      data->acpi_data == NULL || data->freq_table == NULL)) {
346                 return 0;
347         }
348
349         freq = extract_freq(get_cur_val(cpumask_of_cpu(cpu)), data);
350         dprintk("cur freq = %u\n", freq);
351
352         return freq;
353 }
354
355 static unsigned int check_freqs(cpumask_t mask, unsigned int freq,
356                                 struct acpi_cpufreq_data *data)
357 {
358         unsigned int cur_freq;
359         unsigned int i;
360
361         for (i=0; i<100; i++) {
362                 cur_freq = extract_freq(get_cur_val(mask), data);
363                 if (cur_freq == freq)
364                         return 1;
365                 udelay(10);
366         }
367         return 0;
368 }
369
370 static int acpi_cpufreq_target(struct cpufreq_policy *policy,
371                                unsigned int target_freq, unsigned int relation)
372 {
373         struct acpi_cpufreq_data *data = drv_data[policy->cpu];
374         struct acpi_processor_performance *perf;
375         struct cpufreq_freqs freqs;
376         cpumask_t online_policy_cpus;
377         struct drv_cmd cmd;
378         unsigned int next_state = 0; /* Index into freq_table */
379         unsigned int next_perf_state = 0; /* Index into perf table */
380         unsigned int i;
381         int result = 0;
382
383         dprintk("acpi_cpufreq_target %d (%d)\n", target_freq, policy->cpu);
384
385         if (unlikely(data == NULL ||
386              data->acpi_data == NULL || data->freq_table == NULL)) {
387                 return -ENODEV;
388         }
389
390         perf = data->acpi_data;
391         result = cpufreq_frequency_table_target(policy,
392                                                 data->freq_table,
393                                                 target_freq,
394                                                 relation, &next_state);
395         if (unlikely(result))
396                 return -ENODEV;
397
398 #ifdef CONFIG_HOTPLUG_CPU
399         /* cpufreq holds the hotplug lock, so we are safe from here on */
400         cpus_and(online_policy_cpus, cpu_online_map, policy->cpus);
401 #else
402         online_policy_cpus = policy->cpus;
403 #endif
404
405         next_perf_state = data->freq_table[next_state].index;
406         if (perf->state == next_perf_state) {
407                 if (unlikely(data->resume)) {
408                         dprintk("Called after resume, resetting to P%d\n",
409                                 next_perf_state);
410                         data->resume = 0;
411                 } else {
412                         dprintk("Already at target state (P%d)\n",
413                                 next_perf_state);
414                         return 0;
415                 }
416         }
417
418         switch (data->cpu_feature) {
419         case SYSTEM_INTEL_MSR_CAPABLE:
420                 cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
421                 cmd.addr.msr.reg = MSR_IA32_PERF_CTL;
422                 cmd.val = (u32) perf->states[next_perf_state].control;
423                 break;
424         case SYSTEM_IO_CAPABLE:
425                 cmd.type = SYSTEM_IO_CAPABLE;
426                 cmd.addr.io.port = perf->control_register.address;
427                 cmd.addr.io.bit_width = perf->control_register.bit_width;
428                 cmd.val = (u32) perf->states[next_perf_state].control;
429                 break;
430         default:
431                 return -ENODEV;
432         }
433
434         cpus_clear(cmd.mask);
435
436         if (policy->shared_type != CPUFREQ_SHARED_TYPE_ANY)
437                 cmd.mask = online_policy_cpus;
438         else
439                 cpu_set(policy->cpu, cmd.mask);
440
441         freqs.old = perf->states[perf->state].core_frequency * 1000;
442         freqs.new = data->freq_table[next_state].frequency;
443         for_each_cpu_mask(i, cmd.mask) {
444                 freqs.cpu = i;
445                 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
446         }
447
448         drv_write(&cmd);
449
450         if (acpi_pstate_strict) {
451                 if (!check_freqs(cmd.mask, freqs.new, data)) {
452                         dprintk("acpi_cpufreq_target failed (%d)\n",
453                                 policy->cpu);
454                         return -EAGAIN;
455                 }
456         }
457
458         for_each_cpu_mask(i, cmd.mask) {
459                 freqs.cpu = i;
460                 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
461         }
462         perf->state = next_perf_state;
463
464         return result;
465 }
466
467 static int acpi_cpufreq_verify(struct cpufreq_policy *policy)
468 {
469         struct acpi_cpufreq_data *data = drv_data[policy->cpu];
470
471         dprintk("acpi_cpufreq_verify\n");
472
473         return cpufreq_frequency_table_verify(policy, data->freq_table);
474 }
475
476 static unsigned long
477 acpi_cpufreq_guess_freq(struct acpi_cpufreq_data *data, unsigned int cpu)
478 {
479         struct acpi_processor_performance *perf = data->acpi_data;
480
481         if (cpu_khz) {
482                 /* search the closest match to cpu_khz */
483                 unsigned int i;
484                 unsigned long freq;
485                 unsigned long freqn = perf->states[0].core_frequency * 1000;
486
487                 for (i=0; i<(perf->state_count-1); i++) {
488                         freq = freqn;
489                         freqn = perf->states[i+1].core_frequency * 1000;
490                         if ((2 * cpu_khz) > (freqn + freq)) {
491                                 perf->state = i;
492                                 return freq;
493                         }
494                 }
495                 perf->state = perf->state_count-1;
496                 return freqn;
497         } else {
498                 /* assume CPU is at P0... */
499                 perf->state = 0;
500                 return perf->states[0].core_frequency * 1000;
501         }
502 }
503
504 /*
505  * acpi_cpufreq_early_init - initialize ACPI P-States library
506  *
507  * Initialize the ACPI P-States library (drivers/acpi/processor_perflib.c)
508  * in order to determine correct frequency and voltage pairings. We can
509  * do _PDC and _PSD and find out the processor dependency for the
510  * actual init that will happen later...
511  */
512 static int __init acpi_cpufreq_early_init(void)
513 {
514         dprintk("acpi_cpufreq_early_init\n");
515
516         acpi_perf_data = alloc_percpu(struct acpi_processor_performance);
517         if (!acpi_perf_data) {
518                 dprintk("Memory allocation error for acpi_perf_data.\n");
519                 return -ENOMEM;
520         }
521
522         /* Do initialization in ACPI core */
523         acpi_processor_preregister_performance(acpi_perf_data);
524         return 0;
525 }
526
527 #ifdef CONFIG_SMP
528 /*
529  * Some BIOSes do SW_ANY coordination internally, either set it up in hw
530  * or do it in BIOS firmware and won't inform about it to OS. If not
531  * detected, this has a side effect of making CPU run at a different speed
532  * than OS intended it to run at. Detect it and handle it cleanly.
533  */
534 static int bios_with_sw_any_bug;
535
536 static int sw_any_bug_found(struct dmi_system_id *d)
537 {
538         bios_with_sw_any_bug = 1;
539         return 0;
540 }
541
542 static struct dmi_system_id sw_any_bug_dmi_table[] = {
543         {
544                 .callback = sw_any_bug_found,
545                 .ident = "Supermicro Server X6DLP",
546                 .matches = {
547                         DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
548                         DMI_MATCH(DMI_BIOS_VERSION, "080010"),
549                         DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"),
550                 },
551         },
552         { }
553 };
554 #endif
555
556 static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
557 {
558         unsigned int i;
559         unsigned int valid_states = 0;
560         unsigned int cpu = policy->cpu;
561         struct acpi_cpufreq_data *data;
562         unsigned int result = 0;
563         struct cpuinfo_x86 *c = &cpu_data[policy->cpu];
564         struct acpi_processor_performance *perf;
565
566         dprintk("acpi_cpufreq_cpu_init\n");
567
568         data = kzalloc(sizeof(struct acpi_cpufreq_data), GFP_KERNEL);
569         if (!data)
570                 return -ENOMEM;
571
572         data->acpi_data = percpu_ptr(acpi_perf_data, cpu);
573         drv_data[cpu] = data;
574
575         if (cpu_has(c, X86_FEATURE_CONSTANT_TSC))
576                 acpi_cpufreq_driver.flags |= CPUFREQ_CONST_LOOPS;
577
578         result = acpi_processor_register_performance(data->acpi_data, cpu);
579         if (result)
580                 goto err_free;
581
582         perf = data->acpi_data;
583         policy->shared_type = perf->shared_type;
584
585         /*
586          * Will let policy->cpus know about dependency only when software
587          * coordination is required.
588          */
589         if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
590             policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
591                 policy->cpus = perf->shared_cpu_map;
592         }
593
594 #ifdef CONFIG_SMP
595         dmi_check_system(sw_any_bug_dmi_table);
596         if (bios_with_sw_any_bug && cpus_weight(policy->cpus) == 1) {
597                 policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
598                 policy->cpus = cpu_core_map[cpu];
599         }
600 #endif
601
602         /* capability check */
603         if (perf->state_count <= 1) {
604                 dprintk("No P-States\n");
605                 result = -ENODEV;
606                 goto err_unreg;
607         }
608
609         if (perf->control_register.space_id != perf->status_register.space_id) {
610                 result = -ENODEV;
611                 goto err_unreg;
612         }
613
614         switch (perf->control_register.space_id) {
615         case ACPI_ADR_SPACE_SYSTEM_IO:
616                 dprintk("SYSTEM IO addr space\n");
617                 data->cpu_feature = SYSTEM_IO_CAPABLE;
618                 break;
619         case ACPI_ADR_SPACE_FIXED_HARDWARE:
620                 dprintk("HARDWARE addr space\n");
621                 if (!check_est_cpu(cpu)) {
622                         result = -ENODEV;
623                         goto err_unreg;
624                 }
625                 data->cpu_feature = SYSTEM_INTEL_MSR_CAPABLE;
626                 break;
627         default:
628                 dprintk("Unknown addr space %d\n",
629                         (u32) (perf->control_register.space_id));
630                 result = -ENODEV;
631                 goto err_unreg;
632         }
633
634         data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) *
635                     (perf->state_count+1), GFP_KERNEL);
636         if (!data->freq_table) {
637                 result = -ENOMEM;
638                 goto err_unreg;
639         }
640
641         /* detect transition latency */
642         policy->cpuinfo.transition_latency = 0;
643         for (i=0; i<perf->state_count; i++) {
644                 if ((perf->states[i].transition_latency * 1000) >
645                     policy->cpuinfo.transition_latency)
646                         policy->cpuinfo.transition_latency =
647                             perf->states[i].transition_latency * 1000;
648         }
649
650         data->max_freq = perf->states[0].core_frequency * 1000;
651         /* table init */
652         for (i=0; i<perf->state_count; i++) {
653                 if (i>0 && perf->states[i].core_frequency >=
654                     data->freq_table[valid_states-1].frequency / 1000)
655                         continue;
656
657                 data->freq_table[valid_states].index = i;
658                 data->freq_table[valid_states].frequency =
659                     perf->states[i].core_frequency * 1000;
660                 valid_states++;
661         }
662         data->freq_table[valid_states].frequency = CPUFREQ_TABLE_END;
663         perf->state = 0;
664
665         result = cpufreq_frequency_table_cpuinfo(policy, data->freq_table);
666         if (result)
667                 goto err_freqfree;
668
669         switch (perf->control_register.space_id) {
670         case ACPI_ADR_SPACE_SYSTEM_IO:
671                 /* Current speed is unknown and not detectable by IO port */
672                 policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);
673                 break;
674         case ACPI_ADR_SPACE_FIXED_HARDWARE:
675                 acpi_cpufreq_driver.get = get_cur_freq_on_cpu;
676                 policy->cur = get_cur_freq_on_cpu(cpu);
677                 break;
678         default:
679                 break;
680         }
681
682         /* notify BIOS that we exist */
683         acpi_processor_notify_smm(THIS_MODULE);
684
685         /* Check for APERF/MPERF support in hardware */
686         if (c->x86_vendor == X86_VENDOR_INTEL && c->cpuid_level >= 6) {
687                 unsigned int ecx;
688                 ecx = cpuid_ecx(6);
689                 if (ecx & CPUID_6_ECX_APERFMPERF_CAPABILITY)
690                         acpi_cpufreq_driver.getavg = get_measured_perf;
691         }
692
693         dprintk("CPU%u - ACPI performance management activated.\n", cpu);
694         for (i = 0; i < perf->state_count; i++)
695                 dprintk("     %cP%d: %d MHz, %d mW, %d uS\n",
696                         (i == perf->state ? '*' : ' '), i,
697                         (u32) perf->states[i].core_frequency,
698                         (u32) perf->states[i].power,
699                         (u32) perf->states[i].transition_latency);
700
701         cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu);
702
703         /*
704          * the first call to ->target() should result in us actually
705          * writing something to the appropriate registers.
706          */
707         data->resume = 1;
708
709         return result;
710
711 err_freqfree:
712         kfree(data->freq_table);
713 err_unreg:
714         acpi_processor_unregister_performance(perf, cpu);
715 err_free:
716         kfree(data);
717         drv_data[cpu] = NULL;
718
719         return result;
720 }
721
722 static int acpi_cpufreq_cpu_exit(struct cpufreq_policy *policy)
723 {
724         struct acpi_cpufreq_data *data = drv_data[policy->cpu];
725
726         dprintk("acpi_cpufreq_cpu_exit\n");
727
728         if (data) {
729                 cpufreq_frequency_table_put_attr(policy->cpu);
730                 drv_data[policy->cpu] = NULL;
731                 acpi_processor_unregister_performance(data->acpi_data,
732                                                       policy->cpu);
733                 kfree(data);
734         }
735
736         return 0;
737 }
738
739 static int acpi_cpufreq_resume(struct cpufreq_policy *policy)
740 {
741         struct acpi_cpufreq_data *data = drv_data[policy->cpu];
742
743         dprintk("acpi_cpufreq_resume\n");
744
745         data->resume = 1;
746
747         return 0;
748 }
749
750 static struct freq_attr *acpi_cpufreq_attr[] = {
751         &cpufreq_freq_attr_scaling_available_freqs,
752         NULL,
753 };
754
755 static struct cpufreq_driver acpi_cpufreq_driver = {
756         .verify = acpi_cpufreq_verify,
757         .target = acpi_cpufreq_target,
758         .init = acpi_cpufreq_cpu_init,
759         .exit = acpi_cpufreq_cpu_exit,
760         .resume = acpi_cpufreq_resume,
761         .name = "acpi-cpufreq",
762         .owner = THIS_MODULE,
763         .attr = acpi_cpufreq_attr,
764 };
765
766 static int __init acpi_cpufreq_init(void)
767 {
768         int ret;
769
770         dprintk("acpi_cpufreq_init\n");
771
772         ret = acpi_cpufreq_early_init();
773         if (ret)
774                 return ret;
775
776         return cpufreq_register_driver(&acpi_cpufreq_driver);
777 }
778
779 static void __exit acpi_cpufreq_exit(void)
780 {
781         dprintk("acpi_cpufreq_exit\n");
782
783         cpufreq_unregister_driver(&acpi_cpufreq_driver);
784
785         free_percpu(acpi_perf_data);
786
787         return;
788 }
789
790 module_param(acpi_pstate_strict, uint, 0644);
791 MODULE_PARM_DESC(acpi_pstate_strict,
792         "value 0 or non-zero. non-zero -> strict ACPI checks are "
793         "performed during frequency changes.");
794
795 late_initcall(acpi_cpufreq_init);
796 module_exit(acpi_cpufreq_exit);
797
798 MODULE_ALIAS("acpi");