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