diff -Nurp linux-2.6.24.orig/arch/x86/kernel/cpu/cpufreq/Kconfig linux-2.6.24.speedstep-centrino/arch/x86/kernel/cpu/cpufreq/Kconfig --- linux-2.6.24.orig/arch/x86/kernel/cpu/cpufreq/Kconfig 2008-01-25 01:58:37.000000000 +0300 +++ linux-2.6.24.speedstep-centrino/arch/x86/kernel/cpu/cpufreq/Kconfig 2008-04-07 00:23:31.000000000 +0400 @@ -113,7 +113,7 @@ config X86_POWERNOW_K8_ACPI config X86_GX_SUSPMOD tristate "Cyrix MediaGX/NatSemi Geode Suspend Modulation" - depends on X86_32 && PCI + depends on X86_32 help This add the CPUFreq driver for NatSemi Geode processors which support suspend modulation. @@ -123,35 +123,121 @@ config X86_GX_SUSPMOD If in doubt, say N. config X86_SPEEDSTEP_CENTRINO - tristate "Intel Enhanced SpeedStep (deprecated)" + tristate "Intel Enhanced SpeedStep" select CPU_FREQ_TABLE - select X86_SPEEDSTEP_CENTRINO_TABLE if X86_32 - depends on X86_32 || (X86_64 && ACPI_PROCESSOR) + select X86_SPEEDSTEP_CENTRINO_ACPI if (!X86_SPEEDSTEP_CENTRINO_BUILTIN || (!X86_SPEEDSTEP_CENTRINO_BUILTIN_BANIAS && !X86_SPEEDSTEP_CENTRINO_BUILTIN_DOTHAN && !X86_SPEEDSTEP_CENTRINO_BUILTIN_SONOMA )) help - This is deprecated and this functionality is now merged into - acpi_cpufreq (X86_ACPI_CPUFREQ). Use that driver instead of - speedstep_centrino. This adds the CPUFreq driver for Enhanced SpeedStep enabled - mobile CPUs. This means Intel Pentium M (Centrino) CPUs - or 64bit enabled Intel Xeons. + mobile CPUs. This means Intel Pentium M (Centrino) CPUs. However, + you also need to say Y below to at least one of the following options: + - "Use ACPI tables to decode..." [which might imply enabling ACPI] + - "Built-in Tables for ... CPUs" - To compile this driver as a module, choose M here: the - module will be called speedstep-centrino. + You can also say yes to all of these options. In this configuration the + driver will first try to use ACPI. Then if it fails it will try to use + a built-in table if there is one matching the CPU. For details, take a look at . If in doubt, say N. -config X86_SPEEDSTEP_CENTRINO_TABLE - bool "Built-in tables for Banias CPUs" - depends on X86_32 && X86_SPEEDSTEP_CENTRINO +config X86_SPEEDSTEP_CENTRINO_SYSFS + bool "Userspace control of CPU frequency/voltage table" + depends on X86_SPEEDSTEP_CENTRINO + depends on SYSFS + depends on (X86_SPEEDSTEP_CENTRINO_BUILTIN && (X86_SPEEDSTEP_CENTRINO_BUILTIN_BANIAS || X86_SPEEDSTEP_CENTRINO_BUILTIN_DOTHAN || X86_SPEEDSTEP_CENTRINO_BUILTIN_SONOMA )) || X86_SPEEDSTEP_CENTRINO_ACPI || X86_SPEEDSTEP_CENTRINO_DEFAULT default y help - Use built-in tables for Banias CPUs if ACPI encoding - is not available. + Add support for user space control of the CPU frequency/voltage + operating points table through a sysfs interface. + + If you say Y here files will be created in + /sys/devices/system/cpu/cpu*/cpufreq/op_points_table + allowing reading and writing of the current table values as well as + adding or removing operating points. + + For details, take a look at . If in doubt, say N. +config X86_SPEEDSTEP_CENTRINO_ACPI + bool "Use ACPI tables to decode valid frequency/voltage pairs (deprecated)" + depends on X86_SPEEDSTEP_CENTRINO && ACPI_PROCESSOR + depends on !(X86_SPEEDSTEP_CENTRINO = y && ACPI_PROCESSOR = m) + default y + help + This is deprecated and this functionality is now merged into + acpi_cpufreq (X86_ACPI_CPUFREQ). Use that driver instead of + speedstep_centrino. + Use primarily the information provided in the BIOS ACPI tables + to determine valid CPU frequency and voltage pairings. + It is required for the driver to work on CPUs with no built-in + table available + + (this option adds around 3 kB to the kernel size) + + If in doubt, say Y. + +config X86_SPEEDSTEP_CENTRINO_BUILTIN + bool "Built-in tables" + depends on X86_SPEEDSTEP_CENTRINO + default y + help + Use "hard coded" built-in tables if ACPI decoding + is not available. + + If you say Y here you must select at least one of the CPU below. + + If you are not sure of your exact CPU model you can select several CPU + models or all of them. The driver will only use the table that match + the exact CPU name and family/model/stepping numbers. + Selecting all the built-in tables will only add a small size overhead + to the kernel and an insignificant extra time to intialize the driver. + + If both ACPI and built-in tables support are enabled then built-in + tables will be used only if ACPI table decoding fails. + + If you want to force usage of built-in tables over ACPI you need to say + Y here and N to X86_SPEEDSTEP_CENTRINO_ACPI. + + (this option adds from 2.5 to 4.5 kB to the kernel size, depending on + the selected built-in tables) + + If in doubt, say Y. + +config X86_SPEEDSTEP_CENTRINO_BUILTIN_BANIAS + bool "Built-in tables for Banias CPUs" + depends on X86_SPEEDSTEP_CENTRINO_BUILTIN + default y + help + Use built-in tables for Banias CPUs if ACPI encoding is not available. + Banias CPUs are the first generation of Pentium-M, with a 1 MB L2 cache + and 400 MHz FSB manufactured on 0.13 micron process. + + If in doubt, say Y. + +config X86_SPEEDSTEP_CENTRINO_BUILTIN_DOTHAN + bool "Built-in tables for Dothan CPUs" + depends on X86_SPEEDSTEP_CENTRINO_BUILTIN + default y + help + Use built-in tables for Dothan CPUs if ACPI encoding is not available. + Dothan CPUs are the second generation of Pentium-M, with a 2 MB L2 + cache and 400 MHz FSB manufactured on 90 nm process. + + If in doubt, say Y. + +config X86_SPEEDSTEP_CENTRINO_BUILTIN_SONOMA + bool "Built-in tables for Sonoma CPUs" + depends on X86_SPEEDSTEP_CENTRINO_BUILTIN + default y + help + Use built-in tables for Sonoma CPUs if ACPI encoding is not available. + Sonoma CPUs are the third generation of Pentium-M, with a 2 MB L2 cache + and 533 MHz FSB manufactured on 90 nm process. + + If in doubt, say Y. + config X86_SPEEDSTEP_ICH tristate "Intel Speedstep on ICH-M chipsets (ioport interface)" select CPU_FREQ_TABLE diff -Nurp linux-2.6.24.orig/arch/x86/kernel/cpu/cpufreq/Makefile linux-2.6.24.speedstep-centrino/arch/x86/kernel/cpu/cpufreq/Makefile --- linux-2.6.24.orig/arch/x86/kernel/cpu/cpufreq/Makefile 2008-01-25 01:58:37.000000000 +0300 +++ linux-2.6.24.speedstep-centrino/arch/x86/kernel/cpu/cpufreq/Makefile 2008-04-07 00:27:17.000000000 +0400 @@ -1,16 +1,16 @@ -obj-$(CONFIG_X86_POWERNOW_K6) += powernow-k6.o -obj-$(CONFIG_X86_POWERNOW_K7) += powernow-k7.o -obj-$(CONFIG_X86_POWERNOW_K8) += powernow-k8.o -obj-$(CONFIG_X86_LONGHAUL) += longhaul.o -obj-$(CONFIG_X86_E_POWERSAVER) += e_powersaver.o -obj-$(CONFIG_ELAN_CPUFREQ) += elanfreq.o -obj-$(CONFIG_SC520_CPUFREQ) += sc520_freq.o -obj-$(CONFIG_X86_LONGRUN) += longrun.o -obj-$(CONFIG_X86_GX_SUSPMOD) += gx-suspmod.o -obj-$(CONFIG_X86_SPEEDSTEP_ICH) += speedstep-ich.o -obj-$(CONFIG_X86_SPEEDSTEP_LIB) += speedstep-lib.o -obj-$(CONFIG_X86_SPEEDSTEP_SMI) += speedstep-smi.o -obj-$(CONFIG_X86_ACPI_CPUFREQ) += acpi-cpufreq.o -obj-$(CONFIG_X86_SPEEDSTEP_CENTRINO) += speedstep-centrino.o -obj-$(CONFIG_X86_P4_CLOCKMOD) += p4-clockmod.o -obj-$(CONFIG_X86_CPUFREQ_NFORCE2) += cpufreq-nforce2.o + obj-$(CONFIG_X86_POWERNOW_K6) += powernow-k6.o + obj-$(CONFIG_X86_POWERNOW_K7) += powernow-k7.o + obj-$(CONFIG_X86_POWERNOW_K8) += powernow-k8.o + obj-$(CONFIG_X86_LONGHAUL) += longhaul.o + obj-$(CONFIG_X86_E_POWERSAVER) += e_powersaver.o + obj-$(CONFIG_ELAN_CPUFREQ) += elanfreq.o + obj-$(CONFIG_SC520_CPUFREQ) += sc520_freq.o + obj-$(CONFIG_X86_LONGRUN) += longrun.o + obj-$(CONFIG_X86_GX_SUSPMOD) += gx-suspmod.o + obj-$(CONFIG_X86_SPEEDSTEP_ICH) += speedstep-ich.o + obj-$(CONFIG_X86_SPEEDSTEP_CENTRINO) += speedstep-centrino.o + obj-$(CONFIG_X86_SPEEDSTEP_LIB) += speedstep-lib.o + obj-$(CONFIG_X86_SPEEDSTEP_SMI) += speedstep-smi.o + obj-$(CONFIG_X86_ACPI_CPUFREQ) += acpi-cpufreq.o + obj-$(CONFIG_X86_P4_CLOCKMOD) += p4-clockmod.o + obj-$(CONFIG_X86_CPUFREQ_NFORCE2) += cpufreq-nforce2.o diff -Nurp linux-2.6.24.orig/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c linux-2.6.24.speedstep-centrino/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c --- linux-2.6.24.orig/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c 2008-01-25 01:58:37.000000000 +0300 +++ linux-2.6.24.speedstep-centrino/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c 2008-04-07 00:48:28.000000000 +0400 @@ -13,6 +13,11 @@ * Copyright (C) 2003 Jeremy Fitzhardinge */ +/* + * This file has been patched with Linux PHC: https://www.dedigentoo.org/trac/linux-phc + * Patch version: linux-phc-0.2.10-kernel-vanilla-2.6.21.patch + */ + #include #include #include @@ -21,6 +26,12 @@ #include #include +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_ACPI +#include +#include +#include +#endif + #include #include #include @@ -44,6 +55,7 @@ enum { CPU_DOTHAN_A1, CPU_DOTHAN_A2, CPU_DOTHAN_B0, + CPU_DOTHAN_C0, CPU_MP4HT_D0, CPU_MP4HT_E0, }; @@ -53,6 +65,7 @@ static const struct cpu_id cpu_ids[] = { [CPU_DOTHAN_A1] = { 6, 13, 1 }, [CPU_DOTHAN_A2] = { 6, 13, 2 }, [CPU_DOTHAN_B0] = { 6, 13, 6 }, + [CPU_DOTHAN_C0] = { 6, 13, 8 }, [CPU_MP4HT_D0] = {15, 3, 4 }, [CPU_MP4HT_E0] = {15, 4, 1 }, }; @@ -63,8 +76,8 @@ struct cpu_model const struct cpu_id *cpu_id; const char *model_name; unsigned max_freq; /* max clock in kHz */ - struct cpufreq_frequency_table *op_points; /* clock/voltage pairs */ + unsigned base_freq; /* base frequency used to convert between clock rates and MSR: FSB/4 in kHz */ }; static int centrino_verify_cpu_id(const struct cpuinfo_x86 *c, const struct cpu_id *x); @@ -74,7 +87,9 @@ static const struct cpu_id *centrino_cpu static struct cpufreq_driver centrino_driver; -#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_TABLE +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN + +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_BANIAS /* Computes the correct form for IA32_PERF_CTL MSR for a particular frequency/voltage operating point; frequency in MHz, volts in mV. @@ -122,7 +137,6 @@ static struct cpufreq_frequency_table ba { .frequency = CPUFREQ_TABLE_END } }; - /* Low Voltage Intel Pentium M processor 1.20GHz (Banias) */ static struct cpufreq_frequency_table banias_1200[] = { @@ -199,13 +213,243 @@ static struct cpufreq_frequency_table ba .model_name = "Intel(R) Pentium(R) M processor " name "MHz", \ .max_freq = (max)*1000, \ .op_points = banias_##max, \ + .base_freq = 100000, \ } #define BANIAS(max) _BANIAS(&cpu_ids[CPU_BANIAS], max, #max) +#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_BANIAS */ + +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_DOTHAN +/* Dothan processor datasheet 30218903.pdf defines 4 voltages for each + frequency (VID#A through VID#D) - this macro allows us to define all + of these but we only use the VID#A voltages at compile time - this may + need some work if we want to select the voltage profile at runtime. */ + +#define OP(mhz, mva, mvb, mvc, mvd) \ + { \ + .frequency = (mhz) * 1000, \ + .index = (((mhz)/100) << 8) | ((mva - 700) / 16) \ + } + +/* Intel Pentium M processor 733 / 1.10GHz (Dothan) */ +static struct cpufreq_frequency_table dothan_1100[] = +{ + OP( 600, 700, 700, 700, 700), + OP( 800, 748, 748, 748, 748), + OP( 900, 764, 764, 764, 764), + OP(1000, 812, 812, 812, 812), + OP(1100, 844, 844, 844, 844), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 710 / 1.40GHz (Dothan) */ +static struct cpufreq_frequency_table dothan_1400[] = +{ + + OP( 600, 988, 988, 988, 988), + OP( 800, 1068, 1068, 1068, 1052), + OP(1000, 1148, 1148, 1132, 1116), + OP(1200, 1228, 1212, 1212, 1180), + OP(1400, 1340, 1324, 1308, 1276), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 715 / 1.50GHz (Dothan) */ +static struct cpufreq_frequency_table dothan_1500[] = +{ + OP( 600, 988, 988, 988, 988), + OP( 800, 1068, 1068, 1068, 1052), + OP(1000, 1148, 1148, 1132, 1116), + OP(1200, 1228, 1212, 1212, 1180), + OP(1500, 1340, 1324, 1308, 1276), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 725 / 1.60GHz (Dothan) */ +static struct cpufreq_frequency_table dothan_1600[] = +{ + OP( 600, 988, 988, 988, 988), + OP( 800, 1068, 1068, 1052, 1052), + OP(1000, 1132, 1132, 1116, 1116), + OP(1200, 1212, 1196, 1180, 1164), + OP(1400, 1276, 1260, 1244, 1228), + OP(1600, 1340, 1324, 1308, 1276), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 735 / 1.70GHz (Dothan) */ +static struct cpufreq_frequency_table dothan_1700[] = +{ + OP( 600, 988, 988, 988, 988), + OP( 800, 1052, 1052, 1052, 1052), + OP(1000, 1116, 1116, 1116, 1100), + OP(1200, 1180, 1180, 1164, 1148), + OP(1400, 1244, 1244, 1228, 1212), + OP(1700, 1340, 1324, 1308, 1276), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 745 / 1.80GHz (Dothan) */ +static struct cpufreq_frequency_table dothan_1800[] = +{ + OP( 600, 988, 988, 988, 988), + OP( 800, 1052, 1052, 1052, 1036), + OP(1000, 1116, 1100, 1100, 1084), + OP(1200, 1164, 1164, 1148, 1132), + OP(1400, 1228, 1212, 1212, 1180), + OP(1600, 1292, 1276, 1260, 1228), + OP(1800, 1340, 1324, 1308, 1276), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 755 / 2.00GHz (Dothan) */ +static struct cpufreq_frequency_table dothan_2000[] = +{ + OP( 600, 988, 988, 988, 988), + OP( 800, 1052, 1036, 1036, 1036), + OP(1000, 1100, 1084, 1084, 1084), + OP(1200, 1148, 1132, 1132, 1116), + OP(1400, 1196, 1180, 1180, 1164), + OP(1600, 1244, 1228, 1228, 1196), + OP(1800, 1292, 1276, 1276, 1244), + OP(2000, 1340, 1324, 1308, 1276), + { .frequency = CPUFREQ_TABLE_END } +}; + +#undef OP + +#define DOTHAN(cpuid, max, name) \ +{ .cpu_id = cpuid, \ + .model_name = "Intel(R) Pentium(R) M processor " name "GHz", \ + .max_freq = (max)*1000, \ + .op_points = dothan_##max, \ + .base_freq = 100000, \ +} + +#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_DOTHAN */ + + +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_SONOMA + +/* Intel datasheets 30526202.pdf define voltages only for highest and + lowest frequency modes (HFM and LFM). + For LFM the datasheet gives one typical voltage: LFMVccTyp. + For HFM the datasheet gives a min and a max voltage: HFMVccMin and HFMVccMax. + The tables below are using HFMVccMax for the highest frequency to be on + the safe side. The voltages of the intermediate frequencies are linearly + interpolated from LFMVccTyp and HFMVccMax as it is what I have observed + to be used by the ACPI tables of my laptop and of some other's one. + + LFMVccTyp is 988 mv for all models + HFMVccMin is 1260 mv for all models + HFMVccMax is 1356 mv for models 730, 740, 750 and 760. + HFMVccMax is 1372 mv for model 770. + HFMVccMax is 1404 mv for model 780. + + As only the first voltage of each row of the tables are used I have put + there the values interpolated from HFMVccMax rounded to the next higher 16 mV step + For reference I have put in the other 3 columns: + values interpolated from HFMVccMax rounded to the nearest 1 mv + values interpolated from HFMVccMin rounded to the next higher 16 mv step + values interpolated from HFMVccMin rounded to the nearest 1 mv +*/ + +#define OPEX(mhz, base, mva, mvb, mvc, mvd) \ +{ \ + .frequency = (mhz) * 1000, \ + .index = (((mhz)/(base)) << 8) | ((mva - 700) / 16) \ +} + +/* Intel Pentium M processor 730 / 1.60 GHz (Sonoma) */ +static struct cpufreq_frequency_table sonoma_1596[] = +{ + OPEX( 798, 133, 988, 988, 988, 988), + OPEX(1064, 133, 1116, 1111, 1084, 1079), + OPEX(1330, 133, 1244, 1233, 1180, 1169), + OPEX(1596, 133, 1356, 1356, 1260, 1260), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 740 / 1.73 GHz (Sonoma) */ +static struct cpufreq_frequency_table sonoma_1729[] = +{ + OPEX( 798, 133, 988, 988, 988, 988), + OPEX(1064, 133, 1100, 1093, 1068, 1066), + OPEX(1330, 133, 1212, 1198, 1148, 1143), + OPEX(1729, 133, 1356, 1356, 1260, 1260), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 750 / 1.86 GHz (Sonoma) */ +static struct cpufreq_frequency_table sonoma_1862[] = +{ + OPEX( 798, 133, 988, 988, 988, 988), + OPEX(1064, 133, 1084, 1080, 1068, 1056), + OPEX(1330, 133, 1180, 1172, 1132, 1124), + OPEX(1596, 133, 1276, 1264, 1196, 1192), + OPEX(1862, 133, 1356, 1356, 1260, 1260), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 760 / 2.00 GHz (Sonoma) */ +static struct cpufreq_frequency_table sonoma_1995[] = +{ + OPEX( 798, 133, 988, 988, 988, 988), + OPEX(1064, 133, 1084, 1070, 1052, 1048), + OPEX(1330, 133, 1164, 1152, 1116, 1109), + OPEX(1596, 133, 1244, 1233, 1180, 1169), + OPEX(1995, 133, 1356, 1356, 1260, 1260), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 770 / 2.13 GHz (Sonoma) */ +static struct cpufreq_frequency_table sonoma_2128[] = +{ + OPEX( 798, 133, 988, 988, 988, 988), + OPEX(1064, 133, 1068, 1065, 1052, 1042), + OPEX(1330, 133, 1148, 1142, 1100, 1097), + OPEX(1596, 133, 1228, 1218, 1164, 1151), + OPEX(1862, 133, 1308, 1295, 1212, 1206), + OPEX(2128, 133, 1372, 1372, 1260, 1260), + { .frequency = CPUFREQ_TABLE_END } +}; + +/* Intel Pentium M processor 780 / 2.26 GHz (Sonoma) */ +static struct cpufreq_frequency_table sonoma_2261[] = +{ + OPEX( 798, 133, 988, 988, 988, 988), + OPEX(1064, 133, 1068, 1064, 1052, 1037), + OPEX(1330, 133, 1148, 1139, 1100, 1087), + OPEX(1596, 133, 1228, 1215, 1148, 1136), + OPEX(1862, 133, 1292, 1291, 1196, 1186), + OPEX(2261, 133, 1404, 1404, 1260, 1260), + { .frequency = CPUFREQ_TABLE_END } +}; + +#undef OPEX + +#define SONOMA(cpuid, max, base, name) \ +{ .cpu_id = cpuid, \ + .model_name = "Intel(R) Pentium(R) M processor " name "GHz", \ + .max_freq = (max)*1000, \ + .op_points = sonoma_##max, \ + .base_freq = (base)*1000, \ +} + +#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_SONOMA */ + + +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_YONAH +// To Do +#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_YONAH */ + + /* CPU models, their operating frequency range, and freq/voltage operating points */ static struct cpu_model models[] = { +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_BANIAS + /* Builtin tables for Banias CPUs */ _BANIAS(&cpu_ids[CPU_BANIAS], 900, " 900"), BANIAS(1000), BANIAS(1100), @@ -215,18 +459,51 @@ static struct cpu_model models[] = BANIAS(1500), BANIAS(1600), BANIAS(1700), +#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_BANIAS */ - /* NULL model_name is a wildcard */ - { &cpu_ids[CPU_DOTHAN_A1], NULL, 0, NULL }, - { &cpu_ids[CPU_DOTHAN_A2], NULL, 0, NULL }, - { &cpu_ids[CPU_DOTHAN_B0], NULL, 0, NULL }, - { &cpu_ids[CPU_MP4HT_D0], NULL, 0, NULL }, - { &cpu_ids[CPU_MP4HT_E0], NULL, 0, NULL }, +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_DOTHAN + /* Builtin tables for Dothan B0 CPUs */ + DOTHAN(&cpu_ids[CPU_DOTHAN_B0], 1100, "1.10"), + DOTHAN(&cpu_ids[CPU_DOTHAN_B0], 1400, "1.40"), + DOTHAN(&cpu_ids[CPU_DOTHAN_B0], 1500, "1.50"), + DOTHAN(&cpu_ids[CPU_DOTHAN_B0], 1600, "1.60"), + DOTHAN(&cpu_ids[CPU_DOTHAN_B0], 1700, "1.70"), + DOTHAN(&cpu_ids[CPU_DOTHAN_B0], 1800, "1.80"), + DOTHAN(&cpu_ids[CPU_DOTHAN_B0], 2000, "2.00"), +#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_DOTHAN */ + +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_SONOMA + /* Builtin tables for Dothan C0 CPUs, a.k.a Sonoma */ + SONOMA(&cpu_ids[CPU_DOTHAN_C0], 1596, 133, "1.60"), + SONOMA(&cpu_ids[CPU_DOTHAN_C0], 1729, 133, "1.73"), + SONOMA(&cpu_ids[CPU_DOTHAN_C0], 1862, 133, "1.86"), + SONOMA(&cpu_ids[CPU_DOTHAN_C0], 1995, 133, "2.00"), + SONOMA(&cpu_ids[CPU_DOTHAN_C0], 2128, 133, "2.13"), + SONOMA(&cpu_ids[CPU_DOTHAN_C0], 2261, 133, "2.26"), +#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_SONOMA */ + +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_YONAH + /* Builtin tables for Yonah CPUs */ + // To Do +#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_BUILTIN_YONAH */ + + /* NULL model_name is a wildcard to catch known CPU IDs for which + * we don't have any builtin table */ + { &cpu_ids[CPU_BANIAS], NULL, 0, NULL, 0 }, + { &cpu_ids[CPU_DOTHAN_A1], NULL, 0, NULL, 0 }, + { &cpu_ids[CPU_DOTHAN_A2], NULL, 0, NULL, 0 }, + { &cpu_ids[CPU_DOTHAN_B0], NULL, 0, NULL, 0 }, + { &cpu_ids[CPU_DOTHAN_C0], NULL, 0, NULL, 0 }, + { &cpu_ids[CPU_MP4HT_D0], NULL, 0, NULL, 0 }, + { &cpu_ids[CPU_MP4HT_E0], NULL, 0, NULL, 0 }, + /* End of the table */ { NULL, } }; #undef _BANIAS #undef BANIAS +#undef DOTHAN +#undef SONOMA static int centrino_cpu_init_table(struct cpufreq_policy *policy) { @@ -286,6 +563,13 @@ static unsigned extract_clock(unsigned m * for centrino, as some DSDTs are buggy. * Ideally, this can be done using the acpi_data structure. */ + + if ((centrino_model[cpu]) && (centrino_model[cpu]->base_freq != 0)) + { + msr = (msr >> 8) & 0xff; + return msr * centrino_model[cpu]->base_freq; + } + if ((centrino_cpu[cpu] == &cpu_ids[CPU_BANIAS]) || (centrino_cpu[cpu] == &cpu_ids[CPU_DOTHAN_A1]) || (centrino_cpu[cpu] == &cpu_ids[CPU_DOTHAN_B0])) { @@ -338,6 +622,667 @@ static unsigned int get_cur_freq(unsigne } +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_ACPI + +static struct acpi_processor_performance *acpi_perf_data[NR_CPUS]; + +/* + * centrino_cpu_early_init_acpi - Do the preregistering with ACPI P-States + * library + * + * Before doing the actual init, we need to do _PSD related setup whenever + * supported by the BIOS. These are handled by this early_init routine. + */ +static int centrino_cpu_early_init_acpi(void) +{ + unsigned int i, j; + struct acpi_processor_performance *data; + + for_each_possible_cpu(i) { + data = kzalloc(sizeof(struct acpi_processor_performance), + GFP_KERNEL); + if (!data) { + for_each_possible_cpu(j) { + kfree(acpi_perf_data[j]); + acpi_perf_data[j] = NULL; + } + return (-ENOMEM); + } + acpi_perf_data[i] = data; + } + + acpi_processor_preregister_performance(acpi_perf_data); + return 0; +} + + +#ifdef CONFIG_SMP +/* + * Some BIOSes do SW_ANY coordination internally, either set it up in hw + * or do it in BIOS firmware and won't inform about it to OS. If not + * detected, this has a side effect of making CPU run at a different speed + * than OS intended it to run at. Detect it and handle it cleanly. + */ +static int bios_with_sw_any_bug; +static int sw_any_bug_found(struct dmi_system_id *d) +{ + bios_with_sw_any_bug = 1; + return 0; +} + +static struct dmi_system_id sw_any_bug_dmi_table[] = { + { + .callback = sw_any_bug_found, + .ident = "Supermicro Server X6DLP", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"), + DMI_MATCH(DMI_BIOS_VERSION, "080010"), + DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"), + }, + }, + { } +}; +#endif + +/* + * 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) +{ + unsigned long cur_freq; + int result = 0, i; + unsigned int cpu = policy->cpu; + struct acpi_processor_performance *p; + + p = acpi_perf_data[cpu]; + + /* register with ACPI core */ + if (acpi_processor_register_performance(p, cpu)) { + dprintk(PFX "obtaining ACPI data failed\n"); + return -EIO; + } + + policy->shared_type = p->shared_type; + /* + * Will let policy->cpus know about dependency only when software + * coordination is required. + */ + if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL || + policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) { + policy->cpus = p->shared_cpu_map; + } + +#ifdef CONFIG_SMP + dmi_check_system(sw_any_bug_dmi_table); + if (bios_with_sw_any_bug && cpus_weight(policy->cpus) == 1) { + policy->shared_type = CPUFREQ_SHARED_TYPE_ALL; + // tym policy->cpus = cpu_core_map[cpu]; + } +#endif + + /* verify the acpi_data */ + if (p->state_count <= 1) { + dprintk("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)) { + dprintk("Invalid control/status registers (%x - %x)\n", + p->control_register.space_id, p->status_register.space_id); + result = -EIO; + goto err_unreg; + } + + for (i=0; istate_count; i++) { + if ((p->states[i].control & INTEL_MSR_RANGE) != + (p->states[i].status & INTEL_MSR_RANGE)) { + dprintk("Different MSR bits in control (%llu) and status (%llu)\n", + p->states[i].control, p->states[i].status); + result = -EINVAL; + goto err_unreg; + } + + if (!p->states[i].core_frequency) { + dprintk("Zero core frequency for state %u\n", i); + result = -EINVAL; + goto err_unreg; + } + + if (p->states[i].core_frequency > p->states[0].core_frequency) { + dprintk("P%u has larger frequency (%llu) than P0 (%llu), skipping\n", i, + p->states[i].core_frequency, p->states[0].core_frequency); + p->states[i].core_frequency = 0; + continue; + } + } + + centrino_model[cpu] = kzalloc(sizeof(struct cpu_model), GFP_KERNEL); + if (!centrino_model[cpu]) { + result = -ENOMEM; + goto err_unreg; + } + + centrino_model[cpu]->model_name=NULL; + centrino_model[cpu]->max_freq = p->states[0].core_frequency * 1000; + centrino_model[cpu]->op_points = kmalloc(sizeof(struct cpufreq_frequency_table) * + (p->state_count + 1), GFP_KERNEL); + if (!centrino_model[cpu]->op_points) { + result = -ENOMEM; + goto err_kfree; + } + + for (i=0; istate_count; i++) { + centrino_model[cpu]->op_points[i].index = p->states[i].control & INTEL_MSR_RANGE; + centrino_model[cpu]->op_points[i].frequency = p->states[i].core_frequency * 1000; + dprintk("adding state %i with frequency %u and control value %04x\n", + i, centrino_model[cpu]->op_points[i].frequency, centrino_model[cpu]->op_points[i].index); + } + centrino_model[cpu]->op_points[p->state_count].frequency = CPUFREQ_TABLE_END; + + cur_freq = get_cur_freq(cpu); + centrino_model[cpu]->base_freq = 0; + + for (i=0; istate_count; i++) { + if (!p->states[i].core_frequency) { + dprintk("skipping state %u\n", i); + centrino_model[cpu]->op_points[i].frequency = CPUFREQ_ENTRY_INVALID; + continue; + } + + if (extract_clock(centrino_model[cpu]->op_points[i].index, cpu, 0) != + (centrino_model[cpu]->op_points[i].frequency)) { + dprintk("Invalid encoded frequency (%u vs. %u)\n", + extract_clock(centrino_model[cpu]->op_points[i].index, cpu, 0), + centrino_model[cpu]->op_points[i].frequency); + result = -EINVAL; + goto err_kfree_all; + } + + if (cur_freq == centrino_model[cpu]->op_points[i].frequency) + p->state = i; + } + + /* notify BIOS that we exist */ + acpi_processor_notify_smm(THIS_MODULE); + printk("speedstep-centrino with X86_SPEEDSTEP_CENTRINO_ACPI " + "config is deprecated.\n " + "Use X86_ACPI_CPUFREQ (acpi-cpufreq) instead.\n" ); + + return 0; + + err_kfree_all: + kfree(centrino_model[cpu]->op_points); + err_kfree: + kfree(centrino_model[cpu]); + err_unreg: + acpi_processor_unregister_performance(p, cpu); + dprintk(PFX "invalid ACPI data\n"); + return (result); +} +#else +static inline int centrino_cpu_init_acpi(struct cpufreq_policy *policy) { return -ENODEV; } +static inline int centrino_cpu_early_init_acpi(void) { return 0; } +#endif + +static int centrino_target (struct cpufreq_policy *policy, + unsigned int target_freq, + unsigned int relation); + + +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_SYSFS +/************************** sysfs interface for user defined voltage table ************************/ + +static struct cpufreq_frequency_table **original_table = NULL; + +static void check_origial_table (unsigned int cpu) +{ + int i; + + if (!original_table) + { + original_table = kmalloc(sizeof(struct cpufreq_frequency_table *)*NR_CPUS, GFP_KERNEL); + for (i=0; i < NR_CPUS; i++) + { + original_table[i] = NULL; + } + } + + if (!original_table[cpu]) + { + /* Count number of frequencies and allocate memory for a copy */ + for (i=0; centrino_model[cpu]->op_points[i].frequency != CPUFREQ_TABLE_END; i++); + /* Allocate memory to store the copy */ + original_table[cpu] = (struct cpufreq_frequency_table*) kmalloc(sizeof(struct cpufreq_frequency_table)*(i+1), GFP_KERNEL); + /* Make copy of frequency/voltage pairs */ + for (i=0; centrino_model[cpu]->op_points[i].frequency != CPUFREQ_TABLE_END; i++) + { + original_table[cpu][i].frequency = centrino_model[cpu]->op_points[i].frequency; + original_table[cpu][i].index = centrino_model[cpu]->op_points[i].index; + } + original_table[cpu][i].frequency = CPUFREQ_TABLE_END; + } +} + + +static ssize_t show_user_voltage (struct cpufreq_policy *policy, char *buf) +{ + ssize_t bytes_written = 0; + unsigned int cpu = policy->cpu; + unsigned int op_index = 0; + unsigned int op_count = 0; + unsigned int voltage = 0; + unsigned int frequency = 0; + + //dprintk("showing user voltage table in sysfs\n"); + + while ( (centrino_model[cpu]->op_points[op_index].frequency != CPUFREQ_TABLE_END) + && (bytes_writtenop_points[op_index].frequency; + if (frequency != CPUFREQ_ENTRY_INVALID) + { + op_count++; + if (op_count>1) + bytes_written += snprintf (&buf[bytes_written],PAGE_SIZE-bytes_written-1, ","); + voltage = centrino_model[cpu]->op_points[op_index].index; + voltage = 700 + ((voltage & 0xFF) << 4); + //dprintk("writing voltage %i: %u mV \n", op_index, voltage); + bytes_written += snprintf (&buf[bytes_written],PAGE_SIZE-bytes_written-1, "%u",voltage); + } + else + { + // This operating point of the table is invalid, ignoring it. + dprintk("Ignoring invalid operating point %i \n", op_index); + } + op_index++; + } + bytes_written += snprintf (&buf[bytes_written],PAGE_SIZE-bytes_written-1, "\n"); + buf[PAGE_SIZE-1] = 0; + return bytes_written; +} + +static ssize_t +store_user_voltage (struct cpufreq_policy *policy, const char *buf, size_t count) +{ + unsigned int cpu; + const char *curr_buf; + unsigned int curr_freq; + unsigned int op_index; + int isok; + char *next_buf; + unsigned int op_point; + ssize_t retval; + unsigned int voltage; + + if (!policy) + return -ENODEV; + cpu = policy->cpu; + if (!centrino_model[cpu] || !centrino_model[cpu]->op_points) + return -ENODEV; + + check_origial_table(cpu); + + op_index = 0; + curr_buf = buf; + next_buf = NULL; + isok = 1; + + while ((centrino_model[cpu]->op_points[op_index].frequency != CPUFREQ_TABLE_END) + && (isok)) + { + if (centrino_model[cpu]->op_points[op_index].frequency != CPUFREQ_ENTRY_INVALID) + { + voltage = simple_strtoul(curr_buf, &next_buf, 10); + if ((next_buf != curr_buf) && (next_buf != NULL)) + { + if ((voltage >= 700) && (voltage<=1600)) + { + voltage = ((voltage - 700) >> 4) & 0xFF; + op_point = (original_table[cpu])[op_index].index; + if (voltage <= (op_point & 0xFF)) + { + //dprintk("setting control value %i to %04x\n", op_index, op_point); + op_point = (op_point & 0xFFFFFF00) | voltage; + centrino_model[cpu]->op_points[op_index].index = op_point; + } + else + { + op_point = (op_point & 0xFFFFFF00) | voltage; + dprintk("not setting control value %i to %04x because requested voltage is not lower than the default value\n", op_index, op_point); + //isok = 0; + } + } + else + { + dprintk("voltage value %i is out of bounds: %u mV\n", op_index, voltage); + isok = 0; + } + curr_buf = next_buf; + if (*curr_buf==',') + curr_buf++; + next_buf = NULL; + } + else + { + dprintk("failed to parse voltage value %i\n", op_index); + isok = 0; + } + } + else + { + // This operating point of the table is invalid, ignoring it. + dprintk("Ignoring invalid operating point %i \n", op_index); + } + op_index++; + } + + if (isok) + { + retval = count; + curr_freq = policy->cur; + centrino_target(policy, curr_freq, CPUFREQ_RELATION_L); + } + else + { + retval = -EINVAL; + } + + return retval; +} + +static struct freq_attr centrino_freq_attr_voltage_table = +{ + .attr = { .name = "voltage_table", .mode = 0644, .owner = THIS_MODULE }, + .show = show_user_voltage, + .store = store_user_voltage, +}; + + +static ssize_t show_user_op_points (struct cpufreq_policy *policy, char *buf) +{ + ssize_t bytes_written = 0; + unsigned int cpu = policy->cpu; + unsigned int op_index = 0; + unsigned int op_count = 0; + unsigned int voltage = 0; + unsigned int frequency = 0; + + //dprintk("showing user voltage table in sysfs\n"); + + while ( (centrino_model[cpu]->op_points[op_index].frequency != CPUFREQ_TABLE_END) + && (bytes_writtenop_points[op_index].frequency; + if (frequency != CPUFREQ_ENTRY_INVALID) + { + op_count++; + if (op_count>1) + bytes_written += snprintf (&buf[bytes_written],PAGE_SIZE-bytes_written-1, ","); + voltage = centrino_model[cpu]->op_points[op_index].index; + voltage = 700 + ((voltage & 0xFF) << 4); + //dprintk("writing voltage %i: %u mV \n", i, voltage); + bytes_written += snprintf (&buf[bytes_written],PAGE_SIZE-bytes_written-2, "%u:%u",frequency,voltage); + } + else + { + // This operating point of the table is invalid, ignoring it. + dprintk("Ignoring invalid operating point %i \n", op_index); + } + op_index++; + } + bytes_written += snprintf (&buf[bytes_written],PAGE_SIZE-bytes_written-1, "\n"); + buf[PAGE_SIZE-1] = 0; + return bytes_written; +} + +static ssize_t +store_user_op_points (struct cpufreq_policy *policy, const char *buf, size_t count) +{ + unsigned int cpu; + const char *curr_buf; + unsigned int curr_freq; + unsigned int op_index; + unsigned int op_count; + int isok; + char *next_buf; + unsigned int op_point; + ssize_t retval; + unsigned int voltage; + unsigned int frequency; + int found; + + if (!policy) + return -ENODEV; + cpu = policy->cpu; + if (!centrino_model[cpu] || !centrino_model[cpu]->op_points) + return -ENODEV; + + check_origial_table(cpu); + + op_count = 0; + curr_buf = buf; + next_buf = NULL; + isok = 1; + + while ( (isok) && (curr_buf != NULL) ) + { + op_count++; + // Parse frequency + frequency = simple_strtoul(curr_buf, &next_buf, 10); + if ((next_buf != curr_buf) && (next_buf != NULL)) + { + // Parse separator between frequency and voltage + curr_buf = next_buf; + next_buf = NULL; + if (*curr_buf==':') + { + curr_buf++; + // Parse voltage + voltage = simple_strtoul(curr_buf, &next_buf, 10); + if ((next_buf != curr_buf) && (next_buf != NULL)) + { + if ((voltage >= 700) && (voltage<=1600)) + { + voltage = ((voltage - 700) >> 4) & 0xFF; + op_index = 0; + found = 0; + while (centrino_model[cpu]->op_points[op_index].frequency != CPUFREQ_TABLE_END) + { + if ((centrino_model[cpu]->op_points[op_index].frequency == frequency) + && (centrino_model[cpu]->op_points[op_index].frequency != CPUFREQ_ENTRY_INVALID)) + { + found = 1; + op_point = (original_table[cpu])[op_index].index; + if (voltage <= (op_point & 0xFF)) + { + //dprintk("setting control value %i to %04x\n", op_index, op_point); + op_point = (op_point & 0xFFFFFF00) | voltage; + centrino_model[cpu]->op_points[op_index].index = op_point; + } + else + { + op_point = (op_point & 0xFFFFFF00) | voltage; + dprintk("not setting control value %i to %04x because requested voltage is not lower than the default value (%u MHz)\n", op_index, op_point, frequency); + } + } + op_index++; + } + if (found == 0) + { + dprintk("operating point # %u not found: %u MHz\n", op_count, frequency); + isok = 0; + } + } + else + { + dprintk("operating point # %u voltage value is out of bounds: %u mV\n", op_count, voltage); + isok = 0; + } + // Parse seprator before next operating point, if any + curr_buf = next_buf; + next_buf = NULL; + if (*curr_buf==',') + curr_buf++; + else + curr_buf = NULL; + } + else + { + dprintk("failed to parse operating point # %u voltage\n", op_count); + isok = 0; + } + } + else + { + dprintk("failed to parse operating point # %u\n", op_count); + isok = 0; + } + } + else + { + dprintk("failed to parse operating point # %u frequency\n", op_count); + isok = 0; + } + } + + if (isok) + { + retval = count; + curr_freq = policy->cur; + centrino_target(policy, curr_freq, CPUFREQ_RELATION_L); + } + else + { + retval = -EINVAL; + } + + return retval; +} + +static struct freq_attr centrino_freq_attr_op_points_table = +{ + .attr = { .name = "op_points_table", .mode = 0644, .owner = THIS_MODULE }, + .show = show_user_op_points, + .store = store_user_op_points, +}; + +unsigned long rounded_div(unsigned long x, unsigned long y) +{ + return (((x*2) / y)+1)/2; +} + +static ssize_t show_FSB_base_freq (struct cpufreq_policy *policy, char *buf) +{ + ssize_t bytes_written = 0; + unsigned int cpu = policy->cpu; + unsigned int frequency; + unsigned int index; + unsigned int op_index = 0; + + frequency = centrino_model[cpu]->base_freq; + if (frequency!=0) + { + bytes_written += snprintf (buf, PAGE_SIZE-2, "User defined base FSB frequency:\n%u kHz\n",frequency); + } + + bytes_written += snprintf (buf+bytes_written, PAGE_SIZE-bytes_written-2, + "Base FSB frequency computed from operating points table:\n"); + + check_origial_table(cpu); + while ((original_table[cpu][op_index].frequency != CPUFREQ_TABLE_END) + && (bytes_written < PAGE_SIZE-3)) + { + index = original_table[cpu][op_index].index; + index = (index >> 8) & 0xFF; + if (index > 0) + { + frequency = rounded_div((original_table[cpu][op_index].frequency), index); + bytes_written += snprintf (buf+bytes_written, PAGE_SIZE-bytes_written-2, "%u kHz (%u / %u)\n", + frequency, original_table[cpu][op_index].frequency, index); + } + op_index++; + } + + buf[PAGE_SIZE-1] = 0; + return bytes_written; +} + +static ssize_t +store_FSB_base_freq (struct cpufreq_policy *policy, const char *buf, size_t count) +{ + unsigned int cpu; + const char *curr_buf; + unsigned int curr_freq; + unsigned int frequency; + unsigned int index; + char *next_buf; + unsigned int op_index = 0; + ssize_t retval; + + if (!policy) + return -ENODEV; + cpu = policy->cpu; + if (!centrino_model[cpu] || !centrino_model[cpu]->op_points) + return -ENODEV; + + curr_buf = buf; + next_buf = NULL; + frequency = simple_strtoul(curr_buf, &next_buf, 10); + if ((next_buf != curr_buf) && (next_buf != NULL)) + { + if (centrino_model[cpu]->base_freq != frequency) + { + centrino_model[cpu]->base_freq = frequency; + + check_origial_table(cpu); + while (centrino_model[cpu]->op_points[op_index].frequency != CPUFREQ_TABLE_END) + { + if (frequency>0) + { + index = original_table[cpu][op_index].index; + index = (index >> 8) & 0xFF; + if (index > 0) + { + centrino_model[cpu]->op_points[op_index].frequency = frequency * index; + } + } + else + { + centrino_model[cpu]->op_points[op_index].frequency = original_table[cpu][op_index].frequency; + } + op_index++; + } + } + + retval = count; + curr_freq = policy->cur; + centrino_target(policy, curr_freq, CPUFREQ_RELATION_L); + } + else + { + retval = -EINVAL; + } + + return retval; +} + +static struct freq_attr centrino_freq_attr_FSB_Base_Freq = +{ + .attr = { .name = "FSB_base_frequency", .mode = 0644, .owner = THIS_MODULE }, + .show = show_FSB_base_freq, + .store = store_FSB_base_freq, +}; + +#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_SYSFS */ + static int centrino_cpu_init(struct cpufreq_policy *policy) { struct cpuinfo_x86 *cpu = &cpu_data(policy->cpu); @@ -348,13 +1293,19 @@ static int centrino_cpu_init(struct cpuf /* Only Intel makes Enhanced Speedstep-capable CPUs */ if (cpu->x86_vendor != X86_VENDOR_INTEL || !cpu_has(cpu, X86_FEATURE_EST)) + { + printk("ENODEV: (cpu->x86_vendor != X86_VENDOR_INTEL || !cpu_has(cpu, X86_FEATURE_EST))"); return -ENODEV; + } if (cpu_has(cpu, X86_FEATURE_CONSTANT_TSC)) centrino_driver.flags |= CPUFREQ_CONST_LOOPS; if (policy->cpu != 0) + { + printk("ENODEV: (policy->cpu != 0)"); return -ENODEV; + } for (i = 0; i < N_IDS; i++) if (centrino_verify_cpu_id(cpu, &cpu_ids[i])) @@ -371,6 +1322,7 @@ static int centrino_cpu_init(struct cpuf } if (centrino_cpu_init_table(policy)) { + printk("ENODEV: (centrino_cpu_init_table(policy))"); return -ENODEV; } @@ -412,7 +1364,10 @@ static int centrino_cpu_exit(struct cpuf unsigned int cpu = policy->cpu; if (!centrino_model[cpu]) + { + printk("(!centrino_model[cpu])"); return -ENODEV; + } cpufreq_frequency_table_put_attr(cpu); @@ -456,7 +1411,10 @@ static int centrino_target (struct cpufr unsigned int j, k, first_cpu, tmp; if (unlikely(centrino_model[cpu] == NULL)) + { + printk("(unlikely(centrino_model[cpu] == NULL))"); return -ENODEV; + } if (unlikely(cpufreq_frequency_table_target(policy, centrino_model[cpu]->op_points, @@ -580,6 +1538,11 @@ migrate_end: static struct freq_attr* centrino_attr[] = { &cpufreq_freq_attr_scaling_available_freqs, +#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_SYSFS + ¢rino_freq_attr_voltage_table, + ¢rino_freq_attr_op_points_table, + ¢rino_freq_attr_FSB_Base_Freq, +#endif NULL, }; @@ -612,12 +1575,18 @@ static struct cpufreq_driver centrino_dr */ static int __init centrino_init(void) { + printk("centrino_init\n"); struct cpuinfo_x86 *cpu = &cpu_data(0); if (!cpu_has(cpu, X86_FEATURE_EST)) + { + printk("ENODEV: (!cpu_has(cpu, X86_FEATURE_EST))"); return -ENODEV; + } - return cpufreq_register_driver(¢rino_driver); + int d = cpufreq_register_driver(¢rino_driver); + printk("cpufreq_register driver returns %d\n", d); + return d; } static void __exit centrino_exit(void)