Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
powernow-k7.c
Go to the documentation of this file.
1 /*
2  * AMD K7 Powernow driver.
3  * (C) 2003 Dave Jones on behalf of SuSE Labs.
4  * (C) 2003-2004 Dave Jones <[email protected]>
5  *
6  * Licensed under the terms of the GNU GPL License version 2.
7  * Based upon datasheets & sample CPUs kindly provided by AMD.
8  *
9  * Errata 5:
10  * CPU may fail to execute a FID/VID change in presence of interrupt.
11  * - We cli/sti on stepping A0 CPUs around the FID/VID transition.
12  * Errata 15:
13  * CPU with half frequency multipliers may hang upon wakeup from disconnect.
14  * - We disable half multipliers if ACPI is used on A0 stepping CPUs.
15  */
16 
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/moduleparam.h>
20 #include <linux/init.h>
21 #include <linux/cpufreq.h>
22 #include <linux/slab.h>
23 #include <linux/string.h>
24 #include <linux/dmi.h>
25 #include <linux/timex.h>
26 #include <linux/io.h>
27 
28 #include <asm/timer.h> /* Needed for recalibrate_cpu_khz() */
29 #include <asm/msr.h>
30 #include <asm/cpu_device_id.h>
31 
32 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
33 #include <linux/acpi.h>
34 #include <acpi/processor.h>
35 #endif
36 
37 #include "powernow-k7.h"
38 
39 #define PFX "powernow: "
40 
41 
42 struct psb_s {
43  u8 signature[10];
44  u8 tableversion;
45  u8 flags;
46  u16 settlingtime;
47  u8 reserved1;
48  u8 numpst;
49 };
50 
51 struct pst_s {
52  u32 cpuid;
53  u8 fsbspeed;
54  u8 maxfid;
55  u8 startvid;
56  u8 numpstates;
57 };
58 
59 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
60 union powernow_acpi_control_t {
61  struct {
62  unsigned long fid:5,
63  vid:5,
64  sgtc:20,
65  res1:2;
66  } bits;
67  unsigned long val;
68 };
69 #endif
70 
71 /* divide by 1000 to get VCore voltage in V. */
72 static const int mobile_vid_table[32] = {
73  2000, 1950, 1900, 1850, 1800, 1750, 1700, 1650,
74  1600, 1550, 1500, 1450, 1400, 1350, 1300, 0,
75  1275, 1250, 1225, 1200, 1175, 1150, 1125, 1100,
76  1075, 1050, 1025, 1000, 975, 950, 925, 0,
77 };
78 
79 /* divide by 10 to get FID. */
80 static const int fid_codes[32] = {
81  110, 115, 120, 125, 50, 55, 60, 65,
82  70, 75, 80, 85, 90, 95, 100, 105,
83  30, 190, 40, 200, 130, 135, 140, 210,
84  150, 225, 160, 165, 170, 180, -1, -1,
85 };
86 
87 /* This parameter is used in order to force ACPI instead of legacy method for
88  * configuration purpose.
89  */
90 
91 static int acpi_force;
92 
93 static struct cpufreq_frequency_table *powernow_table;
94 
95 static unsigned int can_scale_bus;
96 static unsigned int can_scale_vid;
97 static unsigned int minimum_speed = -1;
98 static unsigned int maximum_speed;
99 static unsigned int number_scales;
100 static unsigned int fsb;
101 static unsigned int latency;
102 static char have_a0;
103 
104 static int check_fsb(unsigned int fsbspeed)
105 {
106  int delta;
107  unsigned int f = fsb / 1000;
108 
109  delta = (fsbspeed > f) ? fsbspeed - f : f - fsbspeed;
110  return delta < 5;
111 }
112 
113 static const struct x86_cpu_id powernow_k7_cpuids[] = {
114  { X86_VENDOR_AMD, 6, },
115  {}
116 };
117 MODULE_DEVICE_TABLE(x86cpu, powernow_k7_cpuids);
118 
119 static int check_powernow(void)
120 {
121  struct cpuinfo_x86 *c = &cpu_data(0);
122  unsigned int maxei, eax, ebx, ecx, edx;
123 
124  if (!x86_match_cpu(powernow_k7_cpuids))
125  return 0;
126 
127  /* Get maximum capabilities */
128  maxei = cpuid_eax(0x80000000);
129  if (maxei < 0x80000007) { /* Any powernow info ? */
130 #ifdef MODULE
131  printk(KERN_INFO PFX "No powernow capabilities detected\n");
132 #endif
133  return 0;
134  }
135 
136  if ((c->x86_model == 6) && (c->x86_mask == 0)) {
137  printk(KERN_INFO PFX "K7 660[A0] core detected, "
138  "enabling errata workarounds\n");
139  have_a0 = 1;
140  }
141 
142  cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
143 
144  /* Check we can actually do something before we say anything.*/
145  if (!(edx & (1 << 1 | 1 << 2)))
146  return 0;
147 
148  printk(KERN_INFO PFX "PowerNOW! Technology present. Can scale: ");
149 
150  if (edx & 1 << 1) {
151  printk("frequency");
152  can_scale_bus = 1;
153  }
154 
155  if ((edx & (1 << 1 | 1 << 2)) == 0x6)
156  printk(" and ");
157 
158  if (edx & 1 << 2) {
159  printk("voltage");
160  can_scale_vid = 1;
161  }
162 
163  printk(".\n");
164  return 1;
165 }
166 
167 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
168 static void invalidate_entry(unsigned int entry)
169 {
170  powernow_table[entry].frequency = CPUFREQ_ENTRY_INVALID;
171 }
172 #endif
173 
174 static int get_ranges(unsigned char *pst)
175 {
176  unsigned int j;
177  unsigned int speed;
178  u8 fid, vid;
179 
180  powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
181  (number_scales + 1)), GFP_KERNEL);
182  if (!powernow_table)
183  return -ENOMEM;
184 
185  for (j = 0 ; j < number_scales; j++) {
186  fid = *pst++;
187 
188  powernow_table[j].frequency = (fsb * fid_codes[fid]) / 10;
189  powernow_table[j].index = fid; /* lower 8 bits */
190 
191  speed = powernow_table[j].frequency;
192 
193  if ((fid_codes[fid] % 10) == 5) {
194 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
195  if (have_a0 == 1)
196  invalidate_entry(j);
197 #endif
198  }
199 
200  if (speed < minimum_speed)
201  minimum_speed = speed;
202  if (speed > maximum_speed)
203  maximum_speed = speed;
204 
205  vid = *pst++;
206  powernow_table[j].index |= (vid << 8); /* upper 8 bits */
207 
208  pr_debug(" FID: 0x%x (%d.%dx [%dMHz]) "
209  "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10,
210  fid_codes[fid] % 10, speed/1000, vid,
211  mobile_vid_table[vid]/1000,
212  mobile_vid_table[vid]%1000);
213  }
214  powernow_table[number_scales].frequency = CPUFREQ_TABLE_END;
215  powernow_table[number_scales].index = 0;
216 
217  return 0;
218 }
219 
220 
221 static void change_FID(int fid)
222 {
223  union msr_fidvidctl fidvidctl;
224 
225  rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
226  if (fidvidctl.bits.FID != fid) {
227  fidvidctl.bits.SGTC = latency;
228  fidvidctl.bits.FID = fid;
229  fidvidctl.bits.VIDC = 0;
230  fidvidctl.bits.FIDC = 1;
231  wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
232  }
233 }
234 
235 
236 static void change_VID(int vid)
237 {
238  union msr_fidvidctl fidvidctl;
239 
240  rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
241  if (fidvidctl.bits.VID != vid) {
242  fidvidctl.bits.SGTC = latency;
243  fidvidctl.bits.VID = vid;
244  fidvidctl.bits.FIDC = 0;
245  fidvidctl.bits.VIDC = 1;
246  wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
247  }
248 }
249 
250 
251 static void change_speed(unsigned int index)
252 {
253  u8 fid, vid;
254  struct cpufreq_freqs freqs;
255  union msr_fidvidstatus fidvidstatus;
256  int cfid;
257 
258  /* fid are the lower 8 bits of the index we stored into
259  * the cpufreq frequency table in powernow_decode_bios,
260  * vid are the upper 8 bits.
261  */
262 
263  fid = powernow_table[index].index & 0xFF;
264  vid = (powernow_table[index].index & 0xFF00) >> 8;
265 
266  freqs.cpu = 0;
267 
268  rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
269  cfid = fidvidstatus.bits.CFID;
270  freqs.old = fsb * fid_codes[cfid] / 10;
271 
272  freqs.new = powernow_table[index].frequency;
273 
274  cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
275 
276  /* Now do the magic poking into the MSRs. */
277 
278  if (have_a0 == 1) /* A0 errata 5 */
279  local_irq_disable();
280 
281  if (freqs.old > freqs.new) {
282  /* Going down, so change FID first */
283  change_FID(fid);
284  change_VID(vid);
285  } else {
286  /* Going up, so change VID first */
287  change_VID(vid);
288  change_FID(fid);
289  }
290 
291 
292  if (have_a0 == 1)
293  local_irq_enable();
294 
295  cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
296 }
297 
298 
299 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
300 
301 static struct acpi_processor_performance *acpi_processor_perf;
302 
303 static int powernow_acpi_init(void)
304 {
305  int i;
306  int retval = 0;
307  union powernow_acpi_control_t pc;
308 
309  if (acpi_processor_perf != NULL && powernow_table != NULL) {
310  retval = -EINVAL;
311  goto err0;
312  }
313 
314  acpi_processor_perf = kzalloc(sizeof(struct acpi_processor_performance),
315  GFP_KERNEL);
316  if (!acpi_processor_perf) {
317  retval = -ENOMEM;
318  goto err0;
319  }
320 
321  if (!zalloc_cpumask_var(&acpi_processor_perf->shared_cpu_map,
322  GFP_KERNEL)) {
323  retval = -ENOMEM;
324  goto err05;
325  }
326 
327  if (acpi_processor_register_performance(acpi_processor_perf, 0)) {
328  retval = -EIO;
329  goto err1;
330  }
331 
332  if (acpi_processor_perf->control_register.space_id !=
333  ACPI_ADR_SPACE_FIXED_HARDWARE) {
334  retval = -ENODEV;
335  goto err2;
336  }
337 
338  if (acpi_processor_perf->status_register.space_id !=
339  ACPI_ADR_SPACE_FIXED_HARDWARE) {
340  retval = -ENODEV;
341  goto err2;
342  }
343 
344  number_scales = acpi_processor_perf->state_count;
345 
346  if (number_scales < 2) {
347  retval = -ENODEV;
348  goto err2;
349  }
350 
351  powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
352  (number_scales + 1)), GFP_KERNEL);
353  if (!powernow_table) {
354  retval = -ENOMEM;
355  goto err2;
356  }
357 
358  pc.val = (unsigned long) acpi_processor_perf->states[0].control;
359  for (i = 0; i < number_scales; i++) {
360  u8 fid, vid;
361  struct acpi_processor_px *state =
362  &acpi_processor_perf->states[i];
363  unsigned int speed, speed_mhz;
364 
365  pc.val = (unsigned long) state->control;
366  pr_debug("acpi: P%d: %d MHz %d mW %d uS control %08x SGTC %d\n",
367  i,
368  (u32) state->core_frequency,
369  (u32) state->power,
370  (u32) state->transition_latency,
371  (u32) state->control,
372  pc.bits.sgtc);
373 
374  vid = pc.bits.vid;
375  fid = pc.bits.fid;
376 
377  powernow_table[i].frequency = fsb * fid_codes[fid] / 10;
378  powernow_table[i].index = fid; /* lower 8 bits */
379  powernow_table[i].index |= (vid << 8); /* upper 8 bits */
380 
381  speed = powernow_table[i].frequency;
382  speed_mhz = speed / 1000;
383 
384  /* processor_perflib will multiply the MHz value by 1000 to
385  * get a KHz value (e.g. 1266000). However, powernow-k7 works
386  * with true KHz values (e.g. 1266768). To ensure that all
387  * powernow frequencies are available, we must ensure that
388  * ACPI doesn't restrict them, so we round up the MHz value
389  * to ensure that perflib's computed KHz value is greater than
390  * or equal to powernow's KHz value.
391  */
392  if (speed % 1000 > 0)
393  speed_mhz++;
394 
395  if ((fid_codes[fid] % 10) == 5) {
396  if (have_a0 == 1)
397  invalidate_entry(i);
398  }
399 
400  pr_debug(" FID: 0x%x (%d.%dx [%dMHz]) "
401  "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10,
402  fid_codes[fid] % 10, speed_mhz, vid,
403  mobile_vid_table[vid]/1000,
404  mobile_vid_table[vid]%1000);
405 
406  if (state->core_frequency != speed_mhz) {
407  state->core_frequency = speed_mhz;
408  pr_debug(" Corrected ACPI frequency to %d\n",
409  speed_mhz);
410  }
411 
412  if (latency < pc.bits.sgtc)
413  latency = pc.bits.sgtc;
414 
415  if (speed < minimum_speed)
416  minimum_speed = speed;
417  if (speed > maximum_speed)
418  maximum_speed = speed;
419  }
420 
421  powernow_table[i].frequency = CPUFREQ_TABLE_END;
422  powernow_table[i].index = 0;
423 
424  /* notify BIOS that we exist */
425  acpi_processor_notify_smm(THIS_MODULE);
426 
427  return 0;
428 
429 err2:
430  acpi_processor_unregister_performance(acpi_processor_perf, 0);
431 err1:
432  free_cpumask_var(acpi_processor_perf->shared_cpu_map);
433 err05:
434  kfree(acpi_processor_perf);
435 err0:
436  printk(KERN_WARNING PFX "ACPI perflib can not be used on "
437  "this platform\n");
438  acpi_processor_perf = NULL;
439  return retval;
440 }
441 #else
442 static int powernow_acpi_init(void)
443 {
444  printk(KERN_INFO PFX "no support for ACPI processor found."
445  " Please recompile your kernel with ACPI processor\n");
446  return -EINVAL;
447 }
448 #endif
449 
450 static void print_pst_entry(struct pst_s *pst, unsigned int j)
451 {
452  pr_debug("PST:%d (@%p)\n", j, pst);
453  pr_debug(" cpuid: 0x%x fsb: %d maxFID: 0x%x startvid: 0x%x\n",
454  pst->cpuid, pst->fsbspeed, pst->maxfid, pst->startvid);
455 }
456 
457 static int powernow_decode_bios(int maxfid, int startvid)
458 {
459  struct psb_s *psb;
460  struct pst_s *pst;
461  unsigned int i, j;
462  unsigned char *p;
463  unsigned int etuple;
464  unsigned int ret;
465 
466  etuple = cpuid_eax(0x80000001);
467 
468  for (i = 0xC0000; i < 0xffff0 ; i += 16) {
469 
470  p = phys_to_virt(i);
471 
472  if (memcmp(p, "AMDK7PNOW!", 10) == 0) {
473  pr_debug("Found PSB header at %p\n", p);
474  psb = (struct psb_s *) p;
475  pr_debug("Table version: 0x%x\n", psb->tableversion);
476  if (psb->tableversion != 0x12) {
477  printk(KERN_INFO PFX "Sorry, only v1.2 tables"
478  " supported right now\n");
479  return -ENODEV;
480  }
481 
482  pr_debug("Flags: 0x%x\n", psb->flags);
483  if ((psb->flags & 1) == 0)
484  pr_debug("Mobile voltage regulator\n");
485  else
486  pr_debug("Desktop voltage regulator\n");
487 
488  latency = psb->settlingtime;
489  if (latency < 100) {
490  printk(KERN_INFO PFX "BIOS set settling time "
491  "to %d microseconds. "
492  "Should be at least 100. "
493  "Correcting.\n", latency);
494  latency = 100;
495  }
496  pr_debug("Settling Time: %d microseconds.\n",
497  psb->settlingtime);
498  pr_debug("Has %d PST tables. (Only dumping ones "
499  "relevant to this CPU).\n",
500  psb->numpst);
501 
502  p += sizeof(struct psb_s);
503 
504  pst = (struct pst_s *) p;
505 
506  for (j = 0; j < psb->numpst; j++) {
507  pst = (struct pst_s *) p;
508  number_scales = pst->numpstates;
509 
510  if ((etuple == pst->cpuid) &&
511  check_fsb(pst->fsbspeed) &&
512  (maxfid == pst->maxfid) &&
513  (startvid == pst->startvid)) {
514  print_pst_entry(pst, j);
515  p = (char *)pst + sizeof(struct pst_s);
516  ret = get_ranges(p);
517  return ret;
518  } else {
519  unsigned int k;
520  p = (char *)pst + sizeof(struct pst_s);
521  for (k = 0; k < number_scales; k++)
522  p += 2;
523  }
524  }
525  printk(KERN_INFO PFX "No PST tables match this cpuid "
526  "(0x%x)\n", etuple);
527  printk(KERN_INFO PFX "This is indicative of a broken "
528  "BIOS.\n");
529 
530  return -EINVAL;
531  }
532  p++;
533  }
534 
535  return -ENODEV;
536 }
537 
538 
539 static int powernow_target(struct cpufreq_policy *policy,
540  unsigned int target_freq,
541  unsigned int relation)
542 {
543  unsigned int newstate;
544 
545  if (cpufreq_frequency_table_target(policy, powernow_table, target_freq,
546  relation, &newstate))
547  return -EINVAL;
548 
549  change_speed(newstate);
550 
551  return 0;
552 }
553 
554 
555 static int powernow_verify(struct cpufreq_policy *policy)
556 {
557  return cpufreq_frequency_table_verify(policy, powernow_table);
558 }
559 
560 /*
561  * We use the fact that the bus frequency is somehow
562  * a multiple of 100000/3 khz, then we compute sgtc according
563  * to this multiple.
564  * That way, we match more how AMD thinks all of that work.
565  * We will then get the same kind of behaviour already tested under
566  * the "well-known" other OS.
567  */
568 static int __cpuinit fixup_sgtc(void)
569 {
570  unsigned int sgtc;
571  unsigned int m;
572 
573  m = fsb / 3333;
574  if ((m % 10) >= 5)
575  m += 5;
576 
577  m /= 10;
578 
579  sgtc = 100 * m * latency;
580  sgtc = sgtc / 3;
581  if (sgtc > 0xfffff) {
582  printk(KERN_WARNING PFX "SGTC too large %d\n", sgtc);
583  sgtc = 0xfffff;
584  }
585  return sgtc;
586 }
587 
588 static unsigned int powernow_get(unsigned int cpu)
589 {
590  union msr_fidvidstatus fidvidstatus;
591  unsigned int cfid;
592 
593  if (cpu)
594  return 0;
595  rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
596  cfid = fidvidstatus.bits.CFID;
597 
598  return fsb * fid_codes[cfid] / 10;
599 }
600 
601 
602 static int __cpuinit acer_cpufreq_pst(const struct dmi_system_id *d)
603 {
604  printk(KERN_WARNING PFX
605  "%s laptop with broken PST tables in BIOS detected.\n",
606  d->ident);
607  printk(KERN_WARNING PFX
608  "You need to downgrade to 3A21 (09/09/2002), or try a newer "
609  "BIOS than 3A71 (01/20/2003)\n");
610  printk(KERN_WARNING PFX
611  "cpufreq scaling has been disabled as a result of this.\n");
612  return 0;
613 }
614 
615 /*
616  * Some Athlon laptops have really fucked PST tables.
617  * A BIOS update is all that can save them.
618  * Mention this, and disable cpufreq.
619  */
620 static struct dmi_system_id __cpuinitdata powernow_dmi_table[] = {
621  {
622  .callback = acer_cpufreq_pst,
623  .ident = "Acer Aspire",
624  .matches = {
625  DMI_MATCH(DMI_SYS_VENDOR, "Insyde Software"),
626  DMI_MATCH(DMI_BIOS_VERSION, "3A71"),
627  },
628  },
629  { }
630 };
631 
632 static int __cpuinit powernow_cpu_init(struct cpufreq_policy *policy)
633 {
634  union msr_fidvidstatus fidvidstatus;
635  int result;
636 
637  if (policy->cpu != 0)
638  return -ENODEV;
639 
640  rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
641 
642  recalibrate_cpu_khz();
643 
644  fsb = (10 * cpu_khz) / fid_codes[fidvidstatus.bits.CFID];
645  if (!fsb) {
646  printk(KERN_WARNING PFX "can not determine bus frequency\n");
647  return -EINVAL;
648  }
649  pr_debug("FSB: %3dMHz\n", fsb/1000);
650 
651  if (dmi_check_system(powernow_dmi_table) || acpi_force) {
652  printk(KERN_INFO PFX "PSB/PST known to be broken. "
653  "Trying ACPI instead\n");
654  result = powernow_acpi_init();
655  } else {
656  result = powernow_decode_bios(fidvidstatus.bits.MFID,
657  fidvidstatus.bits.SVID);
658  if (result) {
659  printk(KERN_INFO PFX "Trying ACPI perflib\n");
660  maximum_speed = 0;
661  minimum_speed = -1;
662  latency = 0;
663  result = powernow_acpi_init();
664  if (result) {
665  printk(KERN_INFO PFX
666  "ACPI and legacy methods failed\n");
667  }
668  } else {
669  /* SGTC use the bus clock as timer */
670  latency = fixup_sgtc();
671  printk(KERN_INFO PFX "SGTC: %d\n", latency);
672  }
673  }
674 
675  if (result)
676  return result;
677 
678  printk(KERN_INFO PFX "Minimum speed %d MHz. Maximum speed %d MHz.\n",
679  minimum_speed/1000, maximum_speed/1000);
680 
681  policy->cpuinfo.transition_latency =
682  cpufreq_scale(2000000UL, fsb, latency);
683 
684  policy->cur = powernow_get(0);
685 
686  cpufreq_frequency_table_get_attr(powernow_table, policy->cpu);
687 
688  return cpufreq_frequency_table_cpuinfo(policy, powernow_table);
689 }
690 
691 static int powernow_cpu_exit(struct cpufreq_policy *policy)
692 {
693  cpufreq_frequency_table_put_attr(policy->cpu);
694 
695 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
696  if (acpi_processor_perf) {
697  acpi_processor_unregister_performance(acpi_processor_perf, 0);
698  free_cpumask_var(acpi_processor_perf->shared_cpu_map);
699  kfree(acpi_processor_perf);
700  }
701 #endif
702 
703  kfree(powernow_table);
704  return 0;
705 }
706 
707 static struct freq_attr *powernow_table_attr[] = {
708  &cpufreq_freq_attr_scaling_available_freqs,
709  NULL,
710 };
711 
712 static struct cpufreq_driver powernow_driver = {
713  .verify = powernow_verify,
714  .target = powernow_target,
715  .get = powernow_get,
716 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
717  .bios_limit = acpi_processor_get_bios_limit,
718 #endif
719  .init = powernow_cpu_init,
720  .exit = powernow_cpu_exit,
721  .name = "powernow-k7",
722  .owner = THIS_MODULE,
723  .attr = powernow_table_attr,
724 };
725 
726 static int __init powernow_init(void)
727 {
728  if (check_powernow() == 0)
729  return -ENODEV;
730  return cpufreq_register_driver(&powernow_driver);
731 }
732 
733 
734 static void __exit powernow_exit(void)
735 {
736  cpufreq_unregister_driver(&powernow_driver);
737 }
738 
739 module_param(acpi_force, int, 0444);
740 MODULE_PARM_DESC(acpi_force, "Force ACPI to be used.");
741 
742 MODULE_AUTHOR("Dave Jones <[email protected]>");
743 MODULE_DESCRIPTION("Powernow driver for AMD K7 processors.");
744 MODULE_LICENSE("GPL");
745 
746 late_initcall(powernow_init);
747 module_exit(powernow_exit);
748 
Generated on Thu Jan 10 2013 13:28:39 for Linux Kernel by   doxygen 1.8.2