bk://linux-dj.bkbits.net/cpufreq
davej@redhat.com|ChangeSet|20040402110824|62928 davej
# This is a BitKeeper generated diff -Nru style patch.
#
# ChangeSet
# 2004/04/02 12:08:24+01:00 davej@redhat.com
# [CPUFREQ] powernow-k8 SMP work part 2.
# Introduce a per-cpu powernow_k8_data struct, and pass it around between all
# the functions that need to know about it.
#
# arch/i386/kernel/cpu/cpufreq/powernow-k8.h
# 2004/04/02 12:08:18+01:00 davej@redhat.com +30 -3
# [CPUFREQ] powernow-k8 SMP work part 2.
# Introduce a per-cpu powernow_k8_data struct, and pass it around between all
# the functions that need to know about it.
#
# arch/i386/kernel/cpu/cpufreq/powernow-k8.c
# 2004/04/02 12:08:18+01:00 davej@redhat.com +205 -209
# [CPUFREQ] powernow-k8 SMP work part 2.
# Introduce a per-cpu powernow_k8_data struct, and pass it around between all
# the functions that need to know about it.
#
# ChangeSet
# 2004/04/02 11:07:05+01:00 davej@redhat.com
# [CPUFREQ] Step 1 of SMP support for powernow-k8.
# Move lots of code to the cpu init routine from the detection routine.
# Do some SMP sanity checks in the detection routine.
#
# arch/i386/kernel/cpu/cpufreq/powernow-k8.c
# 2004/04/02 11:06:59+01:00 davej@redhat.com +27 -13
# [CPUFREQ] Step 1 of SMP support for powernow-k8.
# Move lots of code to the cpu init routine from the detection routine.
# Do some SMP sanity checks in the detection routine.
#
# ChangeSet
# 2004/04/02 01:06:07+01:00 davej@redhat.com
# [CPUFREQ] powernow-k8 whitespace changes.
# Trying to get the diffsize down between me & Pavel.
#
# arch/i386/kernel/cpu/cpufreq/powernow-k8.c
# 2004/04/02 01:06:01+01:00 davej@redhat.com +10 -16
# [CPUFREQ] powernow-k8 whitespace changes.
# Trying to get the diffsize down between me & Pavel.
#
# ChangeSet
# 2004/04/02 00:29:20+01:00 davej@redhat.com
# [CPUFREQ] fix compilation of speedstep-lib with DEBUG set
#
# arch/i386/kernel/cpu/cpufreq/speedstep-lib.c
# 2004/04/02 00:29:13+01:00 davej@redhat.com +1 -1
# [CPUFREQ] fix compilation of speedstep-lib with DEBUG set
#
# ChangeSet
# 2004/04/01 21:27:11+01:00 davej@redhat.com
# [CPUFREQ] Various updates/fixes to the powernow-k8 comment header.
#
# arch/i386/kernel/cpu/cpufreq/powernow-k8.c
# 2004/04/01 21:27:05+01:00 davej@redhat.com +6 -5
# [CPUFREQ] Various updates/fixes to the powernow-k8 comment header.
#
# ChangeSet
# 2004/03/19 20:55:49+00:00 davej@redhat.com
# [CPUFREQ] Extra __init section function for longhaul driver.
# From Luiz Fernando Capitulino
#
# arch/i386/kernel/cpu/cpufreq/longhaul.c
# 2004/03/19 20:55:44+00:00 davej@redhat.com +1 -1
# [CPUFREQ] Extra __init section function for longhaul driver.
# From Luiz Fernando Capitulino
#
# ChangeSet
# 2004/03/19 20:54:42+00:00 davej@redhat.com
# [CPUFREQ] Extra __init section function for longrun driver.
# From Luiz Fernando Capitulino
#
# arch/i386/kernel/cpu/cpufreq/longrun.c
# 2004/03/19 20:54:36+00:00 davej@redhat.com +1 -1
# [CPUFREQ] Extra __init section function for longrun driver.
# From Luiz Fernando Capitulino
#
# ChangeSet
# 2004/03/19 20:53:17+00:00 davej@redhat.com
# [CPUFREQ] Fix an off-by-10 value in the detection of the Pentium M processor frequency.
#
# arch/i386/kernel/cpu/cpufreq/speedstep-lib.c
# 2004/03/19 20:53:11+00:00 davej@redhat.com +1 -1
# [CPUFREQ] Fix an off-by-10 value in the detection of the Pentium M processor frequency.
#
# ChangeSet
# 2004/03/19 20:51:11+00:00 davej@redhat.com
# [CPUFREQ] SPEEDSTEP_RELAXED_CAP_CHECK option.
# A few SpeedStep-capable systems don't perform according to specification: the
# CPUID and/or some MSRs don't tell us the CPU is SpeedStep capable even though
# it definitely is. Allow a relaxed checking for one such issue by a module
# parameter only available if a config option is turned on. This is done to
# avoid the risk of doing invalid speedstep instructions on systems which do
# not support it, and which might even lead to (hardware) failure.
#
# Patch originally from Andres Aeriksson (?) aeriksson at fastmail (dot) fm
#
# arch/i386/kernel/cpu/cpufreq/speedstep-lib.c
# 2004/03/19 20:51:05+00:00 davej@redhat.com +14 -1
# [CPUFREQ] SPEEDSTEP_RELAXED_CAP_CHECK option.
# A few SpeedStep-capable systems don't perform according to specification: the
# CPUID and/or some MSRs don't tell us the CPU is SpeedStep capable even though
# it definitely is. Allow a relaxed checking for one such issue by a module
# parameter only available if a config option is turned on. This is done to
# avoid the risk of doing invalid speedstep instructions on systems which do
# not support it, and which might even lead to (hardware) failure.
#
# Patch originally from Andres Aeriksson (?) aeriksson at fastmail (dot) fm
#
# arch/i386/kernel/cpu/cpufreq/Kconfig
# 2004/03/19 20:51:05+00:00 davej@redhat.com +10 -0
# [CPUFREQ] SPEEDSTEP_RELAXED_CAP_CHECK option.
# A few SpeedStep-capable systems don't perform according to specification: the
# CPUID and/or some MSRs don't tell us the CPU is SpeedStep capable even though
# it definitely is. Allow a relaxed checking for one such issue by a module
# parameter only available if a config option is turned on. This is done to
# avoid the risk of doing invalid speedstep instructions on systems which do
# not support it, and which might even lead to (hardware) failure.
#
# Patch originally from Andres Aeriksson (?) aeriksson at fastmail (dot) fm
#
# ChangeSet
# 2004/03/19 20:47:48+00:00 davej@redhat.com
# [CPUFREQ] Fix up centrino initcall level
# centrino_init needs to be late_initcall so that the ACPI processor module
# is completely up and running.
#
# arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
# 2004/03/19 20:47:42+00:00 davej@redhat.com +1 -1
# [CPUFREQ] Fix up centrino initcall level
# centrino_init needs to be late_initcall so that the ACPI processor module
# is completely up and running.
#
# ChangeSet
# 2004/03/19 20:46:16+00:00 davej@redhat.com
# [CPUFREQ] Export an array of available frequency settings of the centrino driver.
#
# arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
# 2004/03/19 20:46:11+00:00 davej@redhat.com +16 -1
# [CPUFREQ] Export an array of available frequency settings of the centrino driver.
#
# ChangeSet
# 2004/03/19 20:44:09+00:00 davej@redhat.com
# [CPUFREQ] Merge ACPI perflib.
# Use ACPI _PSS data to determine valid frequency and voltage pairs on Enhanced
# SpeedStep-capable processors. An original form of such ACPI-PentiumM-cpufreq
# interaction was sent to the cpufreq list by David Moore in June last year; the
# attached patch utilizes his code to set _PDC.
#
# The new ACPI "P-States library" is utilized to obtain the correct frequency
# and MSR value pairs for the speedstep-centrino driver. Only if no such proper
# table exists (!CONFIG_ACPI, broken ACPI tables, etc.), fall back to the
# existing hard-coded table.
#
# If anyone has a better idea for the Kconfig section, please tell me so.
#
# This version of this patch has proper acpi_state setting included, and also
# has a hint in the banner of the centrino_cpu_init_acpi() function, as Jeremey
# Fitzhardinge suggested.
#
# arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
# 2004/03/19 20:44:03+00:00 davej@redhat.com +144 -5
# [CPUFREQ] Merge ACPI perflib.
# Use ACPI _PSS data to determine valid frequency and voltage pairs on Enhanced
# SpeedStep-capable processors. An original form of such ACPI-PentiumM-cpufreq
# interaction was sent to the cpufreq list by David Moore in June last year; the
# attached patch utilizes his code to set _PDC.
#
# The new ACPI "P-States library" is utilized to obtain the correct frequency
# and MSR value pairs for the speedstep-centrino driver. Only if no such proper
# table exists (!CONFIG_ACPI, broken ACPI tables, etc.), fall back to the
# existing hard-coded table.
#
# If anyone has a better idea for the Kconfig section, please tell me so.
#
# This version of this patch has proper acpi_state setting included, and also
# has a hint in the banner of the centrino_cpu_init_acpi() function, as Jeremey
# Fitzhardinge suggested.
#
# arch/i386/kernel/cpu/cpufreq/Kconfig
# 2004/03/19 20:44:03+00:00 davej@redhat.com +15 -0
# [CPUFREQ] Merge ACPI perflib.
# Use ACPI _PSS data to determine valid frequency and voltage pairs on Enhanced
# SpeedStep-capable processors. An original form of such ACPI-PentiumM-cpufreq
# interaction was sent to the cpufreq list by David Moore in June last year; the
# attached patch utilizes his code to set _PDC.
#
# The new ACPI "P-States library" is utilized to obtain the correct frequency
# and MSR value pairs for the speedstep-centrino driver. Only if no such proper
# table exists (!CONFIG_ACPI, broken ACPI tables, etc.), fall back to the
# existing hard-coded table.
#
# If anyone has a better idea for the Kconfig section, please tell me so.
#
# This version of this patch has proper acpi_state setting included, and also
# has a hint in the banner of the centrino_cpu_init_acpi() function, as Jeremey
# Fitzhardinge suggested.
#
# ChangeSet
# 2004/03/19 20:43:06+00:00 davej@redhat.com
# [CPUFREQ] Move the centrino table matching into an own function
# Only the FEATURE_EST bit for CPU 0 is checked in module_init() directly.
# As cpufreq drivers aren't sticky any longer (see previous patch),
# this will not change user-visible behaviour.
#
# arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
# 2004/03/19 20:43:01+00:00 davej@redhat.com +60 -46
# [CPUFREQ] Move the centrino table matching into an own function
# Only the FEATURE_EST bit for CPU 0 is checked in module_init() directly.
# As cpufreq drivers aren't sticky any longer (see previous patch),
# this will not change user-visible behaviour.
#
# ChangeSet
# 2004/03/19 20:36:51+00:00 davej@redhat.com
# [CPUFREQ] Use KERN_WARNING for warning.
#
# arch/i386/kernel/cpu/cpufreq/p4-clockmod.c
# 2004/03/19 20:36:46+00:00 davej@redhat.com +10 -7
# [CPUFREQ] Use KERN_WARNING for warning.
#
# ChangeSet
# 2004/03/19 20:35:52+00:00 davej@redhat.com
# [CPUFREQ] If ->init fails, unregister cpufreq driver.
# Some cpufreq drivers can only tell whether they work while the per-CPU
# ->init() function is executed [e.g. the acpi driver]. So that cpufreq_driver
# isn't blocked by such stale drivers, unload them unless the driver sets a
# special flag.
#
# include/linux/cpufreq.h
# 2004/03/19 20:35:46+00:00 davej@redhat.com +6 -0
# [CPUFREQ] If ->init fails, unregister cpufreq driver.
# Some cpufreq drivers can only tell whether they work while the per-CPU
# ->init() function is executed [e.g. the acpi driver]. So that cpufreq_driver
# isn't blocked by such stale drivers, unload them unless the driver sets a
# special flag.
#
# drivers/cpufreq/cpufreq.c
# 2004/03/19 20:35:46+00:00 davej@redhat.com +23 -1
# [CPUFREQ] If ->init fails, unregister cpufreq driver.
# Some cpufreq drivers can only tell whether they work while the per-CPU
# ->init() function is executed [e.g. the acpi driver]. So that cpufreq_driver
# isn't blocked by such stale drivers, unload them unless the driver sets a
# special flag.
#
diff -Nru a/arch/i386/kernel/cpu/cpufreq/Kconfig b/arch/i386/kernel/cpu/cpufreq/Kconfig
--- a/arch/i386/kernel/cpu/cpufreq/Kconfig Sun Apr 4 18:51:43 2004
+++ b/arch/i386/kernel/cpu/cpufreq/Kconfig Sun Apr 4 18:51:43 2004
@@ -120,6 +120,21 @@
If in doubt, say N.
+config X86_SPEEDSTEP_CENTRINO_TABLE
+ bool
+ depends on X86_SPEEDSTEP_CENTRINO
+ default y
+
+config X86_SPEEDSTEP_CENTRINO_ACPI
+ bool "Use ACPI tables to decode valid frequency/voltage pairs (EXPERIMENTAL)"
+ depends on EXPERIMENTAL
+ depends on ((X86_SPEEDSTEP_CENTRINO = "m" && ACPI_PROCESSOR) || (X86_SPEEDSTEP_CENTRINO = "y" && ACPI_PROCESSOR = "y"))
+ help
+ Use primarily the information provided in the BIOS ACPI tables
+ to determine valid CPU frequency and voltage pairings.
+
+ If in doubt, say Y.
+
config X86_SPEEDSTEP_ICH
tristate "Intel Speedstep on ICH-M chipsets (ioport interface)"
depends on CPU_FREQ_TABLE
@@ -160,6 +175,16 @@
tristate
depends on (X86_SPEEDSTEP_ICH || X86_SPEEDSTEP_SMI || X86_P4_CLOCKMOD)
default (X86_SPEEDSTEP_ICH || X86_SPEEDSTEP_SMI || X86_P4_CLOCKMOD)
+
+config X86_SPEEDSTEP_RELAXED_CAP_CHECK
+ bool "Relaxed speedstep capability checks"
+ depends on (X86_SPEEDSTEP_SMI || X86_SPEEDSTEP_ICH)
+ help
+ Don't perform all checks for a speedstep capable system which would
+ normally be done. Some ancient or strange systems, though speedstep
+ capable, don't always indicate that they are speedstep capable. This
+ option let's the probing code bypass some of those checks if the
+ parameter "relaxed_check=1" is passed to the module.
config X86_LONGRUN
tristate "Transmeta LongRun"
diff -Nru a/arch/i386/kernel/cpu/cpufreq/longhaul.c b/arch/i386/kernel/cpu/cpufreq/longhaul.c
--- a/arch/i386/kernel/cpu/cpufreq/longhaul.c Sun Apr 4 18:51:43 2004
+++ b/arch/i386/kernel/cpu/cpufreq/longhaul.c Sun Apr 4 18:51:43 2004
@@ -458,7 +458,7 @@
return 0;
}
-static int longhaul_cpu_exit(struct cpufreq_policy *policy)
+static int __exit longhaul_cpu_exit(struct cpufreq_policy *policy)
{
cpufreq_frequency_table_put_attr(policy->cpu);
return 0;
diff -Nru a/arch/i386/kernel/cpu/cpufreq/longrun.c b/arch/i386/kernel/cpu/cpufreq/longrun.c
--- a/arch/i386/kernel/cpu/cpufreq/longrun.c Sun Apr 4 18:51:43 2004
+++ b/arch/i386/kernel/cpu/cpufreq/longrun.c Sun Apr 4 18:51:43 2004
@@ -33,7 +33,7 @@
* Reads the current LongRun policy by access to MSR_TMTA_LONGRUN_FLAGS
* and MSR_TMTA_LONGRUN_CTRL
*/
-static void longrun_get_policy(struct cpufreq_policy *policy)
+static void __init longrun_get_policy(struct cpufreq_policy *policy)
{
u32 msr_lo, msr_hi;
diff -Nru a/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c b/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c
--- a/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c Sun Apr 4 18:51:43 2004
+++ b/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c Sun Apr 4 18:51:43 2004
@@ -181,21 +181,24 @@
{
if ((c->x86 == 0x06) && (c->x86_model == 0x09)) {
/* Pentium M */
- printk(KERN_DEBUG PFX "Warning: Pentium M detected. The speedstep_centrino module\n");
- printk(KERN_DEBUG PFX "offers voltage scaling in addition of frequency scaling. You\n");
- printk(KERN_DEBUG PFX "should use that instead of p4-clockmod, if possible.\n");
+ printk(KERN_WARNING PFX "Warning: Pentium M detected. "
+ "The speedstep_centrino module offers voltage scaling"
+ " in addition of frequency scaling. You should use "
+ "that instead of p4-clockmod, if possible.\n");
return speedstep_get_processor_frequency(SPEEDSTEP_PROCESSOR_PM);
}
if (c->x86 != 0xF) {
- printk(KERN_DEBUG PFX "Unknown p4-clockmod-capable CPU. Please send an e-mail to <linux@brodo.de>\n");
+ printk(KERN_WARNING PFX "Unknown p4-clockmod-capable CPU. Please send an e-mail to <linux@brodo.de>\n");
return 0;
}
if (speedstep_detect_processor() == SPEEDSTEP_PROCESSOR_P4M) {
- printk(KERN_DEBUG PFX "Warning: Pentium 4-M detected. The speedstep-ich or acpi cpufreq \n");
- printk(KERN_DEBUG PFX "modules offers voltage scaling in addition of frequency scaling. You\n");
- printk(KERN_DEBUG PFX "should use either one instead of p4-clockmod, if possible.\n");
+ printk(KERN_WARNING PFX "Warning: Pentium 4-M detected. "
+ "The speedstep-ich or acpi cpufreq modules offers "
+ "voltage scaling in addition of frequency scaling. "
+ "You should use either one instead of p4-clockmod, "
+ "if possible.\n");
return speedstep_get_processor_frequency(SPEEDSTEP_PROCESSOR_P4M);
}
diff -Nru a/arch/i386/kernel/cpu/cpufreq/powernow-k8.c b/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
--- a/arch/i386/kernel/cpu/cpufreq/powernow-k8.c Sun Apr 4 18:51:43 2004
+++ b/arch/i386/kernel/cpu/cpufreq/powernow-k8.c Sun Apr 4 18:51:43 2004
@@ -1,22 +1,23 @@
/*
- * (c) 2003 Advanced Micro Devices, Inc.
+ * (c) 2003, 2004 Advanced Micro Devices, Inc.
* Your use of this code is subject to the terms and conditions of the
- * GNU general public license version 2. See "../../../COPYING" or
+ * GNU general public license version 2. See "COPYING" or
* http://www.gnu.org/licenses/gpl.html
*
* Support : paul.devriendt@amd.com
*
* Based on the powernow-k7.c module written by Dave Jones.
- * (C) 2003 Dave Jones <davej@codemonkey.ork.uk> on behalf of SuSE Labs
+ * (C) 2003 Dave Jones <davej@codemonkey.org.uk> on behalf of SuSE Labs
* (C) 2004 Dominik Brodowski <linux@brodo.de>
* (C) 2004 Pavel Machek <pavel@suse.cz>
* Licensed under the terms of the GNU GPL License version 2.
* Based upon datasheets & sample CPUs kindly provided by AMD.
*
+ * Valuable input gratefully received from Dave Jones, Pavel Machek,
+ * Dominik Brodowski, and others.
* Processor information obtained from Chapter 9 (Power and Thermal Management)
* of the "BIOS and Kernel Developer's Guide for the AMD Athlon 64 and AMD
- * Opteron Processors", revision 3.03, available for download from www.amd.com
- *
+ * Opteron Processors" available for download from www.amd.com
*/
#include <linux/kernel.h>
@@ -36,16 +37,7 @@
#define VERSION "version 1.00.08a"
#include "powernow-k8.h"
-static u32 vstable; /* voltage stabalization time, from PSB, units 20 us */
-static u32 plllock; /* pll lock time, from PSB, units 1 us */
-static u32 numps; /* number of p-states, from PSB */
-static u32 rvo; /* ramp voltage offset, from PSB */
-static u32 irt; /* isochronous relief time, from PSB */
-static u32 vidmvs; /* usable value calculated from mvs, from PSB */
-static u32 currvid; /* keep track of the current fid / vid */
-static u32 currfid;
-
-static struct cpufreq_frequency_table *powernow_table;
+static struct powernow_k8_data *powernow_data[NR_CPUS];
/*
The PSB table supplied by BIOS allows for the definition of the number of
@@ -78,8 +70,7 @@
/* Return the vco fid for an input fid */
-static u32
-convert_fid_to_vco_fid(u32 fid)
+static u32 convert_fid_to_vco_fid(u32 fid)
{
if (fid < HI_FID_TABLE_BOTTOM) {
return 8 + (2 * fid);
@@ -89,11 +80,10 @@
}
/*
- * Return 1 if the pending bit is set. Unless we are actually just told the
- * processor to transition a state, seeing this bit set is really bad news.
+ * Return 1 if the pending bit is set. Unless we just instructed the processor
+ * to transition to a new state, seeing this bit set is really bad news.
*/
-static inline int
-pending_bit_stuck(void)
+static inline int pending_bit_stuck(void)
{
u32 lo, hi;
@@ -102,11 +92,10 @@
}
/*
- * Update the global current fid / vid values from the status msr. Returns 1
- * on error.
+ * Update the global current fid / vid values from the status msr.
+ * Returns 1 on error.
*/
-static int
-query_current_values_with_pending_wait(void)
+static int query_current_values_with_pending_wait(struct powernow_k8_data *data)
{
u32 lo, hi;
u32 i = 0;
@@ -120,63 +109,58 @@
rdmsr(MSR_FIDVID_STATUS, lo, hi);
}
- currvid = hi & MSR_S_HI_CURRENT_VID;
- currfid = lo & MSR_S_LO_CURRENT_FID;
+ data->currvid = hi & MSR_S_HI_CURRENT_VID;
+ data->currfid = lo & MSR_S_LO_CURRENT_FID;
return 0;
}
/* the isochronous relief time */
-static inline void
-count_off_irt(void)
+static inline void count_off_irt(struct powernow_k8_data *data)
{
- udelay((1 << irt) * 10);
+ udelay((1 << data->irt) * 10);
return;
}
/* the voltage stabalization time */
-static inline void
-count_off_vst(void)
+static inline void count_off_vst(struct powernow_k8_data *data)
{
- udelay(vstable * VST_UNITS_20US);
+ udelay(data->vstable * VST_UNITS_20US);
return;
}
/* write the new fid value along with the other control fields to the msr */
-static int
-write_new_fid(u32 fid)
+static int write_new_fid(struct powernow_k8_data *data, u32 fid)
{
u32 lo;
- u32 savevid = currvid;
+ u32 savevid = data->currvid;
- if ((fid & INVALID_FID_MASK) || (currvid & INVALID_VID_MASK)) {
+ if ((fid & INVALID_FID_MASK) || (data->currvid & INVALID_VID_MASK)) {
printk(KERN_ERR PFX "internal error - overflow on fid write\n");
return 1;
}
- lo = fid | (currvid << MSR_C_LO_VID_SHIFT) | MSR_C_LO_INIT_FID_VID;
+ lo = fid | (data->currvid << MSR_C_LO_VID_SHIFT) | MSR_C_LO_INIT_FID_VID;
dprintk(KERN_DEBUG PFX "writing fid %x, lo %x, hi %x\n",
- fid, lo, plllock * PLL_LOCK_CONVERSION);
+ fid, lo, data->plllock * PLL_LOCK_CONVERSION);
- wrmsr(MSR_FIDVID_CTL, lo, plllock * PLL_LOCK_CONVERSION);
+ wrmsr(MSR_FIDVID_CTL, lo, data->plllock * PLL_LOCK_CONVERSION);
- if (query_current_values_with_pending_wait())
+ if (query_current_values_with_pending_wait(data))
return 1;
- count_off_irt();
+ count_off_irt(data);
- if (savevid != currvid) {
- printk(KERN_ERR PFX
- "vid changed on fid transition, save %x, currvid %x\n",
- savevid, currvid);
+ if (savevid != data->currvid) {
+ printk(KERN_ERR PFX "vid change on fid trans, old %x, new %x\n",
+ savevid, data->currvid);
return 1;
}
- if (fid != currfid) {
- printk(KERN_ERR PFX
- "fid transition failed, fid %x, currfid %x\n",
- fid, currfid);
+ if (fid != data->currfid) {
+ printk(KERN_ERR PFX "fid trans failed, fid %x, curr %x\n", fid,
+ data->currfid);
return 1;
}
@@ -184,39 +168,35 @@
}
/* Write a new vid to the hardware */
-static int
-write_new_vid(u32 vid)
+static int write_new_vid(struct powernow_k8_data *data, u32 vid)
{
u32 lo;
- u32 savefid = currfid;
+ u32 savefid = data->currfid;
- if ((currfid & INVALID_FID_MASK) || (vid & INVALID_VID_MASK)) {
+ if ((data->currfid & INVALID_FID_MASK) || (vid & INVALID_VID_MASK)) {
printk(KERN_ERR PFX "internal error - overflow on vid write\n");
return 1;
}
- lo = currfid | (vid << MSR_C_LO_VID_SHIFT) | MSR_C_LO_INIT_FID_VID;
+ lo = data->currfid | (vid << MSR_C_LO_VID_SHIFT) | MSR_C_LO_INIT_FID_VID;
dprintk(KERN_DEBUG PFX "writing vid %x, lo %x, hi %x\n",
vid, lo, STOP_GRANT_5NS);
wrmsr(MSR_FIDVID_CTL, lo, STOP_GRANT_5NS);
- if (query_current_values_with_pending_wait()) {
+ if (query_current_values_with_pending_wait(data))
return 1;
- }
- if (savefid != currfid) {
- printk(KERN_ERR PFX
- "fid changed on vid transition, save %x currfid %x\n",
- savefid, currfid);
+ if (savefid != data->currfid) {
+ printk(KERN_ERR PFX "fid changed on vid trans, old %x new %x\n",
+ savefid, data->currfid);
return 1;
}
- if (vid != currvid) {
- printk(KERN_ERR PFX
- "vid transition failed, vid %x, currvid %x\n",
- vid, currvid);
+ if (vid != data->currvid) {
+ printk(KERN_ERR PFX "vid trans failed, vid %x, curr %x\n", vid,
+ data->currvid);
return 1;
}
@@ -228,224 +208,218 @@
* Decreasing vid codes represent increasing voltages:
* vid of 0 is 1.550V, vid of 0x1e is 0.800V, vid of 0x1f is off.
*/
-static int
-decrease_vid_code_by_step(u32 reqvid, u32 step)
+static int decrease_vid_code_by_step(struct powernow_k8_data *data, u32 reqvid, u32 step)
{
- if ((currvid - reqvid) > step)
- reqvid = currvid - step;
+ if ((data->currvid - reqvid) > step)
+ reqvid = data->currvid - step;
- if (write_new_vid(reqvid))
+ if (write_new_vid(data, reqvid))
return 1;
- count_off_vst();
+ count_off_vst(data);
return 0;
}
/* Change the fid and vid, by the 3 phases. */
-static inline int
-transition_fid_vid(u32 reqfid, u32 reqvid)
+static int transition_fid_vid(struct powernow_k8_data *data, u32 reqfid, u32 reqvid)
{
- if (core_voltage_pre_transition(reqvid))
+ if (core_voltage_pre_transition(data, reqvid))
return 1;
- if (core_frequency_transition(reqfid))
+ if (core_frequency_transition(data, reqfid))
return 1;
- if (core_voltage_post_transition(reqvid))
+ if (core_voltage_post_transition(data, reqvid))
return 1;
- if (query_current_values_with_pending_wait())
+ if (query_current_values_with_pending_wait(data))
return 1;
- if ((reqfid != currfid) || (reqvid != currvid)) {
- printk(KERN_ERR PFX "failed: req 0x%x 0x%x, curr 0x%x 0x%x\n",
- reqfid, reqvid, currfid, currvid);
+ if ((reqfid != data->currfid) || (reqvid != data->currvid)) {
+ printk(KERN_ERR PFX "failed (cpu%d): req 0x%x 0x%x, curr 0x%x 0x%x\n",
+ smp_processor_id(),
+ reqfid, reqvid, data->currfid, data->currvid);
return 1;
}
- dprintk(KERN_INFO PFX
- "transitioned: new fid 0x%x, vid 0x%x\n", currfid, currvid);
+ dprintk(KERN_INFO PFX "transitioned (cpu%d): new fid 0x%x, vid 0x%x\n",
+ smp_processor_id(), data->currfid, data->currvid);
return 0;
}
-/*
- * Phase 1 - core voltage transition ... setup appropriate voltage for the
- * fid transition.
- */
-static inline int
-core_voltage_pre_transition(u32 reqvid)
+/* Phase 1 - core voltage transition ... setup voltage */
+static int core_voltage_pre_transition(struct powernow_k8_data *data, u32 reqvid)
{
- u32 rvosteps = rvo;
- u32 savefid = currfid;
+ u32 rvosteps = data->rvo;
+ u32 savefid = data->currfid;
dprintk(KERN_DEBUG PFX
- "ph1: start, currfid 0x%x, currvid 0x%x, reqvid 0x%x, rvo %x\n",
- currfid, currvid, reqvid, rvo);
-
- while (currvid > reqvid) {
- dprintk(KERN_DEBUG PFX "ph1: curr 0x%x, requesting vid 0x%x\n",
- currvid, reqvid);
- if (decrease_vid_code_by_step(reqvid, vidmvs))
+ "ph1 (cpu%d): start, currfid 0x%x, currvid 0x%x, reqvid 0x%x, rvo 0x%x\n",
+ smp_processor_id();
+ data->currfid, data->currvid, reqvid, data->rvo);
+
+ while (data->currvid > reqvid) {
+ dprintk(KERN_DEBUG PFX "ph1: curr 0x%x, req vid 0x%x\n",
+ data->currvid, reqvid);
+ if (decrease_vid_code_by_step(data, reqvid, data->vidmvs))
return 1;
}
while (rvosteps > 0) {
- if (currvid == 0) {
+ if (data->currvid == 0) {
rvosteps = 0;
} else {
dprintk(KERN_DEBUG PFX
- "ph1: changing vid for rvo, requesting 0x%x\n",
- currvid - 1);
- if (decrease_vid_code_by_step(currvid - 1, 1))
+ "ph1: changing vid for rvo, req 0x%x\n",
+ data->currvid - 1);
+ if (decrease_vid_code_by_step(data, data->currvid - 1, 1))
return 1;
rvosteps--;
}
}
- if (query_current_values_with_pending_wait())
+ if (query_current_values_with_pending_wait(data))
return 1;
- if (savefid != currfid) {
- printk(KERN_ERR PFX "ph1 err, currfid changed 0x%x\n", currfid);
+ if (savefid != data->currfid) {
+ printk(KERN_ERR PFX "ph1 err, currfid changed 0x%x\n", data->currfid);
return 1;
}
dprintk(KERN_DEBUG PFX "ph1 complete, currfid 0x%x, currvid 0x%x\n",
- currfid, currvid);
+ data->currfid, data->currvid);
return 0;
}
/* Phase 2 - core frequency transition */
-static inline int
-core_frequency_transition(u32 reqfid)
+static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid)
{
u32 vcoreqfid;
u32 vcocurrfid;
u32 vcofiddiff;
- u32 savevid = currvid;
+ u32 savevid = data->currvid;
- if ((reqfid < HI_FID_TABLE_BOTTOM) && (currfid < HI_FID_TABLE_BOTTOM)) {
- printk(KERN_ERR PFX "ph2 illegal lo-lo transition 0x%x 0x%x\n",
- reqfid, currfid);
+ if ((reqfid < HI_FID_TABLE_BOTTOM) && (data->currfid < HI_FID_TABLE_BOTTOM)) {
+ printk(KERN_ERR PFX "ph2: illegal lo-lo transition 0x%x 0x%x\n",
+ reqfid, data->currfid);
return 1;
}
- if (currfid == reqfid) {
- printk(KERN_ERR PFX "ph2 null fid transition 0x%x\n", currfid);
+ if (data->currfid == reqfid) {
+ printk(KERN_ERR PFX "ph2 null fid transition 0x%x\n", data->currfid);
return 0;
}
dprintk(KERN_DEBUG PFX
- "ph2 starting, currfid 0x%x, currvid 0x%x, reqfid 0x%x\n",
- currfid, currvid, reqfid);
+ "ph2 (cpu%d): starting, currfid 0x%x, currvid 0x%x, reqfid 0x%x\n",
+ smp_processor_id(),
+ data->currfid, data->currvid, reqfid);
vcoreqfid = convert_fid_to_vco_fid(reqfid);
- vcocurrfid = convert_fid_to_vco_fid(currfid);
+ vcocurrfid = convert_fid_to_vco_fid(data->currfid);
vcofiddiff = vcocurrfid > vcoreqfid ? vcocurrfid - vcoreqfid
: vcoreqfid - vcocurrfid;
while (vcofiddiff > 2) {
- if (reqfid > currfid) {
- if (currfid > LO_FID_TABLE_TOP) {
- if (write_new_fid(currfid + 2)) {
+ if (reqfid > data->currfid) {
+ if (data->currfid > LO_FID_TABLE_TOP) {
+ if (write_new_fid(data, data->currfid + 2)) {
return 1;
}
} else {
if (write_new_fid
- (2 + convert_fid_to_vco_fid(currfid))) {
+ (data, 2 + convert_fid_to_vco_fid(data->currfid))) {
return 1;
}
}
} else {
- if (write_new_fid(currfid - 2))
+ if (write_new_fid(data, data->currfid - 2))
return 1;
}
- vcocurrfid = convert_fid_to_vco_fid(currfid);
+ vcocurrfid = convert_fid_to_vco_fid(data->currfid);
vcofiddiff = vcocurrfid > vcoreqfid ? vcocurrfid - vcoreqfid
: vcoreqfid - vcocurrfid;
}
- if (write_new_fid(reqfid))
+ if (write_new_fid(data, reqfid))
return 1;
- if (query_current_values_with_pending_wait())
+ if (query_current_values_with_pending_wait(data))
return 1;
- if (currfid != reqfid) {
+ if (data->currfid != reqfid) {
printk(KERN_ERR PFX
- "ph2 mismatch, failed fid transition, curr %x, req %x\n",
- currfid, reqfid);
+ "ph2: mismatch, failed fid transition, curr 0x%x, req 0x%x\n",
+ data->currfid, reqfid);
return 1;
}
- if (savevid != currvid) {
- printk(KERN_ERR PFX
- "ph2 vid changed, save %x, curr %x\n", savevid,
- currvid);
+ if (savevid != data->currvid) {
+ printk(KERN_ERR PFX "ph2: vid changed, save %x, curr %x\n",
+ savevid, data->currvid);
return 1;
}
dprintk(KERN_DEBUG PFX "ph2 complete, currfid 0x%x, currvid 0x%x\n",
- currfid, currvid);
+ data->currfid, data->currvid);
return 0;
}
/* Phase 3 - core voltage transition flow ... jump to the final vid. */
-static inline int
-core_voltage_post_transition(u32 reqvid)
+static int core_voltage_post_transition(struct powernow_k8_data *data, u32 reqvid)
{
- u32 savefid = currfid;
+ u32 savefid = data->currfid;
u32 savereqvid = reqvid;
- dprintk(KERN_DEBUG PFX "ph3 starting, currfid 0x%x, currvid 0x%x\n",
- currfid, currvid);
+ dprintk(KERN_DEBUG PFX "ph3 (cpu%d): starting, currfid 0x%x, currvid 0x%x\n",
+ smp_processor_id(),
+ data->currfid, data->currvid);
- if (reqvid != currvid) {
- if (write_new_vid(reqvid))
+ if (reqvid != data->currvid) {
+ if (write_new_vid(data, reqvid))
return 1;
- if (savefid != currfid) {
+ if (savefid != data->currfid) {
printk(KERN_ERR PFX
"ph3: bad fid change, save %x, curr %x\n",
- savefid, currfid);
+ savefid, data->currfid);
return 1;
}
- if (currvid != reqvid) {
+ if (data->currvid != reqvid) {
printk(KERN_ERR PFX
"ph3: failed vid transition\n, req %x, curr %x",
- reqvid, currvid);
+ reqvid, data->currvid);
return 1;
}
}
- if (query_current_values_with_pending_wait())
+ if (query_current_values_with_pending_wait(data))
return 1;
- if (savereqvid != currvid) {
- dprintk(KERN_ERR PFX "ph3 failed, currvid 0x%x\n", currvid);
+ if (savereqvid != data->currvid) {
+ dprintk(KERN_ERR PFX "ph3 failed, currvid 0x%x\n", data->currvid);
return 1;
}
- if (savefid != currfid) {
+ if (savefid != data->currfid) {
dprintk(KERN_ERR PFX "ph3 failed, currfid changed 0x%x\n",
- currfid);
+ data->currfid);
return 1;
}
dprintk(KERN_DEBUG PFX "ph3 complete, currfid 0x%x, currvid 0x%x\n",
- currfid, currvid);
+ data->currfid, data->currvid);
return 0;
}
-static inline int
-check_supported_cpu(void)
+static int check_supported_cpu(unsigned int cpu)
{
struct cpuinfo_x86 *c = cpu_data;
u32 eax, ebx, ecx, edx;
@@ -495,23 +469,23 @@
return 1;
}
-static int check_pst_table(struct pst_s *pst, u8 maxvid)
+static int check_pst_table(struct powernow_k8_data *data, struct pst_s *pst, u8 maxvid)
{
unsigned int j;
u8 lastfid = 0xFF;
- for (j = 0; j < numps; j++) {
+ for (j = 0; j < data->numps; j++) {
if (pst[j].vid > LEAST_VID) {
printk(KERN_ERR PFX "vid %d invalid : 0x%x\n", j, pst[j].vid);
return -EINVAL;
}
- if (pst[j].vid < rvo) { /* vid + rvo >= 0 */
+ if (pst[j].vid < data->rvo) { /* vid + rvo >= 0 */
printk(KERN_ERR PFX
"BIOS error - 0 vid exceeded with pstate %d\n",
j);
return -ENODEV;
}
- if (pst[j].vid < maxvid + rvo) { /* vid + rvo >= maxvid */
+ if (pst[j].vid < maxvid + data->rvo) { /* vid + rvo >= maxvid */
printk(KERN_ERR PFX
"BIOS error - maxvid exceeded with pstate %d\n",
j);
@@ -539,9 +513,9 @@
}
/* Find and validate the PSB/PST table in BIOS. */
-static inline int
-find_psb_table(void)
+static int find_psb_table(struct powernow_k8_data *data)
{
+ struct cpufreq_frequency_table *powernow_table;
struct psb_s *psb;
struct pst_s *pst;
unsigned int i, j;
@@ -570,19 +544,21 @@
return -ENODEV;
}
- vstable = psb->voltagestabilizationtime;
+ data->vstable = psb->voltagestabilizationtime;
+ dprintk(KERN_INFO PFX "voltage stabilization time: %d(*20us)\n", data->vstable);
+
dprintk(KERN_DEBUG PFX "flags2: 0x%x\n", psb->flags2);
- rvo = psb->flags2 & 3;
- irt = ((psb->flags2) >> 2) & 3;
+ data->rvo = psb->flags2 & 3;
+ data->irt = ((psb->flags2) >> 2) & 3;
mvs = ((psb->flags2) >> 4) & 3;
- vidmvs = 1 << mvs;
- batps = ((psb->flags2) >> 6) & 3;
+ data->vidmvs = 1 << mvs;
+ data->batps = ((psb->flags2) >> 6) & 3;
- printk(KERN_INFO PFX "voltage stable in %d usec", vstable * 20);
- if (batps)
+ printk(KERN_INFO PFX "voltage stable in %d usec", data->vstable * 20);
+ if (data->batps)
printk(", only %d lowest states on battery", batps);
- printk(", ramp voltage offset: %d", rvo);
- printk(", isochronous relief time: %d", irt);
+ printk(", ramp voltage offset: %d", data->rvo);
+ printk(", isochronous relief time: %d", data->irt);
printk(", maximum voltage step: %d\n", mvs);
dprintk(KERN_DEBUG PFX "numpst: 0x%x\n", psb->numpst);
@@ -593,42 +569,42 @@
dprintk(KERN_DEBUG PFX "cpuid: 0x%x\n", psb->cpuid);
- plllock = psb->plllocktime;
- printk(KERN_INFO PFX "pll lock time: 0x%x, ", plllock);
+ data->plllock = psb->plllocktime;
+ printk(KERN_INFO PFX "pll lock time: 0x%x, ", data->plllock);
maxvid = psb->maxvid;
printk("maxfid 0x%x (%d MHz), maxvid 0x%x\n",
psb->maxfid, find_freq_from_fid(psb->maxfid), maxvid);
- numps = psb->numpstates;
- if (numps < 2) {
+ data->numps = psb->numpstates;
+ if (data->numps < 2) {
printk(KERN_ERR BFX "no p states to transition\n");
return -ENODEV;
}
if (batps == 0) {
- batps = numps;
- } else if (batps > numps) {
+ batps = data->numps;
+ } else if (batps > data->numps) {
printk(KERN_ERR BFX "batterypstates > numpstates\n");
- batps = numps;
+ batps = data->numps;
} else {
printk(KERN_ERR PFX
"Restricting operation to %d p-states\n", batps);
printk(KERN_ERR PFX
"Check for an updated driver to access all "
- "%d p-states\n", numps);
+ "%d p-states\n", data->numps);
}
- if (numps <= 1) {
+ if (data->numps <= 1) {
printk(KERN_ERR PFX "only 1 p-state to transition\n");
return -ENODEV;
}
pst = (struct pst_s *) (psb + 1);
- if (check_pst_table(pst, maxvid))
+ if (check_pst_table(data, pst, maxvid))
return -EINVAL;
- powernow_table = kmalloc((sizeof(struct cpufreq_frequency_table) * (numps + 1)), GFP_KERNEL);
+ powernow_table = kmalloc((sizeof(struct cpufreq_frequency_table) * (data->numps + 1)), GFP_KERNEL);
if (!powernow_table) {
printk(KERN_ERR PFX "powernow_table memory alloc failure\n");
return -ENOMEM;
@@ -642,7 +618,7 @@
/* If you want to override your frequency tables, this
is right place. */
- for (j = 0; j < numps; j++) {
+ for (j = 0; j < data->numps; j++) {
powernow_table[j].frequency = find_freq_from_fid(powernow_table[j].index & 0xff)*1000;
printk(KERN_INFO PFX " %d : fid 0x%x (%d MHz), vid 0x%x\n", j,
powernow_table[j].index & 0xff,
@@ -650,19 +626,19 @@
powernow_table[j].index >> 8);
}
- powernow_table[numps].frequency = CPUFREQ_TABLE_END;
- powernow_table[numps].index = 0;
+ powernow_table[data->numps].frequency = CPUFREQ_TABLE_END;
+ powernow_table[data->numps].index = 0;
- if (query_current_values_with_pending_wait()) {
+ if (query_current_values_with_pending_wait(data)) {
kfree(powernow_table);
return -EIO;
}
printk(KERN_INFO PFX "currfid 0x%x (%d MHz), currvid 0x%x\n",
- currfid, find_freq_from_fid(currfid), currvid);
+ data->currfid, find_freq_from_fid(data->currfid), data->currvid);
- for (j = 0; j < numps; j++)
- if ((pst[j].fid==currfid) && (pst[j].vid==currvid))
+ for (j = 0; j < data->numps; j++)
+ if ((pst[j].fid==data->currfid) && (pst[j].vid==data->currvid))
return 0;
printk(KERN_ERR BFX "currfid/vid do not match PST, ignoring\n");
@@ -674,8 +650,7 @@
}
/* Take a frequency, and issue the fid/vid transition command */
-static inline int
-transition_frequency(unsigned int index)
+static int transition_frequency(struct powernow_k8_data *data, unsigned int index)
{
u32 fid;
u32 vid;
@@ -687,51 +662,51 @@
* the upper 8 bits.
*/
- fid = powernow_table[index].index & 0xFF;
- vid = (powernow_table[index].index & 0xFF00) >> 8;
+ fid = data->powernow_table[index].index & 0xFF;
+ vid = (data->powernow_table[index].index & 0xFF00) >> 8;
dprintk(KERN_DEBUG PFX "table matched fid 0x%x, giving vid 0x%x\n",
fid, vid);
- if (query_current_values_with_pending_wait())
+ if (query_current_values_with_pending_wait(data))
return 1;
- if ((currvid == vid) && (currfid == fid)) {
+ if ((data->currvid == vid) && (data->currfid == fid)) {
dprintk(KERN_DEBUG PFX
"target matches current values (fid 0x%x, vid 0x%x)\n",
fid, vid);
return 0;
}
- if ((fid < HI_FID_TABLE_BOTTOM) && (currfid < HI_FID_TABLE_BOTTOM)) {
+ if ((fid < HI_FID_TABLE_BOTTOM) && (data->currfid < HI_FID_TABLE_BOTTOM)) {
printk(KERN_ERR PFX
"ignoring illegal change in lo freq table-%x to %x\n",
- currfid, fid);
+ data->currfid, fid);
return 1;
}
dprintk(KERN_DEBUG PFX "changing to fid 0x%x, vid 0x%x\n", fid, vid);
- freqs.cpu = 0; /* only true because SMP not supported */
+ freqs.cpu = data->cpu;
- freqs.old = find_freq_from_fid(currfid);
+ freqs.old = find_freq_from_fid(data->currfid);
freqs.new = find_freq_from_fid(fid);
cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
- res = transition_fid_vid(fid, vid);
+ res = transition_fid_vid(data, fid, vid);
- freqs.new = find_freq_from_fid(currfid);
+ freqs.new = find_freq_from_fid(data->currfid);
cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
return res;
}
/* Driver entry point to switch to the target frequency */
-static int
-powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsigned relation)
+static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsigned relation)
{
- u32 checkfid = currfid;
- u32 checkvid = currvid;
+ struct powernow_k8_data *data = powernow_data[pol->cpu];
+ u32 checkfid = data->currfid;
+ u32 checkvid = data->currvid;
unsigned int newstate;
if (pending_bit_stuck()) {
@@ -742,90 +717,122 @@
dprintk(KERN_DEBUG PFX "targ: %d kHz, min %d, max %d, relation %d\n",
targfreq, pol->min, pol->max, relation);
- if (query_current_values_with_pending_wait())
+ if (query_current_values_with_pending_wait(data))
return -EIO;
dprintk(KERN_DEBUG PFX "targ: curr fid 0x%x, vid 0x%x\n",
- currfid, currvid);
+ data->currfid, data->currvid);
- if ((checkvid != currvid) || (checkfid != currfid)) {
+ if ((checkvid != data->currvid) || (checkfid != data->currfid)) {
printk(KERN_ERR PFX
"error - out of sync, fid 0x%x 0x%x, vid 0x%x 0x%x\n",
- checkfid, currfid, checkvid, currvid);
+ checkfid, data->currfid, checkvid, data->currvid);
}
- if (cpufreq_frequency_table_target(pol, powernow_table, targfreq, relation, &newstate))
+ if (cpufreq_frequency_table_target(pol, data->powernow_table, targfreq, relation, &newstate))
return -EINVAL;
- if (transition_frequency(newstate))
- {
+ if (transition_frequency(data, newstate)) {
printk(KERN_ERR PFX "transition frequency failed\n");
return 1;
}
- pol->cur = 1000 * find_freq_from_fid(currfid);
+ pol->cur = 1000 * find_freq_from_fid(data->currfid);
return 0;
}
/* Driver entry point to verify the policy and range of frequencies */
-static int
-powernowk8_verify(struct cpufreq_policy *pol)
+static int powernowk8_verify(struct cpufreq_policy *pol)
{
+ struct powernow_k8_data *data = powernow_data[pol->cpu];
+
if (pending_bit_stuck()) {
printk(KERN_ERR PFX "failing verify, change pending bit set\n");
return -EIO;
}
- return cpufreq_frequency_table_verify(pol, powernow_table);
+ return cpufreq_frequency_table_verify(pol, data->powernow_table);
}
/* per CPU init entry point to the driver */
-static int __init
-powernowk8_cpu_init(struct cpufreq_policy *pol)
+static int __init powernowk8_cpu_init(struct cpufreq_policy *pol)
{
+ struct powernow_k8_data *data;
+ int rc;
+
+ data = kmalloc(sizeof(struct powernow_k8_data), GFP_KERNEL);
+ if (!data) {
+ printk(KERN_ERR PFX "unable to alloc powernow_k8_data");
+ return -ENOMEM;
+ }
+ memset(data,0,sizeof(struct powernow_k8_data));
+
+ data->cpu = pol->cpu;
+
if (pol->cpu != 0) {
printk(KERN_ERR PFX "init not cpu 0\n");
+ kfree(data);
return -ENODEV;
}
pol->governor = CPUFREQ_DEFAULT_GOVERNOR;
+ rc = find_psb_table(data);
+ if (rc) {
+ kfree(data);
+ return -ENODEV;
+ }
+
+ if (pending_bit_stuck()) {
+ printk(KERN_ERR PFX "failing init, change pending bit set\n");
+ goto err_out;
+ }
+
/* Take a crude guess here.
* That guess was in microseconds, so multply with 1000 */
- pol->cpuinfo.transition_latency = (((rvo + 8) * vstable * VST_UNITS_20US)
- + (3 * (1 << irt) * 10)) * 1000;
+ pol->cpuinfo.transition_latency = (((data->rvo + 8) * data->vstable * VST_UNITS_20US)
+ + (3 * (1 << data->irt) * 10)) * 1000;
- if (query_current_values_with_pending_wait())
+ if (query_current_values_with_pending_wait(data))
return -EIO;
- pol->cur = 1000 * find_freq_from_fid(currfid);
+ pol->cur = 1000 * find_freq_from_fid(data->currfid);
dprintk(KERN_DEBUG PFX "policy current frequency %d kHz\n", pol->cur);
/* min/max the cpu is capable of */
- if (cpufreq_frequency_table_cpuinfo(pol, powernow_table)) {
+ if (cpufreq_frequency_table_cpuinfo(pol, data->powernow_table)) {
printk(KERN_ERR PFX "invalid powernow_table\n");
- kfree(powernow_table);
+ kfree(data->powernow_table);
+ kfree(data);
return -EINVAL;
}
- cpufreq_frequency_table_get_attr(powernow_table, pol->cpu);
+ cpufreq_frequency_table_get_attr(data->powernow_table, pol->cpu);
printk(KERN_INFO PFX "cpu_init done, current fid 0x%x, vid 0x%x\n",
- currfid, currvid);
+ data->currfid, data->currvid);
+
+ powernow_data[pol->cpu] = data;
return 0;
+
+err_out:
+ kfree(data);
+ return -ENODEV;
}
static int __exit powernowk8_cpu_exit (struct cpufreq_policy *pol)
{
- if (pol->cpu != 0)
+ struct powernow_k8_data *data = powernow_data[pol->cpu];
+
+ if (!data)
return -EINVAL;
cpufreq_frequency_table_put_attr(pol->cpu);
- if (powernow_table)
- kfree(powernow_table);
+ kfree(data->powernow_table);
+ kfree(data);
return 0;
}
@@ -845,33 +852,31 @@
.attr = powernow_k8_attr,
};
-
/* driver entry point for init */
-static int __init
-powernowk8_init(void)
+static int __init powernowk8_init(void)
{
- int rc;
+ unsigned int i, supported_cpus = 0;
- if (check_supported_cpu() == 0)
- return -ENODEV;
-
- rc = find_psb_table();
- if (rc)
- return rc;
+ for (i=0; i<NR_CPUS; i++) {
+ if (!cpu_online(i))
+ continue;
+ if (check_supported_cpu(i))
+ supported_cpus++;
+ }
- if (pending_bit_stuck()) {
- printk(KERN_ERR PFX "powernowk8_init fail, change pending bit set\n");
- return -EIO;
+ if (supported_cpus == num_online_cpus()) {
+ printk(KERN_INFO PFX "Found %d AMD Athlon 64 / Opteron processors (" VERSION ")\n",
+ supported_cpus);
+ return cpufreq_register_driver(&cpufreq_amd64_driver);
}
- return cpufreq_register_driver(&cpufreq_amd64_driver);
+ return -ENODEV;
}
/* driver entry point for term */
-static void __exit
-powernowk8_exit(void)
+static void __exit powernowk8_exit(void)
{
- dprintk(KERN_INFO PFX "powernowk8_exit\n");
+ dprintk(KERN_INFO PFX "exit\n");
cpufreq_unregister_driver(&cpufreq_amd64_driver);
}
diff -Nru a/arch/i386/kernel/cpu/cpufreq/powernow-k8.h b/arch/i386/kernel/cpu/cpufreq/powernow-k8.h
--- a/arch/i386/kernel/cpu/cpufreq/powernow-k8.h Sun Apr 4 18:51:43 2004
+++ b/arch/i386/kernel/cpu/cpufreq/powernow-k8.h Sun Apr 4 18:51:43 2004
@@ -5,6 +5,32 @@
* http://www.gnu.org/licenses/gpl.html
*/
+struct powernow_k8_data {
+ unsigned int cpu;
+
+ u32 numps; /* number of p-states */
+ u32 batps; /* number of p-states supported on battery */
+
+ /* these values are constant when the PSB is used to determine
+ * vid/fid pairings, but are modified during the ->target() call
+ * when ACPI is used */
+ u32 rvo; /* ramp voltage offset */
+ u32 irt; /* isochronous relief time */
+ u32 vidmvs; /* usable value calculated from mvs */
+ u32 vstable; /* voltage stabilization time, units 20 us */
+ u32 plllock; /* pll lock time, units 1 us */
+
+ /* keep track of the current fid / vid */
+ u32 currvid;
+ u32 currfid;
+
+ /* the powernow_table includes all frequency and vid/fid pairings:
+ * fid are the lower 8 bits of the index, vid are the upper 8 bits.
+ * frequency is in kHz */
+ struct cpufreq_frequency_table *powernow_table;
+};
+
+
/* processor's cpuid instruction support */
#define CPUID_PROCESSOR_SIGNATURE 1 /* function 1 */
#define CPUID_F1_FAM 0x00000f00 /* family mask */
@@ -117,6 +143,7 @@
#define dprintk(msg...) do { } while(0)
#endif
-static inline int core_voltage_pre_transition(u32 reqvid);
-static inline int core_voltage_post_transition(u32 reqvid);
-static inline int core_frequency_transition(u32 reqfid);
+static inline int core_voltage_pre_transition(struct powernow_k8_data *data, u32 reqvid);
+static inline int core_voltage_post_transition(struct powernow_k8_data *data, u32 reqvid);
+static inline int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid);
+
diff -Nru a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
--- a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c Sun Apr 4 18:51:43 2004
+++ b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c Sun Apr 4 18:51:43 2004
@@ -21,6 +21,7 @@
#include <linux/module.h>
#include <linux/init.h>
#include <linux/cpufreq.h>
+#include <linux/config.h>
#include <asm/msr.h>
#include <asm/processor.h>
@@ -46,7 +47,9 @@
};
/* Operating points for current CPU */
-static const struct cpu_model *centrino_model;
+static struct cpu_model *centrino_model;
+
+#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_TABLE
/* Computes the correct form for IA32_PERF_CTL MSR for a particular
frequency/voltage operating point; frequency in MHz, volts in mV.
@@ -172,7 +175,7 @@
/* CPU models, their operating frequency range, and freq/voltage
operating points */
-static const struct cpu_model models[] =
+static struct cpu_model models[] =
{
_CPU( 900, " 900"),
CPU(1000),
@@ -187,6 +190,48 @@
};
#undef CPU
+static int centrino_cpu_init_table(struct cpufreq_policy *policy)
+{
+ struct cpuinfo_x86 *cpu = &cpu_data[policy->cpu];
+ struct cpu_model *model;
+
+ if (!cpu_has(cpu, X86_FEATURE_EST))
+ return -ENODEV;
+
+ /* Only Intel Pentium M stepping 5 for now - add new CPUs as
+ they appear after making sure they use PERF_CTL in the same
+ way. */
+ if (cpu->x86_vendor != X86_VENDOR_INTEL ||
+ cpu->x86 != 6 ||
+ cpu->x86_model != 9 ||
+ cpu->x86_mask != 5) {
+ printk(KERN_INFO PFX "found unsupported CPU with Enhanced SpeedStep: "
+ "send /proc/cpuinfo to " MAINTAINER "\n");
+ return -ENODEV;
+ }
+
+ for(model = models; model->model_name != NULL; model++)
+ if (strcmp(cpu->x86_model_id, model->model_name) == 0)
+ break;
+ if (model->model_name == NULL) {
+ printk(KERN_INFO PFX "no support for CPU model \"%s\": "
+ "send /proc/cpuinfo to " MAINTAINER "\n",
+ cpu->x86_model_id);
+ return -ENOENT;
+ }
+
+ centrino_model = model;
+
+ printk(KERN_INFO PFX "found \"%s\": max frequency: %dkHz\n",
+ model->model_name, model->max_freq);
+
+ return 0;
+}
+
+#else
+static inline int centrino_cpu_init_table(struct cpufreq_policy *policy) { return -ENODEV; }
+#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_TABLE */
+
/* Extract clock in kHz from PERF_CTL value */
static unsigned extract_clock(unsigned msr)
{
@@ -203,13 +248,148 @@
return extract_clock(l);
}
+
+#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_ACPI
+
+static struct acpi_processor_performance p;
+
+#include <linux/acpi.h>
+#include <acpi/processor.h>
+
+#define ACPI_PDC_CAPABILITY_ENHANCED_SPEEDSTEP 0x1
+
+/*
+ * centrino_cpu_init_acpi - register with ACPI P-States library
+ *
+ * Register with the ACPI P-States library (part of drivers/acpi/processor.c)
+ * in order to determine correct frequency and voltage pairings by reading
+ * the _PSS of the ACPI DSDT or SSDT tables.
+ */
+static int centrino_cpu_init_acpi(struct cpufreq_policy *policy)
+{
+ union acpi_object arg0 = {ACPI_TYPE_BUFFER};
+ u32 arg0_buf[3];
+ struct acpi_object_list arg_list = {1, &arg0};
+ unsigned long cur_freq;
+ int result = 0, i;
+
+ /* _PDC settings */
+ arg0.buffer.length = 12;
+ arg0.buffer.pointer = (u8 *) arg0_buf;
+ arg0_buf[0] = ACPI_PDC_REVISION_ID;
+ arg0_buf[1] = 1;
+ arg0_buf[2] = ACPI_PDC_CAPABILITY_ENHANCED_SPEEDSTEP;
+
+ p.pdc = &arg_list;
+
+ /* register with ACPI core */
+ if (acpi_processor_register_performance(&p, 0))
+ return -EIO;
+
+ /* verify the acpi_data */
+ if (p.state_count <= 1) {
+ printk(KERN_DEBUG "No P-States\n");
+ result = -ENODEV;
+ goto err_unreg;
+ }
+
+ if ((p.control_register.space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) ||
+ (p.status_register.space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) {
+ printk(KERN_DEBUG "Invalid control/status registers\n");
+ result = -EIO;
+ goto err_unreg;
+ }
+
+ for (i=0; i<p.state_count; i++) {
+ if (p.states[i].control != p.states[i].status) {
+ printk(KERN_DEBUG "Different control and status values\n");
+ result = -EINVAL;
+ goto err_unreg;
+ }
+
+ if (!p.states[i].core_frequency) {
+ printk(KERN_DEBUG "Zero core frequency\n");
+ result = -EINVAL;
+ goto err_unreg;
+ }
+
+ if (extract_clock(p.states[i].control) !=
+ (p.states[i].core_frequency * 1000)) {
+ printk(KERN_DEBUG "Invalid encoded frequency\n");
+ result = -EINVAL;
+ goto err_unreg;
+ }
+ }
+
+ centrino_model = kmalloc(sizeof(struct cpu_model), GFP_KERNEL);
+ if (!centrino_model) {
+ result = -ENOMEM;
+ goto err_unreg;
+ }
+ memset(centrino_model, 0, sizeof(struct cpu_model));
+
+ centrino_model->model_name=NULL;
+ centrino_model->max_freq = p.states[0].core_frequency * 1000;
+ centrino_model->op_points = kmalloc(sizeof(struct cpufreq_frequency_table) *
+ (p.state_count + 1), GFP_KERNEL);
+ if (!centrino_model->op_points) {
+ result = -ENOMEM;
+ goto err_kfree;
+ }
+
+ cur_freq = get_cur_freq();
+
+ for (i=0; i<p.state_count; i++) {
+ centrino_model->op_points[i].index = p.states[i].control;
+ centrino_model->op_points[i].frequency = p.states[i].core_frequency * 1000;
+ if (cur_freq == centrino_model->op_points[i].frequency)
+ p.state = i;
+ }
+ centrino_model->op_points[p.state_count].frequency = CPUFREQ_TABLE_END;
+
+ return 0;
+
+ err_kfree:
+ kfree(centrino_model);
+ err_unreg:
+ acpi_processor_unregister_performance(&p, 0);
+ return (result);
+}
+#else
+static inline int centrino_cpu_init_acpi(struct cpufreq_policy *policy) { return -ENODEV; }
+#endif
+
static int centrino_cpu_init(struct cpufreq_policy *policy)
{
unsigned freq;
+ unsigned l, h;
+ int ret;
- if (policy->cpu != 0 || centrino_model == NULL)
+ if (policy->cpu != 0)
return -ENODEV;
+ if (centrino_cpu_init_acpi(policy)) {
+ if (centrino_cpu_init_table(policy)) {
+ return -ENODEV;
+ }
+ }
+
+ /* Check to see if Enhanced SpeedStep is enabled, and try to
+ enable it if not. */
+ rdmsr(MSR_IA32_MISC_ENABLE, l, h);
+
+ if (!(l & (1<<16))) {
+ l |= (1<<16);
+ wrmsr(MSR_IA32_MISC_ENABLE, l, h);
+
+ /* check to see if it stuck */
+ rdmsr(MSR_IA32_MISC_ENABLE, l, h);
+ if (!(l & (1<<16))) {
+ printk(KERN_INFO PFX "couldn't enable Enhanced SpeedStep\n");
+ return -ENODEV;
+ }
+ }
+
freq = get_cur_freq();
policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
@@ -219,7 +399,33 @@
dprintk(KERN_INFO PFX "centrino_cpu_init: policy=%d cur=%dkHz\n",
policy->policy, policy->cur);
- return cpufreq_frequency_table_cpuinfo(policy, centrino_model->op_points);
+ ret = cpufreq_frequency_table_cpuinfo(policy, centrino_model->op_points);
+ if (ret)
+ return (ret);
+
+ cpufreq_frequency_table_get_attr(centrino_model->op_points, policy->cpu);
+
+ return 0;
+}
+
+static int centrino_cpu_exit(struct cpufreq_policy *policy)
+{
+ if (!centrino_model)
+ return -ENODEV;
+
+ cpufreq_frequency_table_put_attr(policy->cpu);
+
+#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_ACPI
+ if (!centrino_model->model_name) {
+ acpi_processor_unregister_performance(&p, 0);
+ kfree(centrino_model->op_points);
+ kfree(centrino_model);
+ }
+#endif
+
+ centrino_model = NULL;
+
+ return 0;
}
/**
@@ -295,12 +501,19 @@
return 0;
}
+static struct freq_attr* centrino_attr[] = {
+ &cpufreq_freq_attr_scaling_available_freqs,
+ NULL,
+};
+
static struct cpufreq_driver centrino_driver = {
.name = "centrino", /* should be speedstep-centrino,
but there's a 16 char limit */
.init = centrino_cpu_init,
+ .exit = centrino_cpu_exit,
.verify = centrino_verify,
.target = centrino_target,
+ .attr = centrino_attr,
.owner = THIS_MODULE,
};
@@ -322,55 +535,10 @@
static int __init centrino_init(void)
{
struct cpuinfo_x86 *cpu = cpu_data;
- const struct cpu_model *model;
- unsigned l, h;
if (!cpu_has(cpu, X86_FEATURE_EST))
return -ENODEV;
- /* Only Intel Pentium M stepping 5 for now - add new CPUs as
- they appear after making sure they use PERF_CTL in the same
- way. */
- if (cpu->x86_vendor != X86_VENDOR_INTEL ||
- cpu->x86 != 6 ||
- cpu->x86_model != 9 ||
- cpu->x86_mask != 5) {
- printk(KERN_INFO PFX "found unsupported CPU with Enhanced SpeedStep: "
- "send /proc/cpuinfo to " MAINTAINER "\n");
- return -ENODEV;
- }
-
- /* Check to see if Enhanced SpeedStep is enabled, and try to
- enable it if not. */
- rdmsr(MSR_IA32_MISC_ENABLE, l, h);
-
- if (!(l & (1<<16))) {
- l |= (1<<16);
- wrmsr(MSR_IA32_MISC_ENABLE, l, h);
-
- /* check to see if it stuck */
- rdmsr(MSR_IA32_MISC_ENABLE, l, h);
- if (!(l & (1<<16))) {
- printk(KERN_INFO PFX "couldn't enable Enhanced SpeedStep\n");
- return -ENODEV;
- }
- }
-
- for(model = models; model->model_name != NULL; model++)
- if (strcmp(cpu->x86_model_id, model->model_name) == 0)
- break;
- if (model->model_name == NULL) {
- printk(KERN_INFO PFX "no support for CPU model \"%s\": "
- "send /proc/cpuinfo to " MAINTAINER "\n",
- cpu->x86_model_id);
- return -ENOENT;
- }
-
- centrino_model = model;
-
- printk(KERN_INFO PFX "found \"%s\": max frequency: %dkHz\n",
- model->model_name, model->max_freq);
-
return cpufreq_register_driver(¢rino_driver);
}
@@ -383,5 +551,5 @@
MODULE_DESCRIPTION ("Enhanced SpeedStep driver for Intel Pentium M processors.");
MODULE_LICENSE ("GPL");
-module_init(centrino_init);
+late_initcall(centrino_init);
module_exit(centrino_exit);
diff -Nru a/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c b/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c
--- a/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c Sun Apr 4 18:51:43 2004
+++ b/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c Sun Apr 4 18:51:43 2004
@@ -10,6 +10,7 @@
#include <linux/kernel.h>
#include <linux/module.h>
+#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/cpufreq.h>
#include <linux/pci.h>
@@ -30,6 +31,12 @@
#define dprintk(msg...) do { } while(0)
#endif
+#ifdef CONFIG_X86_SPEEDSTEP_RELAXED_CAP_CHECK
+static int relaxed_check = 0;
+#else
+#define relaxed_check 0
+#endif
+
/*********************************************************************
* GET PROCESSOR CORE SPEED IN KHZ *
*********************************************************************/
@@ -120,7 +127,7 @@
msr_tmp = (msr_lo >> 22) & 0x1f;
dprintk(KERN_DEBUG "speedstep-lib: bits 22-26 are 0x%x\n", msr_tmp);
- return (msr_tmp * 100 * 10000);
+ return (msr_tmp * 100 * 1000);
}
@@ -210,7 +217,7 @@
ebx = cpuid_ebx(0x00000001);
ebx &= 0x000000FF;
- dprintk(KERN_INFO "ebx value is %x, x86_mask is %x\n", ebx, c->86_mask);
+ dprintk(KERN_INFO "ebx value is %x, x86_mask is %x\n", ebx, c->x86_mask);
switch (c->x86_mask) {
case 4:
@@ -265,6 +272,7 @@
ebx = cpuid_ebx(0x00000001);
ebx &= 0x000000FF;
+
if (ebx != 0x06)
return 0;
@@ -292,7 +300,7 @@
*/
rdmsr(MSR_IA32_PLATFORM_ID, msr_lo, msr_hi);
dprintk(KERN_DEBUG "cpufreq: Coppermine: MSR_IA32_PLATFORM ID is 0x%x, 0x%x\n", msr_lo, msr_hi);
- if ((msr_hi & (1<<18)) && (msr_hi & (3<<24))) {
+ if ((msr_hi & (1<<18)) && (relaxed_check ? 1 : (msr_hi & (3<<24)))) {
if (c->x86_mask == 0x01)
return SPEEDSTEP_PROCESSOR_PIII_C_EARLY;
else
@@ -361,6 +369,11 @@
return (ret);
}
EXPORT_SYMBOL_GPL(speedstep_get_freqs);
+
+#ifdef CONFIG_X86_SPEEDSTEP_RELAXED_CAP_CHECK
+module_param(relaxed_check, int, 0444);
+MODULE_PARM_DESC(relaxed_check, "Don't do all checks for speedstep capability.");
+#endif
MODULE_AUTHOR ("Dominik Brodowski <linux@brodo.de>");
MODULE_DESCRIPTION ("Library for Intel SpeedStep 1 or 2 cpufreq drivers.");
diff -Nru a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
--- a/drivers/cpufreq/cpufreq.c Sun Apr 4 18:51:43 2004
+++ b/drivers/cpufreq/cpufreq.c Sun Apr 4 18:51:43 2004
@@ -963,6 +963,7 @@
int cpufreq_register_driver(struct cpufreq_driver *driver_data)
{
unsigned long flags;
+ int ret;
if (!driver_data || !driver_data->verify || !driver_data->init ||
((!driver_data->setpolicy) && (!driver_data->target)))
@@ -976,7 +977,28 @@
cpufreq_driver = driver_data;
spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
- return sysdev_driver_register(&cpu_sysdev_class,&cpufreq_sysdev_driver);
+ ret = sysdev_driver_register(&cpu_sysdev_class,&cpufreq_sysdev_driver);
+
+ if ((!ret) && !(cpufreq_driver->flags & CPUFREQ_STICKY)) {
+ int i;
+ ret = -ENODEV;
+
+ /* check for at least one working CPU */
+ for (i=0; i<NR_CPUS; i++)
+ if (cpufreq_cpu_data[i])
+ ret = 0;
+
+ /* if all ->init() calls failed, unregister */
+ if (ret) {
+ sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
+
+ spin_lock_irqsave(&cpufreq_driver_lock, flags);
+ cpufreq_driver = NULL;
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+ }
+ }
+
+ return (ret);
}
EXPORT_SYMBOL_GPL(cpufreq_register_driver);
diff -Nru a/include/linux/cpufreq.h b/include/linux/cpufreq.h
--- a/include/linux/cpufreq.h Sun Apr 4 18:51:43 2004
+++ b/include/linux/cpufreq.h Sun Apr 4 18:51:43 2004
@@ -175,6 +175,7 @@
struct cpufreq_driver {
struct module *owner;
char name[CPUFREQ_NAME_LEN];
+ u8 flags;
/* needed by all drivers */
int (*init) (struct cpufreq_policy *policy);
@@ -191,6 +192,11 @@
int (*resume) (struct cpufreq_policy *policy);
struct freq_attr **attr;
};
+
+/* flags */
+
+#define CPUFREQ_STICKY 0x01 /* the driver isn't removed even if
+ all ->init() calls failed */
int cpufreq_register_driver(struct cpufreq_driver *driver_data);
int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);