kernel26-magellan/patches-2.6.25-r4/0156-2.6.25-linux-phc-0.3.1-teknohog.patch

patch comming from:
	http://hoo.homeunix.net/~teknohog/hacks/linux-phc-kernel-vanilla-2.6.25-teknohog.patch

--- linux-2.6.25/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c	2008-04-17 05:49:44.000000000 +0300
+++ linux-2.6.25-teknohog/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c	2008-04-21 01:13:12.000000000 +0300
@@ -23,10 +23,16 @@
  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 
+/* This file has been patched with Linux PHC: https://www.dedigentoo.org/trac/linux-phc
+ * Patch version: linux-phc-0.3.1-kernel-vanilla-2.6.23.patch
+ * Updated for Linux 2.6.25 by Risto A. Paju, teknohog at iki.fi
+ */
+
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/smp.h>
 #include <linux/sched.h>
@@ -57,16 +63,22 @@
 };
 
 #define INTEL_MSR_RANGE		(0xffff)
 #define CPUID_6_ECX_APERFMPERF_CAPABILITY	(0x1)
 
+#define INTEL_MSR_VID_MASK	(0x00ff)
+#define INTEL_MSR_FID_MASK	(0xff00)
+#define INTEL_MSR_FID_SHIFT	(0x8)
+#define PHC_VERSION_STRING	"0.3.1:1"
+
 struct acpi_cpufreq_data {
 	struct acpi_processor_performance *acpi_data;
 	struct cpufreq_frequency_table *freq_table;
 	unsigned int max_freq;
 	unsigned int resume;
 	unsigned int cpu_feature;
+ 	acpi_integer *original_controls;
 };
 
 static DEFINE_PER_CPU(struct acpi_cpufreq_data *, drv_data);
 
 /* acpi_perf_data is a pointer to percpu data. */
@@ -102,17 +114,19 @@
 }
 
 static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
 {
 	int i;
+	u32 fid;
 	struct acpi_processor_performance *perf;
 
-	msr &= INTEL_MSR_RANGE;
+	fid = msr & INTEL_MSR_FID_MASK;
 	perf = data->acpi_data;
 
 	for (i=0; data->freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
-		if (msr == perf->states[data->freq_table[i].index].status)
+		if (fid == (perf->states[data->freq_table[i].index].status &
+		    INTEL_MSR_FID_MASK))
 			return data->freq_table[i].frequency;
 	}
 	return data->freq_table[0].frequency;
 }
 
@@ -729,10 +743,12 @@
 	if (data) {
 		cpufreq_frequency_table_put_attr(policy->cpu);
 		per_cpu(drv_data, policy->cpu) = NULL;
 		acpi_processor_unregister_performance(data->acpi_data,
 						      policy->cpu);
+ 		if (data->original_controls)
+ 			kfree(data->original_controls);
 		kfree(data);
 	}
 
 	return 0;
 }
@@ -746,12 +762,452 @@
 	data->resume = 1;
 
 	return 0;
 }
 
+
+
+
+/* sysfs interface to change operating points voltages */
+
+static unsigned int extract_fid_from_control(unsigned int control)
+{
+	return ((control & INTEL_MSR_FID_MASK) >> INTEL_MSR_FID_SHIFT);
+}
+
+static unsigned int extract_vid_from_control(unsigned int control)
+{
+	return (control & INTEL_MSR_VID_MASK);
+}
+
+static ssize_t check_origial_table (struct acpi_cpufreq_data *data)
+{
+	struct acpi_processor_performance *acpi_data;
+	struct cpufreq_frequency_table *freq_table;
+	unsigned int state_index;
+
+	acpi_data = data->acpi_data;
+	freq_table = data->freq_table;
+
+	if (data->original_controls == NULL) {
+		// Backup original control values
+		data->original_controls = kcalloc(acpi_data->state_count,
+		                                  sizeof(acpi_integer), GFP_KERNEL);
+		if (data->original_controls == NULL) {
+			printk("failed to allocate memory for original control values\n");
+			return -ENOMEM;
+		}
+		for (state_index = 0; state_index < acpi_data->state_count; state_index++) {
+			data->original_controls[state_index] = acpi_data->states[state_index].control;
+		}
+	}
+	return 0;
+}
+
+static ssize_t show_freq_attr_vids(struct cpufreq_policy *policy, char *buf)
+{
+	struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
+	struct acpi_processor_performance *acpi_data;
+	struct cpufreq_frequency_table *freq_table;
+	unsigned int i;
+	unsigned int vid;
+	ssize_t count = 0;
+
+	if (unlikely(data == NULL || 
+	             data->acpi_data == NULL || 
+	             data->freq_table == NULL ||
+	             data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
+		return -ENODEV;
+	}
+
+	acpi_data = data->acpi_data;
+	freq_table = data->freq_table;
+
+	for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
+		vid = extract_vid_from_control(acpi_data->states[freq_table[i].index].control);
+		count += sprintf(&buf[count], "%u ", vid);
+	}
+	count += sprintf(&buf[count], "\n");
+
+	return count;
+}
+
+static ssize_t show_freq_attr_default_vids(struct cpufreq_policy *policy, char *buf)
+{
+	struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
+	struct cpufreq_frequency_table *freq_table;
+	unsigned int i;
+	unsigned int vid;
+	ssize_t count = 0;
+	ssize_t retval;
+
+	if (unlikely(data == NULL || 
+	             data->acpi_data == NULL || 
+	             data->freq_table == NULL ||
+	             data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
+		return -ENODEV;
+	}
+
+	retval = check_origial_table(data);
+        if (0 != retval)
+		return retval; 
+
+	freq_table = data->freq_table;
+
+	for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
+		vid = extract_vid_from_control(data->original_controls[freq_table[i].index]);
+		count += sprintf(&buf[count], "%u ", vid);
+	}
+	count += sprintf(&buf[count], "\n");
+
+	return count;
+}
+
+static ssize_t show_freq_attr_fids(struct cpufreq_policy *policy, char *buf)
+{
+	struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
+	struct acpi_processor_performance *acpi_data;
+	struct cpufreq_frequency_table *freq_table;
+	unsigned int i;
+	unsigned int fid;
+	ssize_t count = 0;
+
+	if (unlikely(data == NULL || 
+	             data->acpi_data == NULL || 
+	             data->freq_table == NULL ||
+	             data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
+		return -ENODEV;
+	}
+
+	acpi_data = data->acpi_data;
+	freq_table = data->freq_table;
+
+	for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
+		fid = extract_fid_from_control(acpi_data->states[freq_table[i].index].control);
+		count += sprintf(&buf[count], "%u ", fid);
+	}
+	count += sprintf(&buf[count], "\n");
+
+	return count;
+}
+
+static ssize_t show_freq_attr_controls(struct cpufreq_policy *policy, char *buf)
+{
+	struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
+	struct acpi_processor_performance *acpi_data;
+	struct cpufreq_frequency_table *freq_table;
+	unsigned int i;
+	unsigned int fid;
+	unsigned int vid;
+	ssize_t count = 0;
+
+	if (unlikely(data == NULL || 
+	             data->acpi_data == NULL || 
+	             data->freq_table == NULL ||
+	             data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
+		return -ENODEV;
+	}
+
+	acpi_data = data->acpi_data;
+	freq_table = data->freq_table;
+
+	for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
+		fid = extract_fid_from_control(acpi_data->states[freq_table[i].index].control);
+		vid = extract_vid_from_control(acpi_data->states[freq_table[i].index].control);
+		count += sprintf(&buf[count], "%u:%u ", fid, vid);
+	}
+	count += sprintf(&buf[count], "\n");
+
+	return count;
+}
+
+static ssize_t show_freq_attr_default_controls(struct cpufreq_policy *policy, char *buf)
+{
+	struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
+	struct cpufreq_frequency_table *freq_table;
+	unsigned int i;
+	unsigned int fid;
+	unsigned int vid;
+	ssize_t count = 0;
+	ssize_t retval;
+
+	if (unlikely(data == NULL || 
+	             data->acpi_data == NULL || 
+	             data->freq_table == NULL ||
+	             data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
+		return -ENODEV;
+	}
+
+	retval = check_origial_table(data);
+        if (0 != retval)
+		return retval; 
+
+	freq_table = data->freq_table;
+
+	for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
+		fid = extract_fid_from_control(data->original_controls[freq_table[i].index]);
+		vid = extract_vid_from_control(data->original_controls[freq_table[i].index]);
+		count += sprintf(&buf[count], "%u:%u ", fid, vid);
+	}
+	count += sprintf(&buf[count], "\n");
+
+	return count;
+}
+
+
+static ssize_t store_freq_attr_vids(struct cpufreq_policy *policy, const char *buf, size_t count)
+{
+	struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
+	struct acpi_processor_performance *acpi_data;
+	struct cpufreq_frequency_table *freq_table;
+	unsigned int freq_index;
+	unsigned int state_index;
+	unsigned int new_vid;
+	unsigned int original_vid;
+	unsigned int new_control;
+	unsigned int original_control;
+	const char *curr_buf = buf;
+	char *next_buf;
+	ssize_t retval;
+
+	if (unlikely(data == NULL || 
+	             data->acpi_data == NULL || 
+	             data->freq_table == NULL ||
+	             data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
+		return -ENODEV;
+	}
+
+	retval = check_origial_table(data);
+        if (0 != retval)
+		return retval; 
+
+	acpi_data = data->acpi_data;
+	freq_table = data->freq_table;
+
+	for (freq_index = 0; freq_table[freq_index].frequency != CPUFREQ_TABLE_END; freq_index++) {
+		new_vid = simple_strtoul(curr_buf, &next_buf, 10);
+		if (next_buf == curr_buf) {
+			if ((curr_buf - buf == count - 1) && (*curr_buf == '\n')) {
+				curr_buf++;
+				break;
+			}
+			printk("failed to parse vid value at %i (%s)\n", freq_index, curr_buf);
+			return -EINVAL;
+		}
+
+		state_index = freq_table[freq_index].index;
+		original_control = data->original_controls[state_index];
+		original_vid = original_control & INTEL_MSR_VID_MASK;
+		if (new_vid <= original_vid) {
+			new_control = (original_control & ~INTEL_MSR_VID_MASK) | new_vid;
+			dprintk("setting control at %i to %x (default is %x)\n",
+			        freq_index, new_control, original_control);
+			acpi_data->states[state_index].control = new_control;
+
+		} else {
+			printk("skipping vid at %i, %u is greater than default %u\n",
+			       freq_index, new_vid, original_vid);
+		}
+
+		curr_buf = next_buf;
+		while ((curr_buf - buf < count) && ((*curr_buf == ' ') || (*curr_buf == ','))) {
+			curr_buf++;
+		}
+	}
+
+	/* set new voltage at current frequency */
+	data->resume = 1;
+	acpi_cpufreq_target(policy, get_cur_freq_on_cpu(policy->cpu), CPUFREQ_RELATION_L);
+
+	return curr_buf - buf;
+}
+
+static ssize_t store_freq_attr_controls(struct cpufreq_policy *policy, const char *buf, size_t count)
+{
+	struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
+	struct acpi_processor_performance *acpi_data;
+	struct cpufreq_frequency_table *freq_table;
+	const char   *curr_buf;
+	unsigned int  op_count;
+	unsigned int  state_index;
+	int           isok;
+	char         *next_buf;
+	ssize_t       retval;
+	unsigned int  new_vid;
+	unsigned int  original_vid;
+	unsigned int  new_fid;
+	unsigned int  old_fid;
+	unsigned int  original_control;
+	unsigned int  old_control;
+	unsigned int  new_control;
+	int           found;
+
+	if (unlikely(data == NULL || 
+	             data->acpi_data == NULL || 
+	             data->freq_table == NULL ||
+	             data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
+		return -ENODEV;
+	}
+
+	retval = check_origial_table(data);
+        if (0 != retval)
+		return retval;
+
+	acpi_data = data->acpi_data;
+	freq_table = data->freq_table;
+
+	op_count = 0;
+	curr_buf = buf;
+	next_buf = NULL;
+	isok     = 1;
+	
+	while ( (isok) && (curr_buf != NULL) )
+	{
+		op_count++;
+		// Parse fid
+		new_fid = 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 vid
+				new_vid = simple_strtoul(curr_buf, &next_buf, 10);
+				if ((next_buf != curr_buf) && (next_buf != NULL))
+				{
+					found = 0;
+					for (state_index = 0; state_index < acpi_data->state_count; state_index++) {
+						old_control = acpi_data->states[state_index].control;
+						old_fid = extract_fid_from_control(old_control);
+						if (new_fid == old_fid)
+						{
+							found = 1;
+							original_control = data->original_controls[state_index];
+							original_vid = extract_vid_from_control(original_control);
+							if (new_vid <= original_vid)
+							{
+								new_control = (original_control & ~INTEL_MSR_VID_MASK) | new_vid;
+								dprintk("setting control at %i to %x (default is %x)\n",
+								        state_index, new_control, original_control);
+								acpi_data->states[state_index].control = new_control;
+
+							} else {
+								printk("skipping vid at %i, %u is greater than default %u\n",
+								       state_index, new_vid, original_vid);
+							}
+						}
+					}
+
+					if (found == 0)
+					{
+						printk("operating point # %u not found (FID = %u)\n", op_count, new_fid);
+						isok = 0;
+					}
+
+					// Parse seprator before next operating point, if any
+					curr_buf = next_buf;
+					next_buf = NULL;
+					if ((*curr_buf == ',') || (*curr_buf == ' '))
+						curr_buf++;
+					else
+						curr_buf = NULL;
+				}
+				else
+				{
+					printk("failed to parse VID of operating point # %u (%s)\n", op_count, curr_buf);
+					isok = 0;
+				}
+			}
+			else
+			{
+				printk("failed to parse operating point # %u (%s)\n", op_count, curr_buf);
+				isok = 0;
+			}
+		}
+		else
+		{
+			printk("failed to parse FID of operating point # %u (%s)\n", op_count, curr_buf);
+			isok = 0;
+		}
+	}
+
+	if (isok)
+	{
+		retval = count;
+		/* set new voltage at current frequency */
+		data->resume = 1;
+		acpi_cpufreq_target(policy, get_cur_freq_on_cpu(policy->cpu), CPUFREQ_RELATION_L);
+	}
+	else
+	{
+		retval = -EINVAL;
+	}
+
+	return retval;
+}
+
+static ssize_t show_freq_attr_phc_version(struct cpufreq_policy *policy, char *buf)
+{
+	ssize_t count = 0;
+	count += sprintf(&buf[count], "%s\n", PHC_VERSION_STRING);
+	return count;
+}
+
+static struct freq_attr cpufreq_freq_attr_phc_version =
+{
+       .attr = { .name = "phc_version", .mode = 0444, .owner = THIS_MODULE },
+       .show = show_freq_attr_phc_version,
+       .store = NULL,
+};
+
+static struct freq_attr cpufreq_freq_attr_vids =
+{
+       .attr = { .name = "phc_vids", .mode = 0644, .owner = THIS_MODULE },
+       .show = show_freq_attr_vids,
+       .store = store_freq_attr_vids,
+};
+
+static struct freq_attr cpufreq_freq_attr_default_vids =
+{
+       .attr = { .name = "phc_default_vids", .mode = 0444, .owner = THIS_MODULE },
+       .show = show_freq_attr_default_vids,
+       .store = NULL,
+};
+
+static struct freq_attr cpufreq_freq_attr_fids =
+{
+       .attr = { .name = "phc_fids", .mode = 0444, .owner = THIS_MODULE },
+       .show = show_freq_attr_fids,
+       .store = NULL,
+};
+
+static struct freq_attr cpufreq_freq_attr_controls =
+{
+       .attr = { .name = "phc_controls", .mode = 0644, .owner = THIS_MODULE },
+       .show = show_freq_attr_controls,
+       .store = store_freq_attr_controls,
+};
+
+static struct freq_attr cpufreq_freq_attr_default_controls =
+{
+       .attr = { .name = "phc_default_controls", .mode = 0444, .owner = THIS_MODULE },
+       .show = show_freq_attr_default_controls,
+       .store = NULL,
+};
+
+
 static struct freq_attr *acpi_cpufreq_attr[] = {
+	&cpufreq_freq_attr_phc_version,
 	&cpufreq_freq_attr_scaling_available_freqs,
+	&cpufreq_freq_attr_vids,
+	&cpufreq_freq_attr_default_vids,
+	&cpufreq_freq_attr_fids,
+	&cpufreq_freq_attr_controls,
+	&cpufreq_freq_attr_default_controls,
 	NULL,
 };
 
 static struct cpufreq_driver acpi_cpufreq_driver = {
 	.verify = acpi_cpufreq_verify,
1	niro	664	patch comming from:
2			http://hoo.homeunix.net/~teknohog/hacks/linux-phc-kernel-vanilla-2.6.25-teknohog.patch
3
4			--- linux-2.6.25/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c 2008-04-17 05:49:44.000000000 +0300
5			+++ linux-2.6.25-teknohog/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c 2008-04-21 01:13:12.000000000 +0300
6			@@ -23,10 +23,16 @@
7			* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
8			*
9			* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10			*/
11
12			+/* This file has been patched with Linux PHC: https://www.dedigentoo.org/trac/linux-phc
13			+ * Patch version: linux-phc-0.3.1-kernel-vanilla-2.6.23.patch
14			+ * Updated for Linux 2.6.25 by Risto A. Paju, teknohog at iki.fi
15			+ */
16			+
17			+
18			#include <linux/kernel.h>
19			#include <linux/module.h>
20			#include <linux/init.h>
21			#include <linux/smp.h>
22			#include <linux/sched.h>
23			@@ -57,16 +63,22 @@
24			};
25
26			#define INTEL_MSR_RANGE (0xffff)
27			#define CPUID_6_ECX_APERFMPERF_CAPABILITY (0x1)
28
29			+#define INTEL_MSR_VID_MASK (0x00ff)
30			+#define INTEL_MSR_FID_MASK (0xff00)
31			+#define INTEL_MSR_FID_SHIFT (0x8)
32			+#define PHC_VERSION_STRING "0.3.1:1"
33			+
34			struct acpi_cpufreq_data {
35			struct acpi_processor_performance *acpi_data;
36			struct cpufreq_frequency_table *freq_table;
37			unsigned int max_freq;
38			unsigned int resume;
39			unsigned int cpu_feature;
40			+ acpi_integer *original_controls;
41			};
42
43			static DEFINE_PER_CPU(struct acpi_cpufreq_data *, drv_data);
44
45			/* acpi_perf_data is a pointer to percpu data. */
46			@@ -102,17 +114,19 @@
47			}
48
49			static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
50			{
51			int i;
52			+ u32 fid;
53			struct acpi_processor_performance *perf;
54
55			- msr &= INTEL_MSR_RANGE;
56			+ fid = msr & INTEL_MSR_FID_MASK;
57			perf = data->acpi_data;
58
59			for (i=0; data->freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
60			- if (msr == perf->states[data->freq_table[i].index].status)
61			+ if (fid == (perf->states[data->freq_table[i].index].status &
62			+ INTEL_MSR_FID_MASK))
63			return data->freq_table[i].frequency;
64			}
65			return data->freq_table[0].frequency;
66			}
67
68			@@ -729,10 +743,12 @@
69			if (data) {
70			cpufreq_frequency_table_put_attr(policy->cpu);
71			per_cpu(drv_data, policy->cpu) = NULL;
72			acpi_processor_unregister_performance(data->acpi_data,
73			policy->cpu);
74			+ if (data->original_controls)
75			+ kfree(data->original_controls);
76			kfree(data);
77			}
78
79			return 0;
80			}
81			@@ -746,12 +762,452 @@
82			data->resume = 1;
83
84			return 0;
85			}
86
87			+
88			+
89			+
90			+/* sysfs interface to change operating points voltages */
91			+
92			+static unsigned int extract_fid_from_control(unsigned int control)
93			+{
94			+ return ((control & INTEL_MSR_FID_MASK) >> INTEL_MSR_FID_SHIFT);
95			+}
96			+
97			+static unsigned int extract_vid_from_control(unsigned int control)
98			+{
99			+ return (control & INTEL_MSR_VID_MASK);
100			+}
101			+
102			+static ssize_t check_origial_table (struct acpi_cpufreq_data *data)
103			+{
104			+ struct acpi_processor_performance *acpi_data;
105			+ struct cpufreq_frequency_table *freq_table;
106			+ unsigned int state_index;
107			+
108			+ acpi_data = data->acpi_data;
109			+ freq_table = data->freq_table;
110			+
111			+ if (data->original_controls == NULL) {
112			+ // Backup original control values
113			+ data->original_controls = kcalloc(acpi_data->state_count,
114			+ sizeof(acpi_integer), GFP_KERNEL);
115			+ if (data->original_controls == NULL) {
116			+ printk("failed to allocate memory for original control values\n");
117			+ return -ENOMEM;
118			+ }
119			+ for (state_index = 0; state_index < acpi_data->state_count; state_index++) {
120			+ data->original_controls[state_index] = acpi_data->states[state_index].control;
121			+ }
122			+ }
123			+ return 0;
124			+}
125			+
126			+static ssize_t show_freq_attr_vids(struct cpufreq_policy policy, char buf)
127			+{
128			+ struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
129			+ struct acpi_processor_performance *acpi_data;
130			+ struct cpufreq_frequency_table *freq_table;
131			+ unsigned int i;
132			+ unsigned int vid;
133			+ ssize_t count = 0;
134			+
135			+ if (unlikely(data == NULL \|\|
136			+ data->acpi_data == NULL \|\|
137			+ data->freq_table == NULL \|\|
138			+ data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
139			+ return -ENODEV;
140			+ }
141			+
142			+ acpi_data = data->acpi_data;
143			+ freq_table = data->freq_table;
144			+
145			+ for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
146			+ vid = extract_vid_from_control(acpi_data->states[freq_table[i].index].control);
147			+ count += sprintf(&buf[count], "%u ", vid);
148			+ }
149			+ count += sprintf(&buf[count], "\n");
150			+
151			+ return count;
152			+}
153			+
154			+static ssize_t show_freq_attr_default_vids(struct cpufreq_policy policy, char buf)
155			+{
156			+ struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
157			+ struct cpufreq_frequency_table *freq_table;
158			+ unsigned int i;
159			+ unsigned int vid;
160			+ ssize_t count = 0;
161			+ ssize_t retval;
162			+
163			+ if (unlikely(data == NULL \|\|
164			+ data->acpi_data == NULL \|\|
165			+ data->freq_table == NULL \|\|
166			+ data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
167			+ return -ENODEV;
168			+ }
169			+
170			+ retval = check_origial_table(data);
171			+ if (0 != retval)
172			+ return retval;
173			+
174			+ freq_table = data->freq_table;
175			+
176			+ for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
177			+ vid = extract_vid_from_control(data->original_controls[freq_table[i].index]);
178			+ count += sprintf(&buf[count], "%u ", vid);
179			+ }
180			+ count += sprintf(&buf[count], "\n");
181			+
182			+ return count;
183			+}
184			+
185			+static ssize_t show_freq_attr_fids(struct cpufreq_policy policy, char buf)
186			+{
187			+ struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
188			+ struct acpi_processor_performance *acpi_data;
189			+ struct cpufreq_frequency_table *freq_table;
190			+ unsigned int i;
191			+ unsigned int fid;
192			+ ssize_t count = 0;
193			+
194			+ if (unlikely(data == NULL \|\|
195			+ data->acpi_data == NULL \|\|
196			+ data->freq_table == NULL \|\|
197			+ data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
198			+ return -ENODEV;
199			+ }
200			+
201			+ acpi_data = data->acpi_data;
202			+ freq_table = data->freq_table;
203			+
204			+ for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
205			+ fid = extract_fid_from_control(acpi_data->states[freq_table[i].index].control);
206			+ count += sprintf(&buf[count], "%u ", fid);
207			+ }
208			+ count += sprintf(&buf[count], "\n");
209			+
210			+ return count;
211			+}
212			+
213			+static ssize_t show_freq_attr_controls(struct cpufreq_policy policy, char buf)
214			+{
215			+ struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
216			+ struct acpi_processor_performance *acpi_data;
217			+ struct cpufreq_frequency_table *freq_table;
218			+ unsigned int i;
219			+ unsigned int fid;
220			+ unsigned int vid;
221			+ ssize_t count = 0;
222			+
223			+ if (unlikely(data == NULL \|\|
224			+ data->acpi_data == NULL \|\|
225			+ data->freq_table == NULL \|\|
226			+ data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
227			+ return -ENODEV;
228			+ }
229			+
230			+ acpi_data = data->acpi_data;
231			+ freq_table = data->freq_table;
232			+
233			+ for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
234			+ fid = extract_fid_from_control(acpi_data->states[freq_table[i].index].control);
235			+ vid = extract_vid_from_control(acpi_data->states[freq_table[i].index].control);
236			+ count += sprintf(&buf[count], "%u:%u ", fid, vid);
237			+ }
238			+ count += sprintf(&buf[count], "\n");
239			+
240			+ return count;
241			+}
242			+
243			+static ssize_t show_freq_attr_default_controls(struct cpufreq_policy policy, char buf)
244			+{
245			+ struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
246			+ struct cpufreq_frequency_table *freq_table;
247			+ unsigned int i;
248			+ unsigned int fid;
249			+ unsigned int vid;
250			+ ssize_t count = 0;
251			+ ssize_t retval;
252			+
253			+ if (unlikely(data == NULL \|\|
254			+ data->acpi_data == NULL \|\|
255			+ data->freq_table == NULL \|\|
256			+ data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
257			+ return -ENODEV;
258			+ }
259			+
260			+ retval = check_origial_table(data);
261			+ if (0 != retval)
262			+ return retval;
263			+
264			+ freq_table = data->freq_table;
265			+
266			+ for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
267			+ fid = extract_fid_from_control(data->original_controls[freq_table[i].index]);
268			+ vid = extract_vid_from_control(data->original_controls[freq_table[i].index]);
269			+ count += sprintf(&buf[count], "%u:%u ", fid, vid);
270			+ }
271			+ count += sprintf(&buf[count], "\n");
272			+
273			+ return count;
274			+}
275			+
276			+
277			+static ssize_t store_freq_attr_vids(struct cpufreq_policy policy, const char buf, size_t count)
278			+{
279			+ struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
280			+ struct acpi_processor_performance *acpi_data;
281			+ struct cpufreq_frequency_table *freq_table;
282			+ unsigned int freq_index;
283			+ unsigned int state_index;
284			+ unsigned int new_vid;
285			+ unsigned int original_vid;
286			+ unsigned int new_control;
287			+ unsigned int original_control;
288			+ const char *curr_buf = buf;
289			+ char *next_buf;
290			+ ssize_t retval;
291			+
292			+ if (unlikely(data == NULL \|\|
293			+ data->acpi_data == NULL \|\|
294			+ data->freq_table == NULL \|\|
295			+ data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
296			+ return -ENODEV;
297			+ }
298			+
299			+ retval = check_origial_table(data);
300			+ if (0 != retval)
301			+ return retval;
302			+
303			+ acpi_data = data->acpi_data;
304			+ freq_table = data->freq_table;
305			+
306			+ for (freq_index = 0; freq_table[freq_index].frequency != CPUFREQ_TABLE_END; freq_index++) {
307			+ new_vid = simple_strtoul(curr_buf, &next_buf, 10);
308			+ if (next_buf == curr_buf) {
309			+ if ((curr_buf - buf == count - 1) && (*curr_buf == '\n')) {
310			+ curr_buf++;
311			+ break;
312			+ }
313			+ printk("failed to parse vid value at %i (%s)\n", freq_index, curr_buf);
314			+ return -EINVAL;
315			+ }
316			+
317			+ state_index = freq_table[freq_index].index;
318			+ original_control = data->original_controls[state_index];
319			+ original_vid = original_control & INTEL_MSR_VID_MASK;
320			+ if (new_vid <= original_vid) {
321			+ new_control = (original_control & ~INTEL_MSR_VID_MASK) \| new_vid;
322			+ dprintk("setting control at %i to %x (default is %x)\n",
323			+ freq_index, new_control, original_control);
324			+ acpi_data->states[state_index].control = new_control;
325			+
326			+ } else {
327			+ printk("skipping vid at %i, %u is greater than default %u\n",
328			+ freq_index, new_vid, original_vid);
329			+ }
330			+
331			+ curr_buf = next_buf;
332			+ while ((curr_buf - buf < count) && ((curr_buf == ' ') \|\| (curr_buf == ','))) {
333			+ curr_buf++;
334			+ }
335			+ }
336			+
337			+ /* set new voltage at current frequency */
338			+ data->resume = 1;
339			+ acpi_cpufreq_target(policy, get_cur_freq_on_cpu(policy->cpu), CPUFREQ_RELATION_L);
340			+
341			+ return curr_buf - buf;
342			+}
343			+
344			+static ssize_t store_freq_attr_controls(struct cpufreq_policy policy, const char buf, size_t count)
345			+{
346			+ struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
347			+ struct acpi_processor_performance *acpi_data;
348			+ struct cpufreq_frequency_table *freq_table;
349			+ const char *curr_buf;
350			+ unsigned int op_count;
351			+ unsigned int state_index;
352			+ int isok;
353			+ char *next_buf;
354			+ ssize_t retval;
355			+ unsigned int new_vid;
356			+ unsigned int original_vid;
357			+ unsigned int new_fid;
358			+ unsigned int old_fid;
359			+ unsigned int original_control;
360			+ unsigned int old_control;
361			+ unsigned int new_control;
362			+ int found;
363			+
364			+ if (unlikely(data == NULL \|\|
365			+ data->acpi_data == NULL \|\|
366			+ data->freq_table == NULL \|\|
367			+ data->cpu_feature != SYSTEM_INTEL_MSR_CAPABLE)) {
368			+ return -ENODEV;
369			+ }
370			+
371			+ retval = check_origial_table(data);
372			+ if (0 != retval)
373			+ return retval;
374			+
375			+ acpi_data = data->acpi_data;
376			+ freq_table = data->freq_table;
377			+
378			+ op_count = 0;
379			+ curr_buf = buf;
380			+ next_buf = NULL;
381			+ isok = 1;
382			+
383			+ while ( (isok) && (curr_buf != NULL) )
384			+ {
385			+ op_count++;
386			+ // Parse fid
387			+ new_fid = simple_strtoul(curr_buf, &next_buf, 10);
388			+ if ((next_buf != curr_buf) && (next_buf != NULL))
389			+ {
390			+ // Parse separator between frequency and voltage
391			+ curr_buf = next_buf;
392			+ next_buf = NULL;
393			+ if (*curr_buf==':')
394			+ {
395			+ curr_buf++;
396			+ // Parse vid
397			+ new_vid = simple_strtoul(curr_buf, &next_buf, 10);
398			+ if ((next_buf != curr_buf) && (next_buf != NULL))
399			+ {
400			+ found = 0;
401			+ for (state_index = 0; state_index < acpi_data->state_count; state_index++) {
402			+ old_control = acpi_data->states[state_index].control;
403			+ old_fid = extract_fid_from_control(old_control);
404			+ if (new_fid == old_fid)
405			+ {
406			+ found = 1;
407			+ original_control = data->original_controls[state_index];
408			+ original_vid = extract_vid_from_control(original_control);
409			+ if (new_vid <= original_vid)
410			+ {
411			+ new_control = (original_control & ~INTEL_MSR_VID_MASK) \| new_vid;
412			+ dprintk("setting control at %i to %x (default is %x)\n",
413			+ state_index, new_control, original_control);
414			+ acpi_data->states[state_index].control = new_control;
415			+
416			+ } else {
417			+ printk("skipping vid at %i, %u is greater than default %u\n",
418			+ state_index, new_vid, original_vid);
419			+ }
420			+ }
421			+ }
422			+
423			+ if (found == 0)
424			+ {
425			+ printk("operating point # %u not found (FID = %u)\n", op_count, new_fid);
426			+ isok = 0;
427			+ }
428			+
429			+ // Parse seprator before next operating point, if any
430			+ curr_buf = next_buf;
431			+ next_buf = NULL;
432			+ if ((curr_buf == ',') \|\| (curr_buf == ' '))
433			+ curr_buf++;
434			+ else
435			+ curr_buf = NULL;
436			+ }
437			+ else
438			+ {
439			+ printk("failed to parse VID of operating point # %u (%s)\n", op_count, curr_buf);
440			+ isok = 0;
441			+ }
442			+ }
443			+ else
444			+ {
445			+ printk("failed to parse operating point # %u (%s)\n", op_count, curr_buf);
446			+ isok = 0;
447			+ }
448			+ }
449			+ else
450			+ {
451			+ printk("failed to parse FID of operating point # %u (%s)\n", op_count, curr_buf);
452			+ isok = 0;
453			+ }
454			+ }
455			+
456			+ if (isok)
457			+ {
458			+ retval = count;
459			+ /* set new voltage at current frequency */
460			+ data->resume = 1;
461			+ acpi_cpufreq_target(policy, get_cur_freq_on_cpu(policy->cpu), CPUFREQ_RELATION_L);
462			+ }
463			+ else
464			+ {
465			+ retval = -EINVAL;
466			+ }
467			+
468			+ return retval;
469			+}
470			+
471			+static ssize_t show_freq_attr_phc_version(struct cpufreq_policy policy, char buf)
472			+{
473			+ ssize_t count = 0;
474			+ count += sprintf(&buf[count], "%s\n", PHC_VERSION_STRING);
475			+ return count;
476			+}
477			+
478			+static struct freq_attr cpufreq_freq_attr_phc_version =
479			+{
480			+ .attr = { .name = "phc_version", .mode = 0444, .owner = THIS_MODULE },
481			+ .show = show_freq_attr_phc_version,
482			+ .store = NULL,
483			+};
484			+
485			+static struct freq_attr cpufreq_freq_attr_vids =
486			+{
487			+ .attr = { .name = "phc_vids", .mode = 0644, .owner = THIS_MODULE },
488			+ .show = show_freq_attr_vids,
489			+ .store = store_freq_attr_vids,
490			+};
491			+
492			+static struct freq_attr cpufreq_freq_attr_default_vids =
493			+{
494			+ .attr = { .name = "phc_default_vids", .mode = 0444, .owner = THIS_MODULE },
495			+ .show = show_freq_attr_default_vids,
496			+ .store = NULL,
497			+};
498			+
499			+static struct freq_attr cpufreq_freq_attr_fids =
500			+{
501			+ .attr = { .name = "phc_fids", .mode = 0444, .owner = THIS_MODULE },
502			+ .show = show_freq_attr_fids,
503			+ .store = NULL,
504			+};
505			+
506			+static struct freq_attr cpufreq_freq_attr_controls =
507			+{
508			+ .attr = { .name = "phc_controls", .mode = 0644, .owner = THIS_MODULE },
509			+ .show = show_freq_attr_controls,
510			+ .store = store_freq_attr_controls,
511			+};
512			+
513			+static struct freq_attr cpufreq_freq_attr_default_controls =
514			+{
515			+ .attr = { .name = "phc_default_controls", .mode = 0444, .owner = THIS_MODULE },
516			+ .show = show_freq_attr_default_controls,
517			+ .store = NULL,
518			+};
519			+
520			+
521			static struct freq_attr *acpi_cpufreq_attr[] = {
522			+ &cpufreq_freq_attr_phc_version,
523			&cpufreq_freq_attr_scaling_available_freqs,
524			+ &cpufreq_freq_attr_vids,
525			+ &cpufreq_freq_attr_default_vids,
526			+ &cpufreq_freq_attr_fids,
527			+ &cpufreq_freq_attr_controls,
528			+ &cpufreq_freq_attr_default_controls,
529			NULL,
530			};
531
532			static struct cpufreq_driver acpi_cpufreq_driver = {
533			.verify = acpi_cpufreq_verify,