Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 2361be23666232dbb4851a527f466c4cbf5340fc

Authored by Viresh Kumar 2013-05-17 18:39:09 +0800

Committed by Rafael J. Wysocki 2013-05-27 19:24:02 +0800

Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch

cpufreq: Don't create empty /sys/devices/system/cpu/cpufreq directory

When we don't have any file in cpu/cpufreq directory we shouldn't
create it. Specially with the introduction of per-policy governor
instance patchset, even governors are moved to
cpu/cpu*/cpufreq/governor-name directory and so this directory is
just not required.

Lets have it only when required.

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

Showing 4 changed files with 56 additions and 6 deletions Inline Diff

drivers/cpufreq/acpi-cpufreq.c
drivers/cpufreq/cpufreq.c
drivers/cpufreq/cpufreq_governor.c
include/linux/cpufreq.h

drivers/cpufreq/acpi-cpufreq.c

Diff comments View file @ 2361be2

1	/*	1	/*
2	* acpi-cpufreq.c - ACPI Processor P-States Driver	2	* acpi-cpufreq.c - ACPI Processor P-States Driver
3	*	3	*
4	* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>	4	* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5	* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>	5	* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6	* Copyright (C) 2002 - 2004 Dominik Brodowski <linux@brodo.de>	6	* Copyright (C) 2002 - 2004 Dominik Brodowski <linux@brodo.de>
7	* Copyright (C) 2006 Denis Sadykov <denis.m.sadykov@intel.com>	7	* Copyright (C) 2006 Denis Sadykov <denis.m.sadykov@intel.com>
8	*	8	*
9	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	9	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10	*	10	*
11	* This program is free software; you can redistribute it and/or modify	11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by	12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or (at	13	* the Free Software Foundation; either version 2 of the License, or (at
14	* your option) any later version.	14	* your option) any later version.
15	*	15	*
16	* This program is distributed in the hope that it will be useful, but	16	* This program is distributed in the hope that it will be useful, but
17	* WITHOUT ANY WARRANTY; without even the implied warranty of	17	* WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19	* General Public License for more details.	19	* General Public License for more details.
20	*	20	*
21	* You should have received a copy of the GNU General Public License along	21	* You should have received a copy of the GNU General Public License along
22	* with this program; if not, write to the Free Software Foundation, Inc.,	22	* with this program; if not, write to the Free Software Foundation, Inc.,
23	* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.	23	* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
24	*	24	*
25	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	25	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26	*/	26	*/
27		27
28	#include <linux/kernel.h>	28	#include <linux/kernel.h>
29	#include <linux/module.h>	29	#include <linux/module.h>
30	#include <linux/init.h>	30	#include <linux/init.h>
31	#include <linux/smp.h>	31	#include <linux/smp.h>
32	#include <linux/sched.h>	32	#include <linux/sched.h>
33	#include <linux/cpufreq.h>	33	#include <linux/cpufreq.h>
34	#include <linux/compiler.h>	34	#include <linux/compiler.h>
35	#include <linux/dmi.h>	35	#include <linux/dmi.h>
36	#include <linux/slab.h>	36	#include <linux/slab.h>
37		37
38	#include <linux/acpi.h>	38	#include <linux/acpi.h>
39	#include <linux/io.h>	39	#include <linux/io.h>
40	#include <linux/delay.h>	40	#include <linux/delay.h>
41	#include <linux/uaccess.h>	41	#include <linux/uaccess.h>
42		42
43	#include <acpi/processor.h>	43	#include <acpi/processor.h>
44		44
45	#include <asm/msr.h>	45	#include <asm/msr.h>
46	#include <asm/processor.h>	46	#include <asm/processor.h>
47	#include <asm/cpufeature.h>	47	#include <asm/cpufeature.h>
48	#include "mperf.h"	48	#include "mperf.h"
49		49
50	MODULE_AUTHOR("Paul Diefenbaugh, Dominik Brodowski");	50	MODULE_AUTHOR("Paul Diefenbaugh, Dominik Brodowski");
51	MODULE_DESCRIPTION("ACPI Processor P-States Driver");	51	MODULE_DESCRIPTION("ACPI Processor P-States Driver");
52	MODULE_LICENSE("GPL");	52	MODULE_LICENSE("GPL");
53		53
54	#define PFX "acpi-cpufreq: "	54	#define PFX "acpi-cpufreq: "
55		55
56	enum {	56	enum {
57	UNDEFINED_CAPABLE = 0,	57	UNDEFINED_CAPABLE = 0,
58	SYSTEM_INTEL_MSR_CAPABLE,	58	SYSTEM_INTEL_MSR_CAPABLE,
59	SYSTEM_AMD_MSR_CAPABLE,	59	SYSTEM_AMD_MSR_CAPABLE,
60	SYSTEM_IO_CAPABLE,	60	SYSTEM_IO_CAPABLE,
61	};	61	};
62		62
63	#define INTEL_MSR_RANGE (0xffff)	63	#define INTEL_MSR_RANGE (0xffff)
64	#define AMD_MSR_RANGE (0x7)	64	#define AMD_MSR_RANGE (0x7)
65		65
66	#define MSR_K7_HWCR_CPB_DIS (1ULL << 25)	66	#define MSR_K7_HWCR_CPB_DIS (1ULL << 25)
67		67
68	struct acpi_cpufreq_data {	68	struct acpi_cpufreq_data {
69	struct acpi_processor_performance *acpi_data;	69	struct acpi_processor_performance *acpi_data;
70	struct cpufreq_frequency_table *freq_table;	70	struct cpufreq_frequency_table *freq_table;
71	unsigned int resume;	71	unsigned int resume;
72	unsigned int cpu_feature;	72	unsigned int cpu_feature;
73	};	73	};
74		74
75	static DEFINE_PER_CPU(struct acpi_cpufreq_data *, acfreq_data);	75	static DEFINE_PER_CPU(struct acpi_cpufreq_data *, acfreq_data);
76		76
77	/* acpi_perf_data is a pointer to percpu data. */	77	/* acpi_perf_data is a pointer to percpu data. */
78	static struct acpi_processor_performance __percpu *acpi_perf_data;	78	static struct acpi_processor_performance __percpu *acpi_perf_data;
79		79
80	static struct cpufreq_driver acpi_cpufreq_driver;	80	static struct cpufreq_driver acpi_cpufreq_driver;
81		81
82	static unsigned int acpi_pstate_strict;	82	static unsigned int acpi_pstate_strict;
83	static bool boost_enabled, boost_supported;	83	static bool boost_enabled, boost_supported;
84	static struct msr __percpu *msrs;	84	static struct msr __percpu *msrs;
85		85
86	static bool boost_state(unsigned int cpu)	86	static bool boost_state(unsigned int cpu)
87	{	87	{
88	u32 lo, hi;	88	u32 lo, hi;
89	u64 msr;	89	u64 msr;
90		90
91	switch (boot_cpu_data.x86_vendor) {	91	switch (boot_cpu_data.x86_vendor) {
92	case X86_VENDOR_INTEL:	92	case X86_VENDOR_INTEL:
93	rdmsr_on_cpu(cpu, MSR_IA32_MISC_ENABLE, &lo, &hi);	93	rdmsr_on_cpu(cpu, MSR_IA32_MISC_ENABLE, &lo, &hi);
94	msr = lo \| ((u64)hi << 32);	94	msr = lo \| ((u64)hi << 32);
95	return !(msr & MSR_IA32_MISC_ENABLE_TURBO_DISABLE);	95	return !(msr & MSR_IA32_MISC_ENABLE_TURBO_DISABLE);
96	case X86_VENDOR_AMD:	96	case X86_VENDOR_AMD:
97	rdmsr_on_cpu(cpu, MSR_K7_HWCR, &lo, &hi);	97	rdmsr_on_cpu(cpu, MSR_K7_HWCR, &lo, &hi);
98	msr = lo \| ((u64)hi << 32);	98	msr = lo \| ((u64)hi << 32);
99	return !(msr & MSR_K7_HWCR_CPB_DIS);	99	return !(msr & MSR_K7_HWCR_CPB_DIS);
100	}	100	}
101	return false;	101	return false;
102	}	102	}
103		103
104	static void boost_set_msrs(bool enable, const struct cpumask *cpumask)	104	static void boost_set_msrs(bool enable, const struct cpumask *cpumask)
105	{	105	{
106	u32 cpu;	106	u32 cpu;
107	u32 msr_addr;	107	u32 msr_addr;
108	u64 msr_mask;	108	u64 msr_mask;
109		109
110	switch (boot_cpu_data.x86_vendor) {	110	switch (boot_cpu_data.x86_vendor) {
111	case X86_VENDOR_INTEL:	111	case X86_VENDOR_INTEL:
112	msr_addr = MSR_IA32_MISC_ENABLE;	112	msr_addr = MSR_IA32_MISC_ENABLE;
113	msr_mask = MSR_IA32_MISC_ENABLE_TURBO_DISABLE;	113	msr_mask = MSR_IA32_MISC_ENABLE_TURBO_DISABLE;
114	break;	114	break;
115	case X86_VENDOR_AMD:	115	case X86_VENDOR_AMD:
116	msr_addr = MSR_K7_HWCR;	116	msr_addr = MSR_K7_HWCR;
117	msr_mask = MSR_K7_HWCR_CPB_DIS;	117	msr_mask = MSR_K7_HWCR_CPB_DIS;
118	break;	118	break;
119	default:	119	default:
120	return;	120	return;
121	}	121	}
122		122
123	rdmsr_on_cpus(cpumask, msr_addr, msrs);	123	rdmsr_on_cpus(cpumask, msr_addr, msrs);
124		124
125	for_each_cpu(cpu, cpumask) {	125	for_each_cpu(cpu, cpumask) {
126	struct msr *reg = per_cpu_ptr(msrs, cpu);	126	struct msr *reg = per_cpu_ptr(msrs, cpu);
127	if (enable)	127	if (enable)
128	reg->q &= ~msr_mask;	128	reg->q &= ~msr_mask;
129	else	129	else
130	reg->q \|= msr_mask;	130	reg->q \|= msr_mask;
131	}	131	}
132		132
133	wrmsr_on_cpus(cpumask, msr_addr, msrs);	133	wrmsr_on_cpus(cpumask, msr_addr, msrs);
134	}	134	}
135		135
136	static ssize_t _store_boost(const char *buf, size_t count)	136	static ssize_t _store_boost(const char *buf, size_t count)
137	{	137	{
138	int ret;	138	int ret;
139	unsigned long val = 0;	139	unsigned long val = 0;
140		140
141	if (!boost_supported)	141	if (!boost_supported)
142	return -EINVAL;	142	return -EINVAL;
143		143
144	ret = kstrtoul(buf, 10, &val);	144	ret = kstrtoul(buf, 10, &val);
145	if (ret \|\| (val > 1))	145	if (ret \|\| (val > 1))
146	return -EINVAL;	146	return -EINVAL;
147		147
148	if ((val && boost_enabled) \|\| (!val && !boost_enabled))	148	if ((val && boost_enabled) \|\| (!val && !boost_enabled))
149	return count;	149	return count;
150		150
151	get_online_cpus();	151	get_online_cpus();
152		152
153	boost_set_msrs(val, cpu_online_mask);	153	boost_set_msrs(val, cpu_online_mask);
154		154
155	put_online_cpus();	155	put_online_cpus();
156		156
157	boost_enabled = val;	157	boost_enabled = val;
158	pr_debug("Core Boosting %sabled.\n", val ? "en" : "dis");	158	pr_debug("Core Boosting %sabled.\n", val ? "en" : "dis");
159		159
160	return count;	160	return count;
161	}	161	}
162		162
163	static ssize_t store_global_boost(struct kobject kobj, struct attribute attr,	163	static ssize_t store_global_boost(struct kobject kobj, struct attribute attr,
164	const char *buf, size_t count)	164	const char *buf, size_t count)
165	{	165	{
166	return _store_boost(buf, count);	166	return _store_boost(buf, count);
167	}	167	}
168		168
169	static ssize_t show_global_boost(struct kobject *kobj,	169	static ssize_t show_global_boost(struct kobject *kobj,
170	struct attribute attr, char buf)	170	struct attribute attr, char buf)
171	{	171	{
172	return sprintf(buf, "%u\n", boost_enabled);	172	return sprintf(buf, "%u\n", boost_enabled);
173	}	173	}
174		174
175	static struct global_attr global_boost = __ATTR(boost, 0644,	175	static struct global_attr global_boost = __ATTR(boost, 0644,
176	show_global_boost,	176	show_global_boost,
177	store_global_boost);	177	store_global_boost);
178		178
179	#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB	179	#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
180	static ssize_t store_cpb(struct cpufreq_policy policy, const char buf,	180	static ssize_t store_cpb(struct cpufreq_policy policy, const char buf,
181	size_t count)	181	size_t count)
182	{	182	{
183	return _store_boost(buf, count);	183	return _store_boost(buf, count);
184	}	184	}
185		185
186	static ssize_t show_cpb(struct cpufreq_policy policy, char buf)	186	static ssize_t show_cpb(struct cpufreq_policy policy, char buf)
187	{	187	{
188	return sprintf(buf, "%u\n", boost_enabled);	188	return sprintf(buf, "%u\n", boost_enabled);
189	}	189	}
190		190
191	static struct freq_attr cpb = __ATTR(cpb, 0644, show_cpb, store_cpb);	191	static struct freq_attr cpb = __ATTR(cpb, 0644, show_cpb, store_cpb);
192	#endif	192	#endif
193		193
194	static int check_est_cpu(unsigned int cpuid)	194	static int check_est_cpu(unsigned int cpuid)
195	{	195	{
196	struct cpuinfo_x86 *cpu = &cpu_data(cpuid);	196	struct cpuinfo_x86 *cpu = &cpu_data(cpuid);
197		197
198	return cpu_has(cpu, X86_FEATURE_EST);	198	return cpu_has(cpu, X86_FEATURE_EST);
199	}	199	}
200		200
201	static int check_amd_hwpstate_cpu(unsigned int cpuid)	201	static int check_amd_hwpstate_cpu(unsigned int cpuid)
202	{	202	{
203	struct cpuinfo_x86 *cpu = &cpu_data(cpuid);	203	struct cpuinfo_x86 *cpu = &cpu_data(cpuid);
204		204
205	return cpu_has(cpu, X86_FEATURE_HW_PSTATE);	205	return cpu_has(cpu, X86_FEATURE_HW_PSTATE);
206	}	206	}
207		207
208	static unsigned extract_io(u32 value, struct acpi_cpufreq_data *data)	208	static unsigned extract_io(u32 value, struct acpi_cpufreq_data *data)
209	{	209	{
210	struct acpi_processor_performance *perf;	210	struct acpi_processor_performance *perf;
211	int i;	211	int i;
212		212
213	perf = data->acpi_data;	213	perf = data->acpi_data;
214		214
215	for (i = 0; i < perf->state_count; i++) {	215	for (i = 0; i < perf->state_count; i++) {
216	if (value == perf->states[i].status)	216	if (value == perf->states[i].status)
217	return data->freq_table[i].frequency;	217	return data->freq_table[i].frequency;
218	}	218	}
219	return 0;	219	return 0;
220	}	220	}
221		221
222	static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)	222	static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
223	{	223	{
224	int i;	224	int i;
225	struct acpi_processor_performance *perf;	225	struct acpi_processor_performance *perf;
226		226
227	if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)	227	if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
228	msr &= AMD_MSR_RANGE;	228	msr &= AMD_MSR_RANGE;
229	else	229	else
230	msr &= INTEL_MSR_RANGE;	230	msr &= INTEL_MSR_RANGE;
231		231
232	perf = data->acpi_data;	232	perf = data->acpi_data;
233		233
234	for (i = 0; data->freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {	234	for (i = 0; data->freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
235	if (msr == perf->states[data->freq_table[i].index].status)	235	if (msr == perf->states[data->freq_table[i].index].status)
236	return data->freq_table[i].frequency;	236	return data->freq_table[i].frequency;
237	}	237	}
238	return data->freq_table[0].frequency;	238	return data->freq_table[0].frequency;
239	}	239	}
240		240
241	static unsigned extract_freq(u32 val, struct acpi_cpufreq_data *data)	241	static unsigned extract_freq(u32 val, struct acpi_cpufreq_data *data)
242	{	242	{
243	switch (data->cpu_feature) {	243	switch (data->cpu_feature) {
244	case SYSTEM_INTEL_MSR_CAPABLE:	244	case SYSTEM_INTEL_MSR_CAPABLE:
245	case SYSTEM_AMD_MSR_CAPABLE:	245	case SYSTEM_AMD_MSR_CAPABLE:
246	return extract_msr(val, data);	246	return extract_msr(val, data);
247	case SYSTEM_IO_CAPABLE:	247	case SYSTEM_IO_CAPABLE:
248	return extract_io(val, data);	248	return extract_io(val, data);
249	default:	249	default:
250	return 0;	250	return 0;
251	}	251	}
252	}	252	}
253		253
254	struct msr_addr {	254	struct msr_addr {
255	u32 reg;	255	u32 reg;
256	};	256	};
257		257
258	struct io_addr {	258	struct io_addr {
259	u16 port;	259	u16 port;
260	u8 bit_width;	260	u8 bit_width;
261	};	261	};
262		262
263	struct drv_cmd {	263	struct drv_cmd {
264	unsigned int type;	264	unsigned int type;
265	const struct cpumask *mask;	265	const struct cpumask *mask;
266	union {	266	union {
267	struct msr_addr msr;	267	struct msr_addr msr;
268	struct io_addr io;	268	struct io_addr io;
269	} addr;	269	} addr;
270	u32 val;	270	u32 val;
271	};	271	};
272		272
273	/* Called via smp_call_function_single(), on the target CPU */	273	/* Called via smp_call_function_single(), on the target CPU */
274	static void do_drv_read(void *_cmd)	274	static void do_drv_read(void *_cmd)
275	{	275	{
276	struct drv_cmd *cmd = _cmd;	276	struct drv_cmd *cmd = _cmd;
277	u32 h;	277	u32 h;
278		278
279	switch (cmd->type) {	279	switch (cmd->type) {
280	case SYSTEM_INTEL_MSR_CAPABLE:	280	case SYSTEM_INTEL_MSR_CAPABLE:
281	case SYSTEM_AMD_MSR_CAPABLE:	281	case SYSTEM_AMD_MSR_CAPABLE:
282	rdmsr(cmd->addr.msr.reg, cmd->val, h);	282	rdmsr(cmd->addr.msr.reg, cmd->val, h);
283	break;	283	break;
284	case SYSTEM_IO_CAPABLE:	284	case SYSTEM_IO_CAPABLE:
285	acpi_os_read_port((acpi_io_address)cmd->addr.io.port,	285	acpi_os_read_port((acpi_io_address)cmd->addr.io.port,
286	&cmd->val,	286	&cmd->val,
287	(u32)cmd->addr.io.bit_width);	287	(u32)cmd->addr.io.bit_width);
288	break;	288	break;
289	default:	289	default:
290	break;	290	break;
291	}	291	}
292	}	292	}
293		293
294	/* Called via smp_call_function_many(), on the target CPUs */	294	/* Called via smp_call_function_many(), on the target CPUs */
295	static void do_drv_write(void *_cmd)	295	static void do_drv_write(void *_cmd)
296	{	296	{
297	struct drv_cmd *cmd = _cmd;	297	struct drv_cmd *cmd = _cmd;
298	u32 lo, hi;	298	u32 lo, hi;
299		299
300	switch (cmd->type) {	300	switch (cmd->type) {
301	case SYSTEM_INTEL_MSR_CAPABLE:	301	case SYSTEM_INTEL_MSR_CAPABLE:
302	rdmsr(cmd->addr.msr.reg, lo, hi);	302	rdmsr(cmd->addr.msr.reg, lo, hi);
303	lo = (lo & ~INTEL_MSR_RANGE) \| (cmd->val & INTEL_MSR_RANGE);	303	lo = (lo & ~INTEL_MSR_RANGE) \| (cmd->val & INTEL_MSR_RANGE);
304	wrmsr(cmd->addr.msr.reg, lo, hi);	304	wrmsr(cmd->addr.msr.reg, lo, hi);
305	break;	305	break;
306	case SYSTEM_AMD_MSR_CAPABLE:	306	case SYSTEM_AMD_MSR_CAPABLE:
307	wrmsr(cmd->addr.msr.reg, cmd->val, 0);	307	wrmsr(cmd->addr.msr.reg, cmd->val, 0);
308	break;	308	break;
309	case SYSTEM_IO_CAPABLE:	309	case SYSTEM_IO_CAPABLE:
310	acpi_os_write_port((acpi_io_address)cmd->addr.io.port,	310	acpi_os_write_port((acpi_io_address)cmd->addr.io.port,
311	cmd->val,	311	cmd->val,
312	(u32)cmd->addr.io.bit_width);	312	(u32)cmd->addr.io.bit_width);
313	break;	313	break;
314	default:	314	default:
315	break;	315	break;
316	}	316	}
317	}	317	}
318		318
319	static void drv_read(struct drv_cmd *cmd)	319	static void drv_read(struct drv_cmd *cmd)
320	{	320	{
321	int err;	321	int err;
322	cmd->val = 0;	322	cmd->val = 0;
323		323
324	err = smp_call_function_any(cmd->mask, do_drv_read, cmd, 1);	324	err = smp_call_function_any(cmd->mask, do_drv_read, cmd, 1);
325	WARN_ON_ONCE(err); /* smp_call_function_any() was buggy? */	325	WARN_ON_ONCE(err); /* smp_call_function_any() was buggy? */
326	}	326	}
327		327
328	static void drv_write(struct drv_cmd *cmd)	328	static void drv_write(struct drv_cmd *cmd)
329	{	329	{
330	int this_cpu;	330	int this_cpu;
331		331
332	this_cpu = get_cpu();	332	this_cpu = get_cpu();
333	if (cpumask_test_cpu(this_cpu, cmd->mask))	333	if (cpumask_test_cpu(this_cpu, cmd->mask))
334	do_drv_write(cmd);	334	do_drv_write(cmd);
335	smp_call_function_many(cmd->mask, do_drv_write, cmd, 1);	335	smp_call_function_many(cmd->mask, do_drv_write, cmd, 1);
336	put_cpu();	336	put_cpu();
337	}	337	}
338		338
339	static u32 get_cur_val(const struct cpumask *mask)	339	static u32 get_cur_val(const struct cpumask *mask)
340	{	340	{
341	struct acpi_processor_performance *perf;	341	struct acpi_processor_performance *perf;
342	struct drv_cmd cmd;	342	struct drv_cmd cmd;
343		343
344	if (unlikely(cpumask_empty(mask)))	344	if (unlikely(cpumask_empty(mask)))
345	return 0;	345	return 0;
346		346
347	switch (per_cpu(acfreq_data, cpumask_first(mask))->cpu_feature) {	347	switch (per_cpu(acfreq_data, cpumask_first(mask))->cpu_feature) {
348	case SYSTEM_INTEL_MSR_CAPABLE:	348	case SYSTEM_INTEL_MSR_CAPABLE:
349	cmd.type = SYSTEM_INTEL_MSR_CAPABLE;	349	cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
350	cmd.addr.msr.reg = MSR_IA32_PERF_STATUS;	350	cmd.addr.msr.reg = MSR_IA32_PERF_STATUS;
351	break;	351	break;
352	case SYSTEM_AMD_MSR_CAPABLE:	352	case SYSTEM_AMD_MSR_CAPABLE:
353	cmd.type = SYSTEM_AMD_MSR_CAPABLE;	353	cmd.type = SYSTEM_AMD_MSR_CAPABLE;
354	cmd.addr.msr.reg = MSR_AMD_PERF_STATUS;	354	cmd.addr.msr.reg = MSR_AMD_PERF_STATUS;
355	break;	355	break;
356	case SYSTEM_IO_CAPABLE:	356	case SYSTEM_IO_CAPABLE:
357	cmd.type = SYSTEM_IO_CAPABLE;	357	cmd.type = SYSTEM_IO_CAPABLE;
358	perf = per_cpu(acfreq_data, cpumask_first(mask))->acpi_data;	358	perf = per_cpu(acfreq_data, cpumask_first(mask))->acpi_data;
359	cmd.addr.io.port = perf->control_register.address;	359	cmd.addr.io.port = perf->control_register.address;
360	cmd.addr.io.bit_width = perf->control_register.bit_width;	360	cmd.addr.io.bit_width = perf->control_register.bit_width;
361	break;	361	break;
362	default:	362	default:
363	return 0;	363	return 0;
364	}	364	}
365		365
366	cmd.mask = mask;	366	cmd.mask = mask;
367	drv_read(&cmd);	367	drv_read(&cmd);
368		368
369	pr_debug("get_cur_val = %u\n", cmd.val);	369	pr_debug("get_cur_val = %u\n", cmd.val);
370		370
371	return cmd.val;	371	return cmd.val;
372	}	372	}
373		373
374	static unsigned int get_cur_freq_on_cpu(unsigned int cpu)	374	static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
375	{	375	{
376	struct acpi_cpufreq_data *data = per_cpu(acfreq_data, cpu);	376	struct acpi_cpufreq_data *data = per_cpu(acfreq_data, cpu);
377	unsigned int freq;	377	unsigned int freq;
378	unsigned int cached_freq;	378	unsigned int cached_freq;
379		379
380	pr_debug("get_cur_freq_on_cpu (%d)\n", cpu);	380	pr_debug("get_cur_freq_on_cpu (%d)\n", cpu);
381		381
382	if (unlikely(data == NULL \|\|	382	if (unlikely(data == NULL \|\|
383	data->acpi_data == NULL \|\| data->freq_table == NULL)) {	383	data->acpi_data == NULL \|\| data->freq_table == NULL)) {
384	return 0;	384	return 0;
385	}	385	}
386		386
387	cached_freq = data->freq_table[data->acpi_data->state].frequency;	387	cached_freq = data->freq_table[data->acpi_data->state].frequency;
388	freq = extract_freq(get_cur_val(cpumask_of(cpu)), data);	388	freq = extract_freq(get_cur_val(cpumask_of(cpu)), data);
389	if (freq != cached_freq) {	389	if (freq != cached_freq) {
390	/*	390	/*
391	* The dreaded BIOS frequency change behind our back.	391	* The dreaded BIOS frequency change behind our back.
392	* Force set the frequency on next target call.	392	* Force set the frequency on next target call.
393	*/	393	*/
394	data->resume = 1;	394	data->resume = 1;
395	}	395	}
396		396
397	pr_debug("cur freq = %u\n", freq);	397	pr_debug("cur freq = %u\n", freq);
398		398
399	return freq;	399	return freq;
400	}	400	}
401		401
402	static unsigned int check_freqs(const struct cpumask *mask, unsigned int freq,	402	static unsigned int check_freqs(const struct cpumask *mask, unsigned int freq,
403	struct acpi_cpufreq_data *data)	403	struct acpi_cpufreq_data *data)
404	{	404	{
405	unsigned int cur_freq;	405	unsigned int cur_freq;
406	unsigned int i;	406	unsigned int i;
407		407
408	for (i = 0; i < 100; i++) {	408	for (i = 0; i < 100; i++) {
409	cur_freq = extract_freq(get_cur_val(mask), data);	409	cur_freq = extract_freq(get_cur_val(mask), data);
410	if (cur_freq == freq)	410	if (cur_freq == freq)
411	return 1;	411	return 1;
412	udelay(10);	412	udelay(10);
413	}	413	}
414	return 0;	414	return 0;
415	}	415	}
416		416
417	static int acpi_cpufreq_target(struct cpufreq_policy *policy,	417	static int acpi_cpufreq_target(struct cpufreq_policy *policy,
418	unsigned int target_freq, unsigned int relation)	418	unsigned int target_freq, unsigned int relation)
419	{	419	{
420	struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);	420	struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);
421	struct acpi_processor_performance *perf;	421	struct acpi_processor_performance *perf;
422	struct cpufreq_freqs freqs;	422	struct cpufreq_freqs freqs;
423	struct drv_cmd cmd;	423	struct drv_cmd cmd;
424	unsigned int next_state = 0; /* Index into freq_table */	424	unsigned int next_state = 0; /* Index into freq_table */
425	unsigned int next_perf_state = 0; /* Index into perf table */	425	unsigned int next_perf_state = 0; /* Index into perf table */
426	int result = 0;	426	int result = 0;
427		427
428	pr_debug("acpi_cpufreq_target %d (%d)\n", target_freq, policy->cpu);	428	pr_debug("acpi_cpufreq_target %d (%d)\n", target_freq, policy->cpu);
429		429
430	if (unlikely(data == NULL \|\|	430	if (unlikely(data == NULL \|\|
431	data->acpi_data == NULL \|\| data->freq_table == NULL)) {	431	data->acpi_data == NULL \|\| data->freq_table == NULL)) {
432	return -ENODEV;	432	return -ENODEV;
433	}	433	}
434		434
435	perf = data->acpi_data;	435	perf = data->acpi_data;
436	result = cpufreq_frequency_table_target(policy,	436	result = cpufreq_frequency_table_target(policy,
437	data->freq_table,	437	data->freq_table,
438	target_freq,	438	target_freq,
439	relation, &next_state);	439	relation, &next_state);
440	if (unlikely(result)) {	440	if (unlikely(result)) {
441	result = -ENODEV;	441	result = -ENODEV;
442	goto out;	442	goto out;
443	}	443	}
444		444
445	next_perf_state = data->freq_table[next_state].index;	445	next_perf_state = data->freq_table[next_state].index;
446	if (perf->state == next_perf_state) {	446	if (perf->state == next_perf_state) {
447	if (unlikely(data->resume)) {	447	if (unlikely(data->resume)) {
448	pr_debug("Called after resume, resetting to P%d\n",	448	pr_debug("Called after resume, resetting to P%d\n",
449	next_perf_state);	449	next_perf_state);
450	data->resume = 0;	450	data->resume = 0;
451	} else {	451	} else {
452	pr_debug("Already at target state (P%d)\n",	452	pr_debug("Already at target state (P%d)\n",
453	next_perf_state);	453	next_perf_state);
454	goto out;	454	goto out;
455	}	455	}
456	}	456	}
457		457
458	switch (data->cpu_feature) {	458	switch (data->cpu_feature) {
459	case SYSTEM_INTEL_MSR_CAPABLE:	459	case SYSTEM_INTEL_MSR_CAPABLE:
460	cmd.type = SYSTEM_INTEL_MSR_CAPABLE;	460	cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
461	cmd.addr.msr.reg = MSR_IA32_PERF_CTL;	461	cmd.addr.msr.reg = MSR_IA32_PERF_CTL;
462	cmd.val = (u32) perf->states[next_perf_state].control;	462	cmd.val = (u32) perf->states[next_perf_state].control;
463	break;	463	break;
464	case SYSTEM_AMD_MSR_CAPABLE:	464	case SYSTEM_AMD_MSR_CAPABLE:
465	cmd.type = SYSTEM_AMD_MSR_CAPABLE;	465	cmd.type = SYSTEM_AMD_MSR_CAPABLE;
466	cmd.addr.msr.reg = MSR_AMD_PERF_CTL;	466	cmd.addr.msr.reg = MSR_AMD_PERF_CTL;
467	cmd.val = (u32) perf->states[next_perf_state].control;	467	cmd.val = (u32) perf->states[next_perf_state].control;
468	break;	468	break;
469	case SYSTEM_IO_CAPABLE:	469	case SYSTEM_IO_CAPABLE:
470	cmd.type = SYSTEM_IO_CAPABLE;	470	cmd.type = SYSTEM_IO_CAPABLE;
471	cmd.addr.io.port = perf->control_register.address;	471	cmd.addr.io.port = perf->control_register.address;
472	cmd.addr.io.bit_width = perf->control_register.bit_width;	472	cmd.addr.io.bit_width = perf->control_register.bit_width;
473	cmd.val = (u32) perf->states[next_perf_state].control;	473	cmd.val = (u32) perf->states[next_perf_state].control;
474	break;	474	break;
475	default:	475	default:
476	result = -ENODEV;	476	result = -ENODEV;
477	goto out;	477	goto out;
478	}	478	}
479		479
480	/* cpufreq holds the hotplug lock, so we are safe from here on */	480	/* cpufreq holds the hotplug lock, so we are safe from here on */
481	if (policy->shared_type != CPUFREQ_SHARED_TYPE_ANY)	481	if (policy->shared_type != CPUFREQ_SHARED_TYPE_ANY)
482	cmd.mask = policy->cpus;	482	cmd.mask = policy->cpus;
483	else	483	else
484	cmd.mask = cpumask_of(policy->cpu);	484	cmd.mask = cpumask_of(policy->cpu);
485		485
486	freqs.old = perf->states[perf->state].core_frequency * 1000;	486	freqs.old = perf->states[perf->state].core_frequency * 1000;
487	freqs.new = data->freq_table[next_state].frequency;	487	freqs.new = data->freq_table[next_state].frequency;
488	cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);	488	cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
489		489
490	drv_write(&cmd);	490	drv_write(&cmd);
491		491
492	if (acpi_pstate_strict) {	492	if (acpi_pstate_strict) {
493	if (!check_freqs(cmd.mask, freqs.new, data)) {	493	if (!check_freqs(cmd.mask, freqs.new, data)) {
494	pr_debug("acpi_cpufreq_target failed (%d)\n",	494	pr_debug("acpi_cpufreq_target failed (%d)\n",
495	policy->cpu);	495	policy->cpu);
496	result = -EAGAIN;	496	result = -EAGAIN;
497	goto out;	497	goto out;
498	}	498	}
499	}	499	}
500		500
501	cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);	501	cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
502	perf->state = next_perf_state;	502	perf->state = next_perf_state;
503		503
504	out:	504	out:
505	return result;	505	return result;
506	}	506	}
507		507
508	static int acpi_cpufreq_verify(struct cpufreq_policy *policy)	508	static int acpi_cpufreq_verify(struct cpufreq_policy *policy)
509	{	509	{
510	struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);	510	struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);
511		511
512	pr_debug("acpi_cpufreq_verify\n");	512	pr_debug("acpi_cpufreq_verify\n");
513		513
514	return cpufreq_frequency_table_verify(policy, data->freq_table);	514	return cpufreq_frequency_table_verify(policy, data->freq_table);
515	}	515	}
516		516
517	static unsigned long	517	static unsigned long
518	acpi_cpufreq_guess_freq(struct acpi_cpufreq_data *data, unsigned int cpu)	518	acpi_cpufreq_guess_freq(struct acpi_cpufreq_data *data, unsigned int cpu)
519	{	519	{
520	struct acpi_processor_performance *perf = data->acpi_data;	520	struct acpi_processor_performance *perf = data->acpi_data;
521		521
522	if (cpu_khz) {	522	if (cpu_khz) {
523	/* search the closest match to cpu_khz */	523	/* search the closest match to cpu_khz */
524	unsigned int i;	524	unsigned int i;
525	unsigned long freq;	525	unsigned long freq;
526	unsigned long freqn = perf->states[0].core_frequency * 1000;	526	unsigned long freqn = perf->states[0].core_frequency * 1000;
527		527
528	for (i = 0; i < (perf->state_count-1); i++) {	528	for (i = 0; i < (perf->state_count-1); i++) {
529	freq = freqn;	529	freq = freqn;
530	freqn = perf->states[i+1].core_frequency * 1000;	530	freqn = perf->states[i+1].core_frequency * 1000;
531	if ((2 * cpu_khz) > (freqn + freq)) {	531	if ((2 * cpu_khz) > (freqn + freq)) {
532	perf->state = i;	532	perf->state = i;
533	return freq;	533	return freq;
534	}	534	}
535	}	535	}
536	perf->state = perf->state_count-1;	536	perf->state = perf->state_count-1;
537	return freqn;	537	return freqn;
538	} else {	538	} else {
539	/* assume CPU is at P0... */	539	/* assume CPU is at P0... */
540	perf->state = 0;	540	perf->state = 0;
541	return perf->states[0].core_frequency * 1000;	541	return perf->states[0].core_frequency * 1000;
542	}	542	}
543	}	543	}
544		544
545	static void free_acpi_perf_data(void)	545	static void free_acpi_perf_data(void)
546	{	546	{
547	unsigned int i;	547	unsigned int i;
548		548
549	/* Freeing a NULL pointer is OK, and alloc_percpu zeroes. */	549	/* Freeing a NULL pointer is OK, and alloc_percpu zeroes. */
550	for_each_possible_cpu(i)	550	for_each_possible_cpu(i)
551	free_cpumask_var(per_cpu_ptr(acpi_perf_data, i)	551	free_cpumask_var(per_cpu_ptr(acpi_perf_data, i)
552	->shared_cpu_map);	552	->shared_cpu_map);
553	free_percpu(acpi_perf_data);	553	free_percpu(acpi_perf_data);
554	}	554	}
555		555
556	static int boost_notify(struct notifier_block *nb, unsigned long action,	556	static int boost_notify(struct notifier_block *nb, unsigned long action,
557	void *hcpu)	557	void *hcpu)
558	{	558	{
559	unsigned cpu = (long)hcpu;	559	unsigned cpu = (long)hcpu;
560	const struct cpumask *cpumask;	560	const struct cpumask *cpumask;
561		561
562	cpumask = get_cpu_mask(cpu);	562	cpumask = get_cpu_mask(cpu);
563		563
564	/*	564	/*
565	* Clear the boost-disable bit on the CPU_DOWN path so that	565	* Clear the boost-disable bit on the CPU_DOWN path so that
566	* this cpu cannot block the remaining ones from boosting. On	566	* this cpu cannot block the remaining ones from boosting. On
567	* the CPU_UP path we simply keep the boost-disable flag in	567	* the CPU_UP path we simply keep the boost-disable flag in
568	* sync with the current global state.	568	* sync with the current global state.
569	*/	569	*/
570		570
571	switch (action) {	571	switch (action) {
572	case CPU_UP_PREPARE:	572	case CPU_UP_PREPARE:
573	case CPU_UP_PREPARE_FROZEN:	573	case CPU_UP_PREPARE_FROZEN:
574	boost_set_msrs(boost_enabled, cpumask);	574	boost_set_msrs(boost_enabled, cpumask);
575	break;	575	break;
576		576
577	case CPU_DOWN_PREPARE:	577	case CPU_DOWN_PREPARE:
578	case CPU_DOWN_PREPARE_FROZEN:	578	case CPU_DOWN_PREPARE_FROZEN:
579	boost_set_msrs(1, cpumask);	579	boost_set_msrs(1, cpumask);
580	break;	580	break;
581		581
582	default:	582	default:
583	break;	583	break;
584	}	584	}
585		585
586	return NOTIFY_OK;	586	return NOTIFY_OK;
587	}	587	}
588		588
589		589
590	static struct notifier_block boost_nb = {	590	static struct notifier_block boost_nb = {
591	.notifier_call = boost_notify,	591	.notifier_call = boost_notify,
592	};	592	};
593		593
594	/*	594	/*
595	* acpi_cpufreq_early_init - initialize ACPI P-States library	595	* acpi_cpufreq_early_init - initialize ACPI P-States library
596	*	596	*
597	* Initialize the ACPI P-States library (drivers/acpi/processor_perflib.c)	597	* Initialize the ACPI P-States library (drivers/acpi/processor_perflib.c)
598	* in order to determine correct frequency and voltage pairings. We can	598	* in order to determine correct frequency and voltage pairings. We can
599	* do _PDC and _PSD and find out the processor dependency for the	599	* do _PDC and _PSD and find out the processor dependency for the
600	* actual init that will happen later...	600	* actual init that will happen later...
601	*/	601	*/
602	static int __init acpi_cpufreq_early_init(void)	602	static int __init acpi_cpufreq_early_init(void)
603	{	603	{
604	unsigned int i;	604	unsigned int i;
605	pr_debug("acpi_cpufreq_early_init\n");	605	pr_debug("acpi_cpufreq_early_init\n");
606		606
607	acpi_perf_data = alloc_percpu(struct acpi_processor_performance);	607	acpi_perf_data = alloc_percpu(struct acpi_processor_performance);
608	if (!acpi_perf_data) {	608	if (!acpi_perf_data) {
609	pr_debug("Memory allocation error for acpi_perf_data.\n");	609	pr_debug("Memory allocation error for acpi_perf_data.\n");
610	return -ENOMEM;	610	return -ENOMEM;
611	}	611	}
612	for_each_possible_cpu(i) {	612	for_each_possible_cpu(i) {
613	if (!zalloc_cpumask_var_node(	613	if (!zalloc_cpumask_var_node(
614	&per_cpu_ptr(acpi_perf_data, i)->shared_cpu_map,	614	&per_cpu_ptr(acpi_perf_data, i)->shared_cpu_map,
615	GFP_KERNEL, cpu_to_node(i))) {	615	GFP_KERNEL, cpu_to_node(i))) {
616		616
617	/* Freeing a NULL pointer is OK: alloc_percpu zeroes. */	617	/* Freeing a NULL pointer is OK: alloc_percpu zeroes. */
618	free_acpi_perf_data();	618	free_acpi_perf_data();
619	return -ENOMEM;	619	return -ENOMEM;
620	}	620	}
621	}	621	}
622		622
623	/* Do initialization in ACPI core */	623	/* Do initialization in ACPI core */
624	acpi_processor_preregister_performance(acpi_perf_data);	624	acpi_processor_preregister_performance(acpi_perf_data);
625	return 0;	625	return 0;
626	}	626	}
627		627
628	#ifdef CONFIG_SMP	628	#ifdef CONFIG_SMP
629	/*	629	/*
630	* Some BIOSes do SW_ANY coordination internally, either set it up in hw	630	* Some BIOSes do SW_ANY coordination internally, either set it up in hw
631	* or do it in BIOS firmware and won't inform about it to OS. If not	631	* or do it in BIOS firmware and won't inform about it to OS. If not
632	* detected, this has a side effect of making CPU run at a different speed	632	* detected, this has a side effect of making CPU run at a different speed
633	* than OS intended it to run at. Detect it and handle it cleanly.	633	* than OS intended it to run at. Detect it and handle it cleanly.
634	*/	634	*/
635	static int bios_with_sw_any_bug;	635	static int bios_with_sw_any_bug;
636		636
637	static int sw_any_bug_found(const struct dmi_system_id *d)	637	static int sw_any_bug_found(const struct dmi_system_id *d)
638	{	638	{
639	bios_with_sw_any_bug = 1;	639	bios_with_sw_any_bug = 1;
640	return 0;	640	return 0;
641	}	641	}
642		642
643	static const struct dmi_system_id sw_any_bug_dmi_table[] = {	643	static const struct dmi_system_id sw_any_bug_dmi_table[] = {
644	{	644	{
645	.callback = sw_any_bug_found,	645	.callback = sw_any_bug_found,
646	.ident = "Supermicro Server X6DLP",	646	.ident = "Supermicro Server X6DLP",
647	.matches = {	647	.matches = {
648	DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),	648	DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
649	DMI_MATCH(DMI_BIOS_VERSION, "080010"),	649	DMI_MATCH(DMI_BIOS_VERSION, "080010"),
650	DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"),	650	DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"),
651	},	651	},
652	},	652	},
653	{ }	653	{ }
654	};	654	};
655		655
656	static int acpi_cpufreq_blacklist(struct cpuinfo_x86 *c)	656	static int acpi_cpufreq_blacklist(struct cpuinfo_x86 *c)
657	{	657	{
658	/* Intel Xeon Processor 7100 Series Specification Update	658	/* Intel Xeon Processor 7100 Series Specification Update
659	* http://www.intel.com/Assets/PDF/specupdate/314554.pdf	659	* http://www.intel.com/Assets/PDF/specupdate/314554.pdf
660	* AL30: A Machine Check Exception (MCE) Occurring during an	660	* AL30: A Machine Check Exception (MCE) Occurring during an
661	* Enhanced Intel SpeedStep Technology Ratio Change May Cause	661	* Enhanced Intel SpeedStep Technology Ratio Change May Cause
662	* Both Processor Cores to Lock Up. */	662	* Both Processor Cores to Lock Up. */
663	if (c->x86_vendor == X86_VENDOR_INTEL) {	663	if (c->x86_vendor == X86_VENDOR_INTEL) {
664	if ((c->x86 == 15) &&	664	if ((c->x86 == 15) &&
665	(c->x86_model == 6) &&	665	(c->x86_model == 6) &&
666	(c->x86_mask == 8)) {	666	(c->x86_mask == 8)) {
667	printk(KERN_INFO "acpi-cpufreq: Intel(R) "	667	printk(KERN_INFO "acpi-cpufreq: Intel(R) "
668	"Xeon(R) 7100 Errata AL30, processors may "	668	"Xeon(R) 7100 Errata AL30, processors may "
669	"lock up on frequency changes: disabling "	669	"lock up on frequency changes: disabling "
670	"acpi-cpufreq.\n");	670	"acpi-cpufreq.\n");
671	return -ENODEV;	671	return -ENODEV;
672	}	672	}
673	}	673	}
674	return 0;	674	return 0;
675	}	675	}
676	#endif	676	#endif
677		677
678	static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)	678	static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
679	{	679	{
680	unsigned int i;	680	unsigned int i;
681	unsigned int valid_states = 0;	681	unsigned int valid_states = 0;
682	unsigned int cpu = policy->cpu;	682	unsigned int cpu = policy->cpu;
683	struct acpi_cpufreq_data *data;	683	struct acpi_cpufreq_data *data;
684	unsigned int result = 0;	684	unsigned int result = 0;
685	struct cpuinfo_x86 *c = &cpu_data(policy->cpu);	685	struct cpuinfo_x86 *c = &cpu_data(policy->cpu);
686	struct acpi_processor_performance *perf;	686	struct acpi_processor_performance *perf;
687	#ifdef CONFIG_SMP	687	#ifdef CONFIG_SMP
688	static int blacklisted;	688	static int blacklisted;
689	#endif	689	#endif
690		690
691	pr_debug("acpi_cpufreq_cpu_init\n");	691	pr_debug("acpi_cpufreq_cpu_init\n");
692		692
693	#ifdef CONFIG_SMP	693	#ifdef CONFIG_SMP
694	if (blacklisted)	694	if (blacklisted)
695	return blacklisted;	695	return blacklisted;
696	blacklisted = acpi_cpufreq_blacklist(c);	696	blacklisted = acpi_cpufreq_blacklist(c);
697	if (blacklisted)	697	if (blacklisted)
698	return blacklisted;	698	return blacklisted;
699	#endif	699	#endif
700		700
701	data = kzalloc(sizeof(struct acpi_cpufreq_data), GFP_KERNEL);	701	data = kzalloc(sizeof(struct acpi_cpufreq_data), GFP_KERNEL);
702	if (!data)	702	if (!data)
703	return -ENOMEM;	703	return -ENOMEM;
704		704
705	data->acpi_data = per_cpu_ptr(acpi_perf_data, cpu);	705	data->acpi_data = per_cpu_ptr(acpi_perf_data, cpu);
706	per_cpu(acfreq_data, cpu) = data;	706	per_cpu(acfreq_data, cpu) = data;
707		707
708	if (cpu_has(c, X86_FEATURE_CONSTANT_TSC))	708	if (cpu_has(c, X86_FEATURE_CONSTANT_TSC))
709	acpi_cpufreq_driver.flags \|= CPUFREQ_CONST_LOOPS;	709	acpi_cpufreq_driver.flags \|= CPUFREQ_CONST_LOOPS;
710		710
711	result = acpi_processor_register_performance(data->acpi_data, cpu);	711	result = acpi_processor_register_performance(data->acpi_data, cpu);
712	if (result)	712	if (result)
713	goto err_free;	713	goto err_free;
714		714
715	perf = data->acpi_data;	715	perf = data->acpi_data;
716	policy->shared_type = perf->shared_type;	716	policy->shared_type = perf->shared_type;
717		717
718	/*	718	/*
719	* Will let policy->cpus know about dependency only when software	719	* Will let policy->cpus know about dependency only when software
720	* coordination is required.	720	* coordination is required.
721	*/	721	*/
722	if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL \|\|	722	if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL \|\|
723	policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {	723	policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
724	cpumask_copy(policy->cpus, perf->shared_cpu_map);	724	cpumask_copy(policy->cpus, perf->shared_cpu_map);
725	}	725	}
726		726
727	#ifdef CONFIG_SMP	727	#ifdef CONFIG_SMP
728	dmi_check_system(sw_any_bug_dmi_table);	728	dmi_check_system(sw_any_bug_dmi_table);
729	if (bios_with_sw_any_bug && !policy_is_shared(policy)) {	729	if (bios_with_sw_any_bug && !policy_is_shared(policy)) {
730	policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;	730	policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
731	cpumask_copy(policy->cpus, cpu_core_mask(cpu));	731	cpumask_copy(policy->cpus, cpu_core_mask(cpu));
732	}	732	}
733		733
734	if (check_amd_hwpstate_cpu(cpu) && !acpi_pstate_strict) {	734	if (check_amd_hwpstate_cpu(cpu) && !acpi_pstate_strict) {
735	cpumask_clear(policy->cpus);	735	cpumask_clear(policy->cpus);
736	cpumask_set_cpu(cpu, policy->cpus);	736	cpumask_set_cpu(cpu, policy->cpus);
737	policy->shared_type = CPUFREQ_SHARED_TYPE_HW;	737	policy->shared_type = CPUFREQ_SHARED_TYPE_HW;
738	pr_info_once(PFX "overriding BIOS provided _PSD data\n");	738	pr_info_once(PFX "overriding BIOS provided _PSD data\n");
739	}	739	}
740	#endif	740	#endif
741		741
742	/* capability check */	742	/* capability check */
743	if (perf->state_count <= 1) {	743	if (perf->state_count <= 1) {
744	pr_debug("No P-States\n");	744	pr_debug("No P-States\n");
745	result = -ENODEV;	745	result = -ENODEV;
746	goto err_unreg;	746	goto err_unreg;
747	}	747	}
748		748
749	if (perf->control_register.space_id != perf->status_register.space_id) {	749	if (perf->control_register.space_id != perf->status_register.space_id) {
750	result = -ENODEV;	750	result = -ENODEV;
751	goto err_unreg;	751	goto err_unreg;
752	}	752	}
753		753
754	switch (perf->control_register.space_id) {	754	switch (perf->control_register.space_id) {
755	case ACPI_ADR_SPACE_SYSTEM_IO:	755	case ACPI_ADR_SPACE_SYSTEM_IO:
756	if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&	756	if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
757	boot_cpu_data.x86 == 0xf) {	757	boot_cpu_data.x86 == 0xf) {
758	pr_debug("AMD K8 systems must use native drivers.\n");	758	pr_debug("AMD K8 systems must use native drivers.\n");
759	result = -ENODEV;	759	result = -ENODEV;
760	goto err_unreg;	760	goto err_unreg;
761	}	761	}
762	pr_debug("SYSTEM IO addr space\n");	762	pr_debug("SYSTEM IO addr space\n");
763	data->cpu_feature = SYSTEM_IO_CAPABLE;	763	data->cpu_feature = SYSTEM_IO_CAPABLE;
764	break;	764	break;
765	case ACPI_ADR_SPACE_FIXED_HARDWARE:	765	case ACPI_ADR_SPACE_FIXED_HARDWARE:
766	pr_debug("HARDWARE addr space\n");	766	pr_debug("HARDWARE addr space\n");
767	if (check_est_cpu(cpu)) {	767	if (check_est_cpu(cpu)) {
768	data->cpu_feature = SYSTEM_INTEL_MSR_CAPABLE;	768	data->cpu_feature = SYSTEM_INTEL_MSR_CAPABLE;
769	break;	769	break;
770	}	770	}
771	if (check_amd_hwpstate_cpu(cpu)) {	771	if (check_amd_hwpstate_cpu(cpu)) {
772	data->cpu_feature = SYSTEM_AMD_MSR_CAPABLE;	772	data->cpu_feature = SYSTEM_AMD_MSR_CAPABLE;
773	break;	773	break;
774	}	774	}
775	result = -ENODEV;	775	result = -ENODEV;
776	goto err_unreg;	776	goto err_unreg;
777	default:	777	default:
778	pr_debug("Unknown addr space %d\n",	778	pr_debug("Unknown addr space %d\n",
779	(u32) (perf->control_register.space_id));	779	(u32) (perf->control_register.space_id));
780	result = -ENODEV;	780	result = -ENODEV;
781	goto err_unreg;	781	goto err_unreg;
782	}	782	}
783		783
784	data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) *	784	data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) *
785	(perf->state_count+1), GFP_KERNEL);	785	(perf->state_count+1), GFP_KERNEL);
786	if (!data->freq_table) {	786	if (!data->freq_table) {
787	result = -ENOMEM;	787	result = -ENOMEM;
788	goto err_unreg;	788	goto err_unreg;
789	}	789	}
790		790
791	/* detect transition latency */	791	/* detect transition latency */
792	policy->cpuinfo.transition_latency = 0;	792	policy->cpuinfo.transition_latency = 0;
793	for (i = 0; i < perf->state_count; i++) {	793	for (i = 0; i < perf->state_count; i++) {
794	if ((perf->states[i].transition_latency * 1000) >	794	if ((perf->states[i].transition_latency * 1000) >
795	policy->cpuinfo.transition_latency)	795	policy->cpuinfo.transition_latency)
796	policy->cpuinfo.transition_latency =	796	policy->cpuinfo.transition_latency =
797	perf->states[i].transition_latency * 1000;	797	perf->states[i].transition_latency * 1000;
798	}	798	}
799		799
800	/* Check for high latency (>20uS) from buggy BIOSes, like on T42 */	800	/* Check for high latency (>20uS) from buggy BIOSes, like on T42 */
801	if (perf->control_register.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE &&	801	if (perf->control_register.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE &&
802	policy->cpuinfo.transition_latency > 20 * 1000) {	802	policy->cpuinfo.transition_latency > 20 * 1000) {
803	policy->cpuinfo.transition_latency = 20 * 1000;	803	policy->cpuinfo.transition_latency = 20 * 1000;
804	printk_once(KERN_INFO	804	printk_once(KERN_INFO
805	"P-state transition latency capped at 20 uS\n");	805	"P-state transition latency capped at 20 uS\n");
806	}	806	}
807		807
808	/* table init */	808	/* table init */
809	for (i = 0; i < perf->state_count; i++) {	809	for (i = 0; i < perf->state_count; i++) {
810	if (i > 0 && perf->states[i].core_frequency >=	810	if (i > 0 && perf->states[i].core_frequency >=
811	data->freq_table[valid_states-1].frequency / 1000)	811	data->freq_table[valid_states-1].frequency / 1000)
812	continue;	812	continue;
813		813
814	data->freq_table[valid_states].index = i;	814	data->freq_table[valid_states].index = i;
815	data->freq_table[valid_states].frequency =	815	data->freq_table[valid_states].frequency =
816	perf->states[i].core_frequency * 1000;	816	perf->states[i].core_frequency * 1000;
817	valid_states++;	817	valid_states++;
818	}	818	}
819	data->freq_table[valid_states].frequency = CPUFREQ_TABLE_END;	819	data->freq_table[valid_states].frequency = CPUFREQ_TABLE_END;
820	perf->state = 0;	820	perf->state = 0;
821		821
822	result = cpufreq_frequency_table_cpuinfo(policy, data->freq_table);	822	result = cpufreq_frequency_table_cpuinfo(policy, data->freq_table);
823	if (result)	823	if (result)
824	goto err_freqfree;	824	goto err_freqfree;
825		825
826	if (perf->states[0].core_frequency * 1000 != policy->cpuinfo.max_freq)	826	if (perf->states[0].core_frequency * 1000 != policy->cpuinfo.max_freq)
827	printk(KERN_WARNING FW_WARN "P-state 0 is not max freq\n");	827	printk(KERN_WARNING FW_WARN "P-state 0 is not max freq\n");
828		828
829	switch (perf->control_register.space_id) {	829	switch (perf->control_register.space_id) {
830	case ACPI_ADR_SPACE_SYSTEM_IO:	830	case ACPI_ADR_SPACE_SYSTEM_IO:
831	/* Current speed is unknown and not detectable by IO port */	831	/* Current speed is unknown and not detectable by IO port */
832	policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);	832	policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);
833	break;	833	break;
834	case ACPI_ADR_SPACE_FIXED_HARDWARE:	834	case ACPI_ADR_SPACE_FIXED_HARDWARE:
835	acpi_cpufreq_driver.get = get_cur_freq_on_cpu;	835	acpi_cpufreq_driver.get = get_cur_freq_on_cpu;
836	policy->cur = get_cur_freq_on_cpu(cpu);	836	policy->cur = get_cur_freq_on_cpu(cpu);
837	break;	837	break;
838	default:	838	default:
839	break;	839	break;
840	}	840	}
841		841
842	/* notify BIOS that we exist */	842	/* notify BIOS that we exist */
843	acpi_processor_notify_smm(THIS_MODULE);	843	acpi_processor_notify_smm(THIS_MODULE);
844		844
845	/* Check for APERF/MPERF support in hardware */	845	/* Check for APERF/MPERF support in hardware */
846	if (boot_cpu_has(X86_FEATURE_APERFMPERF))	846	if (boot_cpu_has(X86_FEATURE_APERFMPERF))
847	acpi_cpufreq_driver.getavg = cpufreq_get_measured_perf;	847	acpi_cpufreq_driver.getavg = cpufreq_get_measured_perf;
848		848
849	pr_debug("CPU%u - ACPI performance management activated.\n", cpu);	849	pr_debug("CPU%u - ACPI performance management activated.\n", cpu);
850	for (i = 0; i < perf->state_count; i++)	850	for (i = 0; i < perf->state_count; i++)
851	pr_debug(" %cP%d: %d MHz, %d mW, %d uS\n",	851	pr_debug(" %cP%d: %d MHz, %d mW, %d uS\n",
852	(i == perf->state ? '*' : ' '), i,	852	(i == perf->state ? '*' : ' '), i,
853	(u32) perf->states[i].core_frequency,	853	(u32) perf->states[i].core_frequency,
854	(u32) perf->states[i].power,	854	(u32) perf->states[i].power,
855	(u32) perf->states[i].transition_latency);	855	(u32) perf->states[i].transition_latency);
856		856
857	cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu);	857	cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu);
858		858
859	/*	859	/*
860	* the first call to ->target() should result in us actually	860	* the first call to ->target() should result in us actually
861	* writing something to the appropriate registers.	861	* writing something to the appropriate registers.
862	*/	862	*/
863	data->resume = 1;	863	data->resume = 1;
864		864
865	return result;	865	return result;
866		866
867	err_freqfree:	867	err_freqfree:
868	kfree(data->freq_table);	868	kfree(data->freq_table);
869	err_unreg:	869	err_unreg:
870	acpi_processor_unregister_performance(perf, cpu);	870	acpi_processor_unregister_performance(perf, cpu);
871	err_free:	871	err_free:
872	kfree(data);	872	kfree(data);
873	per_cpu(acfreq_data, cpu) = NULL;	873	per_cpu(acfreq_data, cpu) = NULL;
874		874
875	return result;	875	return result;
876	}	876	}
877		877
878	static int acpi_cpufreq_cpu_exit(struct cpufreq_policy *policy)	878	static int acpi_cpufreq_cpu_exit(struct cpufreq_policy *policy)
879	{	879	{
880	struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);	880	struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);
881		881
882	pr_debug("acpi_cpufreq_cpu_exit\n");	882	pr_debug("acpi_cpufreq_cpu_exit\n");
883		883
884	if (data) {	884	if (data) {
885	cpufreq_frequency_table_put_attr(policy->cpu);	885	cpufreq_frequency_table_put_attr(policy->cpu);
886	per_cpu(acfreq_data, policy->cpu) = NULL;	886	per_cpu(acfreq_data, policy->cpu) = NULL;
887	acpi_processor_unregister_performance(data->acpi_data,	887	acpi_processor_unregister_performance(data->acpi_data,
888	policy->cpu);	888	policy->cpu);
889	kfree(data->freq_table);	889	kfree(data->freq_table);
890	kfree(data);	890	kfree(data);
891	}	891	}
892		892
893	return 0;	893	return 0;
894	}	894	}
895		895
896	static int acpi_cpufreq_resume(struct cpufreq_policy *policy)	896	static int acpi_cpufreq_resume(struct cpufreq_policy *policy)
897	{	897	{
898	struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);	898	struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);
899		899
900	pr_debug("acpi_cpufreq_resume\n");	900	pr_debug("acpi_cpufreq_resume\n");
901		901
902	data->resume = 1;	902	data->resume = 1;
903		903
904	return 0;	904	return 0;
905	}	905	}
906		906
907	static struct freq_attr *acpi_cpufreq_attr[] = {	907	static struct freq_attr *acpi_cpufreq_attr[] = {
908	&cpufreq_freq_attr_scaling_available_freqs,	908	&cpufreq_freq_attr_scaling_available_freqs,
909	NULL, /* this is a placeholder for cpb, do not remove */	909	NULL, /* this is a placeholder for cpb, do not remove */
910	NULL,	910	NULL,
911	};	911	};
912		912
913	static struct cpufreq_driver acpi_cpufreq_driver = {	913	static struct cpufreq_driver acpi_cpufreq_driver = {
914	.verify = acpi_cpufreq_verify,	914	.verify = acpi_cpufreq_verify,
915	.target = acpi_cpufreq_target,	915	.target = acpi_cpufreq_target,
916	.bios_limit = acpi_processor_get_bios_limit,	916	.bios_limit = acpi_processor_get_bios_limit,
917	.init = acpi_cpufreq_cpu_init,	917	.init = acpi_cpufreq_cpu_init,
918	.exit = acpi_cpufreq_cpu_exit,	918	.exit = acpi_cpufreq_cpu_exit,
919	.resume = acpi_cpufreq_resume,	919	.resume = acpi_cpufreq_resume,
920	.name = "acpi-cpufreq",	920	.name = "acpi-cpufreq",
921	.owner = THIS_MODULE,	921	.owner = THIS_MODULE,
922	.attr = acpi_cpufreq_attr,	922	.attr = acpi_cpufreq_attr,
923	};	923	};
924		924
925	static void __init acpi_cpufreq_boost_init(void)	925	static void __init acpi_cpufreq_boost_init(void)
926	{	926	{
927	if (boot_cpu_has(X86_FEATURE_CPB) \|\| boot_cpu_has(X86_FEATURE_IDA)) {	927	if (boot_cpu_has(X86_FEATURE_CPB) \|\| boot_cpu_has(X86_FEATURE_IDA)) {
928	msrs = msrs_alloc();	928	msrs = msrs_alloc();
929		929
930	if (!msrs)	930	if (!msrs)
931	return;	931	return;
932		932
933	boost_supported = true;	933	boost_supported = true;
934	boost_enabled = boost_state(0);	934	boost_enabled = boost_state(0);
935		935
936	get_online_cpus();	936	get_online_cpus();
937		937
938	/* Force all MSRs to the same value */	938	/* Force all MSRs to the same value */
939	boost_set_msrs(boost_enabled, cpu_online_mask);	939	boost_set_msrs(boost_enabled, cpu_online_mask);
940		940
941	register_cpu_notifier(&boost_nb);	941	register_cpu_notifier(&boost_nb);
942		942
943	put_online_cpus();	943	put_online_cpus();
944	} else	944	} else
945	global_boost.attr.mode = 0444;	945	global_boost.attr.mode = 0444;
946		946
947	/* We create the boost file in any case, though for systems without	947	/* We create the boost file in any case, though for systems without
948	* hardware support it will be read-only and hardwired to return 0.	948	* hardware support it will be read-only and hardwired to return 0.
949	*/	949	*/
950	if (sysfs_create_file(cpufreq_global_kobject, &(global_boost.attr)))	950	if (cpufreq_sysfs_create_file(&(global_boost.attr)))
951	pr_warn(PFX "could not register global boost sysfs file\n");	951	pr_warn(PFX "could not register global boost sysfs file\n");
952	else	952	else
953	pr_debug("registered global boost sysfs file\n");	953	pr_debug("registered global boost sysfs file\n");
954	}	954	}
955		955
956	static void __exit acpi_cpufreq_boost_exit(void)	956	static void __exit acpi_cpufreq_boost_exit(void)
957	{	957	{
958	sysfs_remove_file(cpufreq_global_kobject, &(global_boost.attr));	958	cpufreq_sysfs_remove_file(&(global_boost.attr));
959		959
960	if (msrs) {	960	if (msrs) {
961	unregister_cpu_notifier(&boost_nb);	961	unregister_cpu_notifier(&boost_nb);
962		962
963	msrs_free(msrs);	963	msrs_free(msrs);
964	msrs = NULL;	964	msrs = NULL;
965	}	965	}
966	}	966	}
967		967
968	static int __init acpi_cpufreq_init(void)	968	static int __init acpi_cpufreq_init(void)
969	{	969	{
970	int ret;	970	int ret;
971		971
972	if (acpi_disabled)	972	if (acpi_disabled)
973	return 0;	973	return 0;
974		974
975	pr_debug("acpi_cpufreq_init\n");	975	pr_debug("acpi_cpufreq_init\n");
976		976
977	ret = acpi_cpufreq_early_init();	977	ret = acpi_cpufreq_early_init();
978	if (ret)	978	if (ret)
979	return ret;	979	return ret;
980		980
981	#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB	981	#ifdef CONFIG_X86_ACPI_CPUFREQ_CPB
982	/* this is a sysfs file with a strange name and an even stranger	982	/* this is a sysfs file with a strange name and an even stranger
983	* semantic - per CPU instantiation, but system global effect.	983	* semantic - per CPU instantiation, but system global effect.
984	* Lets enable it only on AMD CPUs for compatibility reasons and	984	* Lets enable it only on AMD CPUs for compatibility reasons and
985	* only if configured. This is considered legacy code, which	985	* only if configured. This is considered legacy code, which
986	* will probably be removed at some point in the future.	986	* will probably be removed at some point in the future.
987	*/	987	*/
988	if (check_amd_hwpstate_cpu(0)) {	988	if (check_amd_hwpstate_cpu(0)) {
989	struct freq_attr **iter;	989	struct freq_attr **iter;
990		990
991	pr_debug("adding sysfs entry for cpb\n");	991	pr_debug("adding sysfs entry for cpb\n");
992		992
993	for (iter = acpi_cpufreq_attr; *iter != NULL; iter++)	993	for (iter = acpi_cpufreq_attr; *iter != NULL; iter++)
994	;	994	;
995		995
996	/* make sure there is a terminator behind it */	996	/* make sure there is a terminator behind it */
997	if (iter[1] == NULL)	997	if (iter[1] == NULL)
998	*iter = &cpb;	998	*iter = &cpb;
999	}	999	}
1000	#endif	1000	#endif
1001		1001
1002	ret = cpufreq_register_driver(&acpi_cpufreq_driver);	1002	ret = cpufreq_register_driver(&acpi_cpufreq_driver);
1003	if (ret)	1003	if (ret)
1004	free_acpi_perf_data();	1004	free_acpi_perf_data();
1005	else	1005	else
1006	acpi_cpufreq_boost_init();	1006	acpi_cpufreq_boost_init();
1007		1007
1008	return ret;	1008	return ret;
1009	}	1009	}
1010		1010
1011	static void __exit acpi_cpufreq_exit(void)	1011	static void __exit acpi_cpufreq_exit(void)
1012	{	1012	{
1013	pr_debug("acpi_cpufreq_exit\n");	1013	pr_debug("acpi_cpufreq_exit\n");
1014		1014
1015	acpi_cpufreq_boost_exit();	1015	acpi_cpufreq_boost_exit();
1016		1016
1017	cpufreq_unregister_driver(&acpi_cpufreq_driver);	1017	cpufreq_unregister_driver(&acpi_cpufreq_driver);
1018		1018
1019	free_acpi_perf_data();	1019	free_acpi_perf_data();
1020	}	1020	}
1021		1021
1022	module_param(acpi_pstate_strict, uint, 0644);	1022	module_param(acpi_pstate_strict, uint, 0644);
1023	MODULE_PARM_DESC(acpi_pstate_strict,	1023	MODULE_PARM_DESC(acpi_pstate_strict,
1024	"value 0 or non-zero. non-zero -> strict ACPI checks are "	1024	"value 0 or non-zero. non-zero -> strict ACPI checks are "
1025	"performed during frequency changes.");	1025	"performed during frequency changes.");
1026		1026
1027	late_initcall(acpi_cpufreq_init);	1027	late_initcall(acpi_cpufreq_init);
1028	module_exit(acpi_cpufreq_exit);	1028	module_exit(acpi_cpufreq_exit);
1029		1029
1030	static const struct x86_cpu_id acpi_cpufreq_ids[] = {	1030	static const struct x86_cpu_id acpi_cpufreq_ids[] = {
1031	X86_FEATURE_MATCH(X86_FEATURE_ACPI),	1031	X86_FEATURE_MATCH(X86_FEATURE_ACPI),
1032	X86_FEATURE_MATCH(X86_FEATURE_HW_PSTATE),	1032	X86_FEATURE_MATCH(X86_FEATURE_HW_PSTATE),
1033	{}	1033	{}
1034	};	1034	};
1035	MODULE_DEVICE_TABLE(x86cpu, acpi_cpufreq_ids);	1035	MODULE_DEVICE_TABLE(x86cpu, acpi_cpufreq_ids);
1036		1036
1037	MODULE_ALIAS("acpi");	1037	MODULE_ALIAS("acpi");
1038		1038

drivers/cpufreq/cpufreq.c

Diff comments View file @ 2361be2

 /*
  *  linux/drivers/cpufreq/cpufreq.c
  *
  *  Copyright (C) 2001 Russell King
  *            (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
  *
  *  Oct 2005 - Ashok Raj <ashok.raj@intel.com>
  *	Added handling for CPU hotplug
  *  Feb 2006 - Jacob Shin <jacob.shin@amd.com>
  *	Fix handling for CPU hotplug -- affected CPUs
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <asm/cputime.h>
 #include <linux/kernel.h>
 #include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/notifier.h>
 #include <linux/cpufreq.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/tick.h>
 #include <linux/device.h>
 #include <linux/slab.h>
 #include <linux/cpu.h>
 #include <linux/completion.h>
 #include <linux/mutex.h>
 #include <linux/syscore_ops.h>
 #include <trace/events/power.h>
 /**
  * The "cpufreq driver" - the arch- or hardware-dependent low
  * level driver of CPUFreq support, and its spinlock. This lock
  * also protects the cpufreq_cpu_data array.
  */
 static struct cpufreq_driver *cpufreq_driver;
 static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
 #ifdef CONFIG_HOTPLUG_CPU
 /* This one keeps track of the previously set governor of a removed CPU */
 static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], cpufreq_cpu_governor);
 #endif
 static DEFINE_RWLOCK(cpufreq_driver_lock);
 /*
  * cpu_policy_rwsem is a per CPU reader-writer semaphore designed to cure
  * all cpufreq/hotplug/workqueue/etc related lock issues.
  *
  * The rules for this semaphore:
  * - Any routine that wants to read from the policy structure will
  *   do a down_read on this semaphore.
  * - Any routine that will write to the policy structure and/or may take away
  *   the policy altogether (eg. CPU hotplug), will hold this lock in write
  *   mode before doing so.
  *
  * Additional rules:
  * - Governor routines that can be called in cpufreq hotplug path should not
  *   take this sem as top level hotplug notifier handler takes this.
  * - Lock should not be held across
  *     __cpufreq_governor(data, CPUFREQ_GOV_STOP);
  */
 static DEFINE_PER_CPU(int, cpufreq_policy_cpu);
 static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
 #define lock_policy_rwsem(mode, cpu)					\
 static int lock_policy_rwsem_##mode(int cpu)				\
 {									\
 	int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);		\
 	BUG_ON(policy_cpu == -1);					\
 	down_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu));		\
 									\
 	return 0;							\
 }
 lock_policy_rwsem(read, cpu);
 lock_policy_rwsem(write, cpu);
 #define unlock_policy_rwsem(mode, cpu)					\
 static void unlock_policy_rwsem_##mode(int cpu)				\
 {									\
 	int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);		\
 	BUG_ON(policy_cpu == -1);					\
 	up_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu));		\
 }
 unlock_policy_rwsem(read, cpu);
 unlock_policy_rwsem(write, cpu);
 /* internal prototypes */
 static int __cpufreq_governor(struct cpufreq_policy *policy,
 		unsigned int event);
 static unsigned int __cpufreq_get(unsigned int cpu);
 static void handle_update(struct work_struct *work);
 /**
  * Two notifier lists: the "policy" list is involved in the
  * validation process for a new CPU frequency policy; the
  * "transition" list for kernel code that needs to handle
  * changes to devices when the CPU clock speed changes.
  * The mutex locks both lists.
  */
 static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
 static struct srcu_notifier_head cpufreq_transition_notifier_list;
 static bool init_cpufreq_transition_notifier_list_called;
 static int __init init_cpufreq_transition_notifier_list(void)
 {
 	srcu_init_notifier_head(&cpufreq_transition_notifier_list);
 	init_cpufreq_transition_notifier_list_called = true;
 	return 0;
 }
 pure_initcall(init_cpufreq_transition_notifier_list);
 static int off __read_mostly;
 static int cpufreq_disabled(void)
 {
 	return off;
 }
 void disable_cpufreq(void)
 {
 	off = 1;
 }
 static LIST_HEAD(cpufreq_governor_list);
 static DEFINE_MUTEX(cpufreq_governor_mutex);
 bool have_governor_per_policy(void)
 {
 	return cpufreq_driver->have_governor_per_policy;
 }
 EXPORT_SYMBOL_GPL(have_governor_per_policy);
 struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)
 {
 	if (have_governor_per_policy())
 		return &policy->kobj;
 	else
 		return cpufreq_global_kobject;
 }
 EXPORT_SYMBOL_GPL(get_governor_parent_kobj);
 static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
 {
 	u64 idle_time;
 	u64 cur_wall_time;
 	u64 busy_time;
 	cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
 	busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
 	busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
 	busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
 	busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
 	busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
 	busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
 	idle_time = cur_wall_time - busy_time;
 	if (wall)
 		*wall = cputime_to_usecs(cur_wall_time);
 	return cputime_to_usecs(idle_time);
 }
 u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
 {
 	u64 idle_time = get_cpu_idle_time_us(cpu, io_busy ? wall : NULL);
 	if (idle_time == -1ULL)
 		return get_cpu_idle_time_jiffy(cpu, wall);
 	else if (!io_busy)
 		idle_time += get_cpu_iowait_time_us(cpu, wall);
 	return idle_time;
 }
 EXPORT_SYMBOL_GPL(get_cpu_idle_time);
 static struct cpufreq_policy *__cpufreq_cpu_get(unsigned int cpu, bool sysfs)
 {
 	struct cpufreq_policy *data;
 	unsigned long flags;
 	if (cpu >= nr_cpu_ids)
 		goto err_out;
 	/* get the cpufreq driver */
 	read_lock_irqsave(&cpufreq_driver_lock, flags);
 	if (!cpufreq_driver)
 		goto err_out_unlock;
 	if (!try_module_get(cpufreq_driver->owner))
 		goto err_out_unlock;
 	/* get the CPU */
 	data = per_cpu(cpufreq_cpu_data, cpu);
 	if (!data)
 		goto err_out_put_module;
 	if (!sysfs && !kobject_get(&data->kobj))
 		goto err_out_put_module;
 	read_unlock_irqrestore(&cpufreq_driver_lock, flags);
 	return data;
 err_out_put_module:
 	module_put(cpufreq_driver->owner);
 err_out_unlock:
 	read_unlock_irqrestore(&cpufreq_driver_lock, flags);
 err_out:
 	return NULL;
 }
 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
 {
 	if (cpufreq_disabled())
 		return NULL;
 	return __cpufreq_cpu_get(cpu, false);
 }
 EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
 static struct cpufreq_policy *cpufreq_cpu_get_sysfs(unsigned int cpu)
 {
 	return __cpufreq_cpu_get(cpu, true);
 }
 static void __cpufreq_cpu_put(struct cpufreq_policy *data, bool sysfs)
 {
 	if (!sysfs)
 		kobject_put(&data->kobj);
 	module_put(cpufreq_driver->owner);
 }
 void cpufreq_cpu_put(struct cpufreq_policy *data)
 {
 	if (cpufreq_disabled())
 		return;
 	__cpufreq_cpu_put(data, false);
 }
 EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
 static void cpufreq_cpu_put_sysfs(struct cpufreq_policy *data)
 {
 	__cpufreq_cpu_put(data, true);
 }
 /*********************************************************************
  *            EXTERNALLY AFFECTING FREQUENCY CHANGES                 *
  *********************************************************************/
 /**
  * adjust_jiffies - adjust the system "loops_per_jiffy"
  *
  * This function alters the system "loops_per_jiffy" for the clock
  * speed change. Note that loops_per_jiffy cannot be updated on SMP
  * systems as each CPU might be scaled differently. So, use the arch
  * per-CPU loops_per_jiffy value wherever possible.
  */
 #ifndef CONFIG_SMP
 static unsigned long l_p_j_ref;
 static unsigned int  l_p_j_ref_freq;
 static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
 {
 	if (ci->flags & CPUFREQ_CONST_LOOPS)
 		return;
 	if (!l_p_j_ref_freq) {
 		l_p_j_ref = loops_per_jiffy;
 		l_p_j_ref_freq = ci->old;
 		pr_debug("saving %lu as reference value for loops_per_jiffy; "
 			"freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
 	}
 	if ((val == CPUFREQ_POSTCHANGE  && ci->old != ci->new) ||
 	    (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
 		loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
 								ci->new);
 		pr_debug("scaling loops_per_jiffy to %lu "
 			"for frequency %u kHz\n", loops_per_jiffy, ci->new);
 	}
 }
 #else
 static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
 {
 	return;
 }
 #endif
 void __cpufreq_notify_transition(struct cpufreq_policy *policy,
 		struct cpufreq_freqs *freqs, unsigned int state)
 {
 	BUG_ON(irqs_disabled());
 	if (cpufreq_disabled())
 		return;
 	freqs->flags = cpufreq_driver->flags;
 	pr_debug("notification %u of frequency transition to %u kHz\n",
 		state, freqs->new);
 	switch (state) {
 	case CPUFREQ_PRECHANGE:
 		/* detect if the driver reported a value as "old frequency"
 		 * which is not equal to what the cpufreq core thinks is
 		 * "old frequency".
 		 */
 		if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
 			if ((policy) && (policy->cpu == freqs->cpu) &&
 			    (policy->cur) && (policy->cur != freqs->old)) {
 				pr_debug("Warning: CPU frequency is"
 					" %u, cpufreq assumed %u kHz.\n",
 					freqs->old, policy->cur);
 				freqs->old = policy->cur;
 			}
 		}
 		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
 				CPUFREQ_PRECHANGE, freqs);
 		adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
 		break;
 	case CPUFREQ_POSTCHANGE:
 		adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
 		pr_debug("FREQ: %lu - CPU: %lu", (unsigned long)freqs->new,
 			(unsigned long)freqs->cpu);
 		trace_cpu_frequency(freqs->new, freqs->cpu);
 		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
 				CPUFREQ_POSTCHANGE, freqs);
 		if (likely(policy) && likely(policy->cpu == freqs->cpu))
 			policy->cur = freqs->new;
 		break;
 	}
 }
 /**
  * cpufreq_notify_transition - call notifier chain and adjust_jiffies
  * on frequency transition.
  *
  * This function calls the transition notifiers and the "adjust_jiffies"
  * function. It is called twice on all CPU frequency changes that have
  * external effects.
  */
 void cpufreq_notify_transition(struct cpufreq_policy *policy,
 		struct cpufreq_freqs *freqs, unsigned int state)
 {
 	for_each_cpu(freqs->cpu, policy->cpus)
 		__cpufreq_notify_transition(policy, freqs, state);
 }
 EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
 /*********************************************************************
  *                          SYSFS INTERFACE                          *
  *********************************************************************/
 static struct cpufreq_governor *__find_governor(const char *str_governor)
 {
 	struct cpufreq_governor *t;
 	list_for_each_entry(t, &cpufreq_governor_list, governor_list)
 		if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
 			return t;
 	return NULL;
 }
 /**
  * cpufreq_parse_governor - parse a governor string
  */
 static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
 				struct cpufreq_governor **governor)
 {
 	int err = -EINVAL;
 	if (!cpufreq_driver)
 		goto out;
 	if (cpufreq_driver->setpolicy) {
 		if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
 			*policy = CPUFREQ_POLICY_PERFORMANCE;
 			err = 0;
 		} else if (!strnicmp(str_governor, "powersave",
 						CPUFREQ_NAME_LEN)) {
 			*policy = CPUFREQ_POLICY_POWERSAVE;
 			err = 0;
 		}
 	} else if (cpufreq_driver->target) {
 		struct cpufreq_governor *t;
 		mutex_lock(&cpufreq_governor_mutex);
 		t = __find_governor(str_governor);
 		if (t == NULL) {
 			int ret;
 			mutex_unlock(&cpufreq_governor_mutex);
 			ret = request_module("cpufreq_%s", str_governor);
 			mutex_lock(&cpufreq_governor_mutex);
 			if (ret == 0)
 				t = __find_governor(str_governor);
 		}
 		if (t != NULL) {
 			*governor = t;
 			err = 0;
 		}
 		mutex_unlock(&cpufreq_governor_mutex);
 	}
 out:
 	return err;
 }
 /**
  * cpufreq_per_cpu_attr_read() / show_##file_name() -
  * print out cpufreq information
  *
  * Write out information from cpufreq_driver->policy[cpu]; object must be
  * "unsigned int".
  */
 #define show_one(file_name, object)			\
 static ssize_t show_##file_name				\
 (struct cpufreq_policy *policy, char *buf)		\
 {							\
 	return sprintf(buf, "%u\n", policy->object);	\
 }
 show_one(cpuinfo_min_freq, cpuinfo.min_freq);
 show_one(cpuinfo_max_freq, cpuinfo.max_freq);
 show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
 show_one(scaling_min_freq, min);
 show_one(scaling_max_freq, max);
 show_one(scaling_cur_freq, cur);
 static int __cpufreq_set_policy(struct cpufreq_policy *data,
 				struct cpufreq_policy *policy);
 /**
  * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
  */
 #define store_one(file_name, object)			\
 static ssize_t store_##file_name					\
 (struct cpufreq_policy *policy, const char *buf, size_t count)		\
 {									\
 	unsigned int ret;						\
 	struct cpufreq_policy new_policy;				\
 									\
 	ret = cpufreq_get_policy(&new_policy, policy->cpu);		\
 	if (ret)							\
 		return -EINVAL;						\
 									\
 	ret = sscanf(buf, "%u", &new_policy.object);			\
 	if (ret != 1)							\
 		return -EINVAL;						\
 									\
 	ret = __cpufreq_set_policy(policy, &new_policy);		\
 	policy->user_policy.object = policy->object;			\
 									\
 	return ret ? ret : count;					\
 }
 store_one(scaling_min_freq, min);
 store_one(scaling_max_freq, max);
 /**
  * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
  */
 static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
 					char *buf)
 {
 	unsigned int cur_freq = __cpufreq_get(policy->cpu);
 	if (!cur_freq)
 		return sprintf(buf, "<unknown>");
 	return sprintf(buf, "%u\n", cur_freq);
 }
 /**
  * show_scaling_governor - show the current policy for the specified CPU
  */
 static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
 {
 	if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
 		return sprintf(buf, "powersave\n");
 	else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
 		return sprintf(buf, "performance\n");
 	else if (policy->governor)
 		return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
 				policy->governor->name);
 	return -EINVAL;
 }
 /**
  * store_scaling_governor - store policy for the specified CPU
  */
 static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
 					const char *buf, size_t count)
 {
 	unsigned int ret;
 	char	str_governor[16];
 	struct cpufreq_policy new_policy;
 	ret = cpufreq_get_policy(&new_policy, policy->cpu);
 	if (ret)
 		return ret;
 	ret = sscanf(buf, "%15s", str_governor);
 	if (ret != 1)
 		return -EINVAL;
 	if (cpufreq_parse_governor(str_governor, &new_policy.policy,
 						&new_policy.governor))
 		return -EINVAL;
 	/* Do not use cpufreq_set_policy here or the user_policy.max
 	   will be wrongly overridden */
 	ret = __cpufreq_set_policy(policy, &new_policy);
 	policy->user_policy.policy = policy->policy;
 	policy->user_policy.governor = policy->governor;
 	if (ret)
 		return ret;
 	else
 		return count;
 }
 /**
  * show_scaling_driver - show the cpufreq driver currently loaded
  */
 static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
 {
 	return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
 }
 /**
  * show_scaling_available_governors - show the available CPUfreq governors
  */
 static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
 						char *buf)
 {
 	ssize_t i = 0;
 	struct cpufreq_governor *t;
 	if (!cpufreq_driver->target) {
 		i += sprintf(buf, "performance powersave");
 		goto out;
 	}
 	list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
 		if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
 		    - (CPUFREQ_NAME_LEN + 2)))
 			goto out;
 		i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
 	}
 out:
 	i += sprintf(&buf[i], "\n");
 	return i;
 }
 static ssize_t show_cpus(const struct cpumask *mask, char *buf)
 {
 	ssize_t i = 0;
 	unsigned int cpu;
 	for_each_cpu(cpu, mask) {
 		if (i)
 			i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
 		i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
 		if (i >= (PAGE_SIZE - 5))
 			break;
 	}
 	i += sprintf(&buf[i], "\n");
 	return i;
 }
 /**
  * show_related_cpus - show the CPUs affected by each transition even if
  * hw coordination is in use
  */
 static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
 {
 	return show_cpus(policy->related_cpus, buf);
 }
 /**
  * show_affected_cpus - show the CPUs affected by each transition
  */
 static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
 {
 	return show_cpus(policy->cpus, buf);
 }
 static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
 					const char *buf, size_t count)
 {
 	unsigned int freq = 0;
 	unsigned int ret;
 	if (!policy->governor || !policy->governor->store_setspeed)
 		return -EINVAL;
 	ret = sscanf(buf, "%u", &freq);
 	if (ret != 1)
 		return -EINVAL;
 	policy->governor->store_setspeed(policy, freq);
 	return count;
 }
 static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
 {
 	if (!policy->governor || !policy->governor->show_setspeed)
 		return sprintf(buf, "<unsupported>\n");
 	return policy->governor->show_setspeed(policy, buf);
 }
 /**
  * show_bios_limit - show the current cpufreq HW/BIOS limitation
  */
 static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
 {
 	unsigned int limit;
 	int ret;
 	if (cpufreq_driver->bios_limit) {
 		ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
 		if (!ret)
 			return sprintf(buf, "%u\n", limit);
 	}
 	return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
 }
 cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
 cpufreq_freq_attr_ro(cpuinfo_min_freq);
 cpufreq_freq_attr_ro(cpuinfo_max_freq);
 cpufreq_freq_attr_ro(cpuinfo_transition_latency);
 cpufreq_freq_attr_ro(scaling_available_governors);
 cpufreq_freq_attr_ro(scaling_driver);
 cpufreq_freq_attr_ro(scaling_cur_freq);
 cpufreq_freq_attr_ro(bios_limit);
 cpufreq_freq_attr_ro(related_cpus);
 cpufreq_freq_attr_ro(affected_cpus);
 cpufreq_freq_attr_rw(scaling_min_freq);
 cpufreq_freq_attr_rw(scaling_max_freq);
 cpufreq_freq_attr_rw(scaling_governor);
 cpufreq_freq_attr_rw(scaling_setspeed);
 static struct attribute *default_attrs[] = {
 	&cpuinfo_min_freq.attr,
 	&cpuinfo_max_freq.attr,
 	&cpuinfo_transition_latency.attr,
 	&scaling_min_freq.attr,
 	&scaling_max_freq.attr,
 	&affected_cpus.attr,
 	&related_cpus.attr,
 	&scaling_governor.attr,
 	&scaling_driver.attr,
 	&scaling_available_governors.attr,
 	&scaling_setspeed.attr,
 	NULL
 };
-struct kobject *cpufreq_global_kobject;
-EXPORT_SYMBOL(cpufreq_global_kobject);
 #define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
 #define to_attr(a) container_of(a, struct freq_attr, attr)
 static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
 {
 	struct cpufreq_policy *policy = to_policy(kobj);
 	struct freq_attr *fattr = to_attr(attr);
 	ssize_t ret = -EINVAL;
 	policy = cpufreq_cpu_get_sysfs(policy->cpu);
 	if (!policy)
 		goto no_policy;
 	if (lock_policy_rwsem_read(policy->cpu) < 0)
 		goto fail;
 	if (fattr->show)
 		ret = fattr->show(policy, buf);
 	else
 		ret = -EIO;
 	unlock_policy_rwsem_read(policy->cpu);
 fail:
 	cpufreq_cpu_put_sysfs(policy);
 no_policy:
 	return ret;
 }
 static ssize_t store(struct kobject *kobj, struct attribute *attr,
 		     const char *buf, size_t count)
 {
 	struct cpufreq_policy *policy = to_policy(kobj);
 	struct freq_attr *fattr = to_attr(attr);
 	ssize_t ret = -EINVAL;
 	policy = cpufreq_cpu_get_sysfs(policy->cpu);
 	if (!policy)
 		goto no_policy;
 	if (lock_policy_rwsem_write(policy->cpu) < 0)
 		goto fail;
 	if (fattr->store)
 		ret = fattr->store(policy, buf, count);
 	else
 		ret = -EIO;
 	unlock_policy_rwsem_write(policy->cpu);
 fail:
 	cpufreq_cpu_put_sysfs(policy);
 no_policy:
 	return ret;
 }
 static void cpufreq_sysfs_release(struct kobject *kobj)
 {
 	struct cpufreq_policy *policy = to_policy(kobj);
 	pr_debug("last reference is dropped\n");
 	complete(&policy->kobj_unregister);
 }
 static const struct sysfs_ops sysfs_ops = {
 	.show	= show,
 	.store	= store,
 };
 static struct kobj_type ktype_cpufreq = {
 	.sysfs_ops	= &sysfs_ops,
 	.default_attrs	= default_attrs,
 	.release	= cpufreq_sysfs_release,
 };
+struct kobject *cpufreq_global_kobject;
+EXPORT_SYMBOL(cpufreq_global_kobject);
+static int cpufreq_global_kobject_usage;
+int cpufreq_get_global_kobject(void)
+{
+	if (!cpufreq_global_kobject_usage++)
+		return kobject_add(cpufreq_global_kobject,
+				&cpu_subsys.dev_root->kobj, "%s", "cpufreq");
+	return 0;
+}
+EXPORT_SYMBOL(cpufreq_get_global_kobject);
+void cpufreq_put_global_kobject(void)
+{
+	if (!--cpufreq_global_kobject_usage)
+		kobject_del(cpufreq_global_kobject);
+}
+EXPORT_SYMBOL(cpufreq_put_global_kobject);
+int cpufreq_sysfs_create_file(const struct attribute *attr)
+{
+	int ret = cpufreq_get_global_kobject();
+	if (!ret) {
+		ret = sysfs_create_file(cpufreq_global_kobject, attr);
+		if (ret)
+			cpufreq_put_global_kobject();
+	}
+	return ret;
+}
+EXPORT_SYMBOL(cpufreq_sysfs_create_file);
+void cpufreq_sysfs_remove_file(const struct attribute *attr)
+{
+	sysfs_remove_file(cpufreq_global_kobject, attr);
+	cpufreq_put_global_kobject();
+}
+EXPORT_SYMBOL(cpufreq_sysfs_remove_file);
 /* symlink affected CPUs */
 static int cpufreq_add_dev_symlink(unsigned int cpu,
 				   struct cpufreq_policy *policy)
 {
 	unsigned int j;
 	int ret = 0;
 	for_each_cpu(j, policy->cpus) {
 		struct cpufreq_policy *managed_policy;
 		struct device *cpu_dev;
 		if (j == cpu)
 			continue;
 		pr_debug("CPU %u already managed, adding link\n", j);
 		managed_policy = cpufreq_cpu_get(cpu);
 		cpu_dev = get_cpu_device(j);
 		ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
 					"cpufreq");
 		if (ret) {
 			cpufreq_cpu_put(managed_policy);
 			return ret;
 		}
 	}
 	return ret;
 }
 static int cpufreq_add_dev_interface(unsigned int cpu,
 				     struct cpufreq_policy *policy,
 				     struct device *dev)
 {
 	struct cpufreq_policy new_policy;
 	struct freq_attr **drv_attr;
 	unsigned long flags;
 	int ret = 0;
 	unsigned int j;
 	/* prepare interface data */
 	ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
 				   &dev->kobj, "cpufreq");
 	if (ret)
 		return ret;
 	/* set up files for this cpu device */
 	drv_attr = cpufreq_driver->attr;
 	while ((drv_attr) && (*drv_attr)) {
 		ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
 		if (ret)
 			goto err_out_kobj_put;
 		drv_attr++;
 	}
 	if (cpufreq_driver->get) {
 		ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
 		if (ret)
 			goto err_out_kobj_put;
 	}
 	if (cpufreq_driver->target) {
 		ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
 		if (ret)
 			goto err_out_kobj_put;
 	}
 	if (cpufreq_driver->bios_limit) {
 		ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
 		if (ret)
 			goto err_out_kobj_put;
 	}
 	write_lock_irqsave(&cpufreq_driver_lock, flags);
 	for_each_cpu(j, policy->cpus) {
 		per_cpu(cpufreq_cpu_data, j) = policy;
 		per_cpu(cpufreq_policy_cpu, j) = policy->cpu;
 	}
 	write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 	ret = cpufreq_add_dev_symlink(cpu, policy);
 	if (ret)
 		goto err_out_kobj_put;
 	memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
 	/* assure that the starting sequence is run in __cpufreq_set_policy */
 	policy->governor = NULL;
 	/* set default policy */
 	ret = __cpufreq_set_policy(policy, &new_policy);
 	policy->user_policy.policy = policy->policy;
 	policy->user_policy.governor = policy->governor;
 	if (ret) {
 		pr_debug("setting policy failed\n");
 		if (cpufreq_driver->exit)
 			cpufreq_driver->exit(policy);
 	}
 	return ret;
 err_out_kobj_put:
 	kobject_put(&policy->kobj);
 	wait_for_completion(&policy->kobj_unregister);
 	return ret;
 }
 #ifdef CONFIG_HOTPLUG_CPU
 static int cpufreq_add_policy_cpu(unsigned int cpu, unsigned int sibling,
 				  struct device *dev)
 {
 	struct cpufreq_policy *policy;
 	int ret = 0, has_target = !!cpufreq_driver->target;
 	unsigned long flags;
 	policy = cpufreq_cpu_get(sibling);
 	WARN_ON(!policy);
 	if (has_target)
 		__cpufreq_governor(policy, CPUFREQ_GOV_STOP);
 	lock_policy_rwsem_write(sibling);
 	write_lock_irqsave(&cpufreq_driver_lock, flags);
 	cpumask_set_cpu(cpu, policy->cpus);
 	per_cpu(cpufreq_policy_cpu, cpu) = policy->cpu;
 	per_cpu(cpufreq_cpu_data, cpu) = policy;
 	write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 	unlock_policy_rwsem_write(sibling);
 	if (has_target) {
 		__cpufreq_governor(policy, CPUFREQ_GOV_START);
 		__cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
 	}
 	ret = sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
 	if (ret) {
 		cpufreq_cpu_put(policy);
 		return ret;
 	}
 	return 0;
 }
 #endif
 /**
  * cpufreq_add_dev - add a CPU device
  *
  * Adds the cpufreq interface for a CPU device.
  *
  * The Oracle says: try running cpufreq registration/unregistration concurrently
  * with with cpu hotplugging and all hell will break loose. Tried to clean this
  * mess up, but more thorough testing is needed. - Mathieu
  */
 static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
 {
 	unsigned int j, cpu = dev->id;
 	int ret = -ENOMEM;
 	struct cpufreq_policy *policy;
 	unsigned long flags;
 #ifdef CONFIG_HOTPLUG_CPU
 	struct cpufreq_governor *gov;
 	int sibling;
 #endif
 	if (cpu_is_offline(cpu))
 		return 0;
 	pr_debug("adding CPU %u\n", cpu);
 #ifdef CONFIG_SMP
 	/* check whether a different CPU already registered this
 	 * CPU because it is in the same boat. */
 	policy = cpufreq_cpu_get(cpu);
 	if (unlikely(policy)) {
 		cpufreq_cpu_put(policy);
 		return 0;
 	}
 #ifdef CONFIG_HOTPLUG_CPU
 	/* Check if this cpu was hot-unplugged earlier and has siblings */
 	read_lock_irqsave(&cpufreq_driver_lock, flags);
 	for_each_online_cpu(sibling) {
 		struct cpufreq_policy *cp = per_cpu(cpufreq_cpu_data, sibling);
 		if (cp && cpumask_test_cpu(cpu, cp->related_cpus)) {
 			read_unlock_irqrestore(&cpufreq_driver_lock, flags);
 			return cpufreq_add_policy_cpu(cpu, sibling, dev);
 		}
 	}
 	read_unlock_irqrestore(&cpufreq_driver_lock, flags);
 #endif
 #endif
 	if (!try_module_get(cpufreq_driver->owner)) {
 		ret = -EINVAL;
 		goto module_out;
 	}
 	policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
 	if (!policy)
 		goto nomem_out;
 	if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
 		goto err_free_policy;
 	if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
 		goto err_free_cpumask;
 	policy->cpu = cpu;
 	policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
 	cpumask_copy(policy->cpus, cpumask_of(cpu));
 	/* Initially set CPU itself as the policy_cpu */
 	per_cpu(cpufreq_policy_cpu, cpu) = cpu;
 	init_completion(&policy->kobj_unregister);
 	INIT_WORK(&policy->update, handle_update);
 	/* call driver. From then on the cpufreq must be able
 	 * to accept all calls to ->verify and ->setpolicy for this CPU
 	 */
 	ret = cpufreq_driver->init(policy);
 	if (ret) {
 		pr_debug("initialization failed\n");
 		goto err_set_policy_cpu;
 	}
 	/* related cpus should atleast have policy->cpus */
 	cpumask_or(policy->related_cpus, policy->related_cpus, policy->cpus);
 	/*
 	 * affected cpus must always be the one, which are online. We aren't
 	 * managing offline cpus here.
 	 */
 	cpumask_and(policy->cpus, policy->cpus, cpu_online_mask);
 	policy->user_policy.min = policy->min;
 	policy->user_policy.max = policy->max;
 	blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
 				     CPUFREQ_START, policy);
 #ifdef CONFIG_HOTPLUG_CPU
 	gov = __find_governor(per_cpu(cpufreq_cpu_governor, cpu));
 	if (gov) {
 		policy->governor = gov;
 		pr_debug("Restoring governor %s for cpu %d\n",
 		       policy->governor->name, cpu);
 	}
 #endif
 	ret = cpufreq_add_dev_interface(cpu, policy, dev);
 	if (ret)
 		goto err_out_unregister;
 	kobject_uevent(&policy->kobj, KOBJ_ADD);
 	module_put(cpufreq_driver->owner);
 	pr_debug("initialization complete\n");
 	return 0;
 err_out_unregister:
 	write_lock_irqsave(&cpufreq_driver_lock, flags);
 	for_each_cpu(j, policy->cpus)
 		per_cpu(cpufreq_cpu_data, j) = NULL;
 	write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 	kobject_put(&policy->kobj);
 	wait_for_completion(&policy->kobj_unregister);
 err_set_policy_cpu:
 	per_cpu(cpufreq_policy_cpu, cpu) = -1;
 	free_cpumask_var(policy->related_cpus);
 err_free_cpumask:
 	free_cpumask_var(policy->cpus);
 err_free_policy:
 	kfree(policy);
 nomem_out:
 	module_put(cpufreq_driver->owner);
 module_out:
 	return ret;
 }
 static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
 {
 	int j;
 	policy->last_cpu = policy->cpu;
 	policy->cpu = cpu;
 	for_each_cpu(j, policy->cpus)
 		per_cpu(cpufreq_policy_cpu, j) = cpu;
 #ifdef CONFIG_CPU_FREQ_TABLE
 	cpufreq_frequency_table_update_policy_cpu(policy);
 #endif
 	blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
 			CPUFREQ_UPDATE_POLICY_CPU, policy);
 }
 /**
  * __cpufreq_remove_dev - remove a CPU device
  *
  * Removes the cpufreq interface for a CPU device.
  * Caller should already have policy_rwsem in write mode for this CPU.
  * This routine frees the rwsem before returning.
  */
 static int __cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
 {
 	unsigned int cpu = dev->id, ret, cpus;
 	unsigned long flags;
 	struct cpufreq_policy *data;
 	struct kobject *kobj;
 	struct completion *cmp;
 	struct device *cpu_dev;
 	pr_debug("%s: unregistering CPU %u\n", __func__, cpu);
 	write_lock_irqsave(&cpufreq_driver_lock, flags);
 	data = per_cpu(cpufreq_cpu_data, cpu);
 	per_cpu(cpufreq_cpu_data, cpu) = NULL;
 	write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 	if (!data) {
 		pr_debug("%s: No cpu_data found\n", __func__);
 		return -EINVAL;
 	}
 	if (cpufreq_driver->target)
 		__cpufreq_governor(data, CPUFREQ_GOV_STOP);
 #ifdef CONFIG_HOTPLUG_CPU
 	if (!cpufreq_driver->setpolicy)
 		strncpy(per_cpu(cpufreq_cpu_governor, cpu),
 			data->governor->name, CPUFREQ_NAME_LEN);
 #endif
 	WARN_ON(lock_policy_rwsem_write(cpu));
 	cpus = cpumask_weight(data->cpus);
 	if (cpus > 1)
 		cpumask_clear_cpu(cpu, data->cpus);
 	unlock_policy_rwsem_write(cpu);
 	if (cpu != data->cpu) {
 		sysfs_remove_link(&dev->kobj, "cpufreq");
 	} else if (cpus > 1) {
 		/* first sibling now owns the new sysfs dir */
 		cpu_dev = get_cpu_device(cpumask_first(data->cpus));
 		sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
 		ret = kobject_move(&data->kobj, &cpu_dev->kobj);
 		if (ret) {
 			pr_err("%s: Failed to move kobj: %d", __func__, ret);
 			WARN_ON(lock_policy_rwsem_write(cpu));
 			cpumask_set_cpu(cpu, data->cpus);
 			write_lock_irqsave(&cpufreq_driver_lock, flags);
 			per_cpu(cpufreq_cpu_data, cpu) = data;
 			write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 			unlock_policy_rwsem_write(cpu);
 			ret = sysfs_create_link(&cpu_dev->kobj, &data->kobj,
 					"cpufreq");
 			return -EINVAL;
 		}
 		WARN_ON(lock_policy_rwsem_write(cpu));
 		update_policy_cpu(data, cpu_dev->id);
 		unlock_policy_rwsem_write(cpu);
 		pr_debug("%s: policy Kobject moved to cpu: %d from: %d\n",
 				__func__, cpu_dev->id, cpu);
 	}
 	if ((cpus == 1) && (cpufreq_driver->target))
 		__cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
 	pr_debug("%s: removing link, cpu: %d\n", __func__, cpu);
 	cpufreq_cpu_put(data);
 	/* If cpu is last user of policy, free policy */
 	if (cpus == 1) {
 		lock_policy_rwsem_read(cpu);
 		kobj = &data->kobj;
 		cmp = &data->kobj_unregister;
 		unlock_policy_rwsem_read(cpu);
 		kobject_put(kobj);
 		/* we need to make sure that the underlying kobj is actually
 		 * not referenced anymore by anybody before we proceed with
 		 * unloading.
 		 */
 		pr_debug("waiting for dropping of refcount\n");
 		wait_for_completion(cmp);
 		pr_debug("wait complete\n");
 		if (cpufreq_driver->exit)
 			cpufreq_driver->exit(data);
 		free_cpumask_var(data->related_cpus);
 		free_cpumask_var(data->cpus);
 		kfree(data);
 	} else if (cpufreq_driver->target) {
 		__cpufreq_governor(data, CPUFREQ_GOV_START);
 		__cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
 	}
 	per_cpu(cpufreq_policy_cpu, cpu) = -1;
 	return 0;
 }
 static int cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
 {
 	unsigned int cpu = dev->id;
 	int retval;
 	if (cpu_is_offline(cpu))
 		return 0;
 	retval = __cpufreq_remove_dev(dev, sif);
 	return retval;
 }
 static void handle_update(struct work_struct *work)
 {
 	struct cpufreq_policy *policy =
 		container_of(work, struct cpufreq_policy, update);
 	unsigned int cpu = policy->cpu;
 	pr_debug("handle_update for cpu %u called\n", cpu);
 	cpufreq_update_policy(cpu);
 }
 /**
  *	cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
  *	@cpu: cpu number
  *	@old_freq: CPU frequency the kernel thinks the CPU runs at
  *	@new_freq: CPU frequency the CPU actually runs at
  *
  *	We adjust to current frequency first, and need to clean up later.
  *	So either call to cpufreq_update_policy() or schedule handle_update()).
  */
 static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
 				unsigned int new_freq)
 {
 	struct cpufreq_policy *policy;
 	struct cpufreq_freqs freqs;
 	unsigned long flags;
 	pr_debug("Warning: CPU frequency out of sync: cpufreq and timing "
 	       "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
 	freqs.old = old_freq;
 	freqs.new = new_freq;
 	read_lock_irqsave(&cpufreq_driver_lock, flags);
 	policy = per_cpu(cpufreq_cpu_data, cpu);
 	read_unlock_irqrestore(&cpufreq_driver_lock, flags);
 	cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 	cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 }
 /**
  * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
  * @cpu: CPU number
  *
  * This is the last known freq, without actually getting it from the driver.
  * Return value will be same as what is shown in scaling_cur_freq in sysfs.
  */
 unsigned int cpufreq_quick_get(unsigned int cpu)
 {
 	struct cpufreq_policy *policy;
 	unsigned int ret_freq = 0;
 	if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
 		return cpufreq_driver->get(cpu);
 	policy = cpufreq_cpu_get(cpu);
 	if (policy) {
 		ret_freq = policy->cur;
 		cpufreq_cpu_put(policy);
 	}
 	return ret_freq;
 }
 EXPORT_SYMBOL(cpufreq_quick_get);
 /**
  * cpufreq_quick_get_max - get the max reported CPU frequency for this CPU
  * @cpu: CPU number
  *
  * Just return the max possible frequency for a given CPU.
  */
 unsigned int cpufreq_quick_get_max(unsigned int cpu)
 {
 	struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
 	unsigned int ret_freq = 0;
 	if (policy) {
 		ret_freq = policy->max;
 		cpufreq_cpu_put(policy);
 	}
 	return ret_freq;
 }
 EXPORT_SYMBOL(cpufreq_quick_get_max);
 static unsigned int __cpufreq_get(unsigned int cpu)
 {
 	struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
 	unsigned int ret_freq = 0;
 	if (!cpufreq_driver->get)
 		return ret_freq;
 	ret_freq = cpufreq_driver->get(cpu);
 	if (ret_freq && policy->cur &&
 		!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
 		/* verify no discrepancy between actual and
 					saved value exists */
 		if (unlikely(ret_freq != policy->cur)) {
 			cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
 			schedule_work(&policy->update);
 		}
 	}
 	return ret_freq;
 }
 /**
  * cpufreq_get - get the current CPU frequency (in kHz)
  * @cpu: CPU number
  *
  * Get the CPU current (static) CPU frequency
  */
 unsigned int cpufreq_get(unsigned int cpu)
 {
 	unsigned int ret_freq = 0;
 	struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
 	if (!policy)
 		goto out;
 	if (unlikely(lock_policy_rwsem_read(cpu)))
 		goto out_policy;
 	ret_freq = __cpufreq_get(cpu);
 	unlock_policy_rwsem_read(cpu);
 out_policy:
 	cpufreq_cpu_put(policy);
 out:
 	return ret_freq;
 }
 EXPORT_SYMBOL(cpufreq_get);
 static struct subsys_interface cpufreq_interface = {
 	.name		= "cpufreq",
 	.subsys		= &cpu_subsys,
 	.add_dev	= cpufreq_add_dev,
 	.remove_dev	= cpufreq_remove_dev,
 };
 /**
  * cpufreq_bp_suspend - Prepare the boot CPU for system suspend.
  *
  * This function is only executed for the boot processor.  The other CPUs
  * have been put offline by means of CPU hotplug.
  */
 static int cpufreq_bp_suspend(void)
 {
 	int ret = 0;
 	int cpu = smp_processor_id();
 	struct cpufreq_policy *cpu_policy;
 	pr_debug("suspending cpu %u\n", cpu);
 	/* If there's no policy for the boot CPU, we have nothing to do. */
 	cpu_policy = cpufreq_cpu_get(cpu);
 	if (!cpu_policy)
 		return 0;
 	if (cpufreq_driver->suspend) {
 		ret = cpufreq_driver->suspend(cpu_policy);
 		if (ret)
 			printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
 					"step on CPU %u\n", cpu_policy->cpu);
 	}
 	cpufreq_cpu_put(cpu_policy);
 	return ret;
 }
 /**
  * cpufreq_bp_resume - Restore proper frequency handling of the boot CPU.
  *
  *	1.) resume CPUfreq hardware support (cpufreq_driver->resume())
  *	2.) schedule call cpufreq_update_policy() ASAP as interrupts are
  *	    restored. It will verify that the current freq is in sync with
  *	    what we believe it to be. This is a bit later than when it
  *	    should be, but nonethteless it's better than calling
  *	    cpufreq_driver->get() here which might re-enable interrupts...
  *
  * This function is only executed for the boot CPU.  The other CPUs have not
  * been turned on yet.
  */
 static void cpufreq_bp_resume(void)
 {
 	int ret = 0;
 	int cpu = smp_processor_id();
 	struct cpufreq_policy *cpu_policy;
 	pr_debug("resuming cpu %u\n", cpu);
 	/* If there's no policy for the boot CPU, we have nothing to do. */
 	cpu_policy = cpufreq_cpu_get(cpu);
 	if (!cpu_policy)
 		return;
 	if (cpufreq_driver->resume) {
 		ret = cpufreq_driver->resume(cpu_policy);
 		if (ret) {
 			printk(KERN_ERR "cpufreq: resume failed in ->resume "
 					"step on CPU %u\n", cpu_policy->cpu);
 			goto fail;
 		}
 	}
 	schedule_work(&cpu_policy->update);
 fail:
 	cpufreq_cpu_put(cpu_policy);
 }
 static struct syscore_ops cpufreq_syscore_ops = {
 	.suspend	= cpufreq_bp_suspend,
 	.resume		= cpufreq_bp_resume,
 };
 /**
  *	cpufreq_get_current_driver - return current driver's name
  *
  *	Return the name string of the currently loaded cpufreq driver
  *	or NULL, if none.
  */
 const char *cpufreq_get_current_driver(void)
 {
 	if (cpufreq_driver)
 		return cpufreq_driver->name;
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
 /*********************************************************************
  *                     NOTIFIER LISTS INTERFACE                      *
  *********************************************************************/
 /**
  *	cpufreq_register_notifier - register a driver with cpufreq
  *	@nb: notifier function to register
  *      @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
  *
  *	Add a driver to one of two lists: either a list of drivers that
  *      are notified about clock rate changes (once before and once after
  *      the transition), or a list of drivers that are notified about
  *      changes in cpufreq policy.
  *
  *	This function may sleep, and has the same return conditions as
  *	blocking_notifier_chain_register.
  */
 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
 {
 	int ret;
 	if (cpufreq_disabled())
 		return -EINVAL;
 	WARN_ON(!init_cpufreq_transition_notifier_list_called);
 	switch (list) {
 	case CPUFREQ_TRANSITION_NOTIFIER:
 		ret = srcu_notifier_chain_register(
 				&cpufreq_transition_notifier_list, nb);
 		break;
 	case CPUFREQ_POLICY_NOTIFIER:
 		ret = blocking_notifier_chain_register(
 				&cpufreq_policy_notifier_list, nb);
 		break;
 	default:
 		ret = -EINVAL;
 	}
 	return ret;
 }
 EXPORT_SYMBOL(cpufreq_register_notifier);
 /**
  *	cpufreq_unregister_notifier - unregister a driver with cpufreq
  *	@nb: notifier block to be unregistered
  *      @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
  *
  *	Remove a driver from the CPU frequency notifier list.
  *
  *	This function may sleep, and has the same return conditions as
  *	blocking_notifier_chain_unregister.
  */
 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
 {
 	int ret;
 	if (cpufreq_disabled())
 		return -EINVAL;
 	switch (list) {
 	case CPUFREQ_TRANSITION_NOTIFIER:
 		ret = srcu_notifier_chain_unregister(
 				&cpufreq_transition_notifier_list, nb);
 		break;
 	case CPUFREQ_POLICY_NOTIFIER:
 		ret = blocking_notifier_chain_unregister(
 				&cpufreq_policy_notifier_list, nb);
 		break;
 	default:
 		ret = -EINVAL;
 	}
 	return ret;
 }
 EXPORT_SYMBOL(cpufreq_unregister_notifier);
 /*********************************************************************
  *                              GOVERNORS                            *
  *********************************************************************/
 int __cpufreq_driver_target(struct cpufreq_policy *policy,
 			    unsigned int target_freq,
 			    unsigned int relation)
 {
 	int retval = -EINVAL;
 	unsigned int old_target_freq = target_freq;
 	if (cpufreq_disabled())
 		return -ENODEV;
 	/* Make sure that target_freq is within supported range */
 	if (target_freq > policy->max)
 		target_freq = policy->max;
 	if (target_freq < policy->min)
 		target_freq = policy->min;
 	pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
 			policy->cpu, target_freq, relation, old_target_freq);
 	if (target_freq == policy->cur)
 		return 0;
 	if (cpufreq_driver->target)
 		retval = cpufreq_driver->target(policy, target_freq, relation);
 	return retval;
 }
 EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
 int cpufreq_driver_target(struct cpufreq_policy *policy,
 			  unsigned int target_freq,
 			  unsigned int relation)
 {
 	int ret = -EINVAL;
 	policy = cpufreq_cpu_get(policy->cpu);
 	if (!policy)
 		goto no_policy;
 	if (unlikely(lock_policy_rwsem_write(policy->cpu)))
 		goto fail;
 	ret = __cpufreq_driver_target(policy, target_freq, relation);
 	unlock_policy_rwsem_write(policy->cpu);
 fail:
 	cpufreq_cpu_put(policy);
 no_policy:
 	return ret;
 }
 EXPORT_SYMBOL_GPL(cpufreq_driver_target);
 int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
 {
 	int ret = 0;
 	if (cpufreq_disabled())
 		return ret;
 	if (!cpufreq_driver->getavg)
 		return 0;
 	policy = cpufreq_cpu_get(policy->cpu);
 	if (!policy)
 		return -EINVAL;
 	ret = cpufreq_driver->getavg(policy, cpu);
 	cpufreq_cpu_put(policy);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
 /*
  * when "event" is CPUFREQ_GOV_LIMITS
  */
 static int __cpufreq_governor(struct cpufreq_policy *policy,
 					unsigned int event)
 {
 	int ret;
 	/* Only must be defined when default governor is known to have latency
 	   restrictions, like e.g. conservative or ondemand.
 	   That this is the case is already ensured in Kconfig
 	*/
 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
 	struct cpufreq_governor *gov = &cpufreq_gov_performance;
 #else
 	struct cpufreq_governor *gov = NULL;
 #endif
 	if (policy->governor->max_transition_latency &&
 	    policy->cpuinfo.transition_latency >
 	    policy->governor->max_transition_latency) {
 		if (!gov)
 			return -EINVAL;
 		else {
 			printk(KERN_WARNING "%s governor failed, too long"
 			       " transition latency of HW, fallback"
 			       " to %s governor\n",
 			       policy->governor->name,
 			       gov->name);
 			policy->governor = gov;
 		}
 	}
 	if (!try_module_get(policy->governor->owner))
 		return -EINVAL;
 	pr_debug("__cpufreq_governor for CPU %u, event %u\n",
 						policy->cpu, event);
 	ret = policy->governor->governor(policy, event);
 	if (!ret) {
 		if (event == CPUFREQ_GOV_POLICY_INIT)
 			policy->governor->initialized++;
 		else if (event == CPUFREQ_GOV_POLICY_EXIT)
 			policy->governor->initialized--;
 	}
 	/* we keep one module reference alive for
 			each CPU governed by this CPU */
 	if ((event != CPUFREQ_GOV_START) || ret)
 		module_put(policy->governor->owner);
 	if ((event == CPUFREQ_GOV_STOP) && !ret)
 		module_put(policy->governor->owner);
 	return ret;
 }
 int cpufreq_register_governor(struct cpufreq_governor *governor)
 {
 	int err;
 	if (!governor)
 		return -EINVAL;
 	if (cpufreq_disabled())
 		return -ENODEV;
 	mutex_lock(&cpufreq_governor_mutex);
 	governor->initialized = 0;
 	err = -EBUSY;
 	if (__find_governor(governor->name) == NULL) {
 		err = 0;
 		list_add(&governor->governor_list, &cpufreq_governor_list);
 	}
 	mutex_unlock(&cpufreq_governor_mutex);
 	return err;
 }
 EXPORT_SYMBOL_GPL(cpufreq_register_governor);
 void cpufreq_unregister_governor(struct cpufreq_governor *governor)
 {
 #ifdef CONFIG_HOTPLUG_CPU
 	int cpu;
 #endif
 	if (!governor)
 		return;
 	if (cpufreq_disabled())
 		return;
 #ifdef CONFIG_HOTPLUG_CPU
 	for_each_present_cpu(cpu) {
 		if (cpu_online(cpu))
 			continue;
 		if (!strcmp(per_cpu(cpufreq_cpu_governor, cpu), governor->name))
 			strcpy(per_cpu(cpufreq_cpu_governor, cpu), "\0");
 	}
 #endif
 	mutex_lock(&cpufreq_governor_mutex);
 	list_del(&governor->governor_list);
 	mutex_unlock(&cpufreq_governor_mutex);
 	return;
 }
 EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
 /*********************************************************************
  *                          POLICY INTERFACE                         *
  *********************************************************************/
 /**
  * cpufreq_get_policy - get the current cpufreq_policy
  * @policy: struct cpufreq_policy into which the current cpufreq_policy
  *	is written
  *
  * Reads the current cpufreq policy.
  */
 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
 {
 	struct cpufreq_policy *cpu_policy;
 	if (!policy)
 		return -EINVAL;
 	cpu_policy = cpufreq_cpu_get(cpu);
 	if (!cpu_policy)
 		return -EINVAL;
 	memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
 	cpufreq_cpu_put(cpu_policy);
 	return 0;
 }
 EXPORT_SYMBOL(cpufreq_get_policy);
 /*
  * data   : current policy.
  * policy : policy to be set.
  */
 static int __cpufreq_set_policy(struct cpufreq_policy *data,
 				struct cpufreq_policy *policy)
 {
 	int ret = 0, failed = 1;
 	pr_debug("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
 		policy->min, policy->max);
 	memcpy(&policy->cpuinfo, &data->cpuinfo,
 				sizeof(struct cpufreq_cpuinfo));
 	if (policy->min > data->max || policy->max < data->min) {
 		ret = -EINVAL;
 		goto error_out;
 	}
 	/* verify the cpu speed can be set within this limit */
 	ret = cpufreq_driver->verify(policy);
 	if (ret)
 		goto error_out;
 	/* adjust if necessary - all reasons */
 	blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
 			CPUFREQ_ADJUST, policy);
 	/* adjust if necessary - hardware incompatibility*/
 	blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
 			CPUFREQ_INCOMPATIBLE, policy);
 	/* verify the cpu speed can be set within this limit,
 	   which might be different to the first one */
 	ret = cpufreq_driver->verify(policy);
 	if (ret)
 		goto error_out;
 	/* notification of the new policy */
 	blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
 			CPUFREQ_NOTIFY, policy);
 	data->min = policy->min;
 	data->max = policy->max;
 	pr_debug("new min and max freqs are %u - %u kHz\n",
 					data->min, data->max);
 	if (cpufreq_driver->setpolicy) {
 		data->policy = policy->policy;
 		pr_debug("setting range\n");
 		ret = cpufreq_driver->setpolicy(policy);
 	} else {
 		if (policy->governor != data->governor) {
 			/* save old, working values */
 			struct cpufreq_governor *old_gov = data->governor;
 			pr_debug("governor switch\n");
 			/* end old governor */
 			if (data->governor) {
 				__cpufreq_governor(data, CPUFREQ_GOV_STOP);
 				unlock_policy_rwsem_write(policy->cpu);
 				__cpufreq_governor(data,
 						CPUFREQ_GOV_POLICY_EXIT);
 				lock_policy_rwsem_write(policy->cpu);
 			}
 			/* start new governor */
 			data->governor = policy->governor;
 			if (!__cpufreq_governor(data, CPUFREQ_GOV_POLICY_INIT)) {
 				if (!__cpufreq_governor(data, CPUFREQ_GOV_START)) {
 					failed = 0;
 				} else {
 					unlock_policy_rwsem_write(policy->cpu);
 					__cpufreq_governor(data,
 							CPUFREQ_GOV_POLICY_EXIT);
 					lock_policy_rwsem_write(policy->cpu);
 				}
 			}
 			if (failed) {
 				/* new governor failed, so re-start old one */
 				pr_debug("starting governor %s failed\n",
 							data->governor->name);
 				if (old_gov) {
 					data->governor = old_gov;
 					__cpufreq_governor(data,
 							CPUFREQ_GOV_POLICY_INIT);
 					__cpufreq_governor(data,
 							   CPUFREQ_GOV_START);
 				}
 				ret = -EINVAL;
 				goto error_out;
 			}
 			/* might be a policy change, too, so fall through */
 		}
 		pr_debug("governor: change or update limits\n");
 		__cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
 	}
 error_out:
 	return ret;
 }
 /**
  *	cpufreq_update_policy - re-evaluate an existing cpufreq policy
  *	@cpu: CPU which shall be re-evaluated
  *
  *	Useful for policy notifiers which have different necessities
  *	at different times.
  */
 int cpufreq_update_policy(unsigned int cpu)
 {
 	struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
 	struct cpufreq_policy policy;
 	int ret;
 	if (!data) {
 		ret = -ENODEV;
 		goto no_policy;
 	}
 	if (unlikely(lock_policy_rwsem_write(cpu))) {
 		ret = -EINVAL;
 		goto fail;
 	}
 	pr_debug("updating policy for CPU %u\n", cpu);
 	memcpy(&policy, data, sizeof(struct cpufreq_policy));
 	policy.min = data->user_policy.min;
 	policy.max = data->user_policy.max;
 	policy.policy = data->user_policy.policy;
 	policy.governor = data->user_policy.governor;
 	/* BIOS might change freq behind our back
 	  -> ask driver for current freq and notify governors about a change */
 	if (cpufreq_driver->get) {
 		policy.cur = cpufreq_driver->get(cpu);
 		if (!data->cur) {
 			pr_debug("Driver did not initialize current freq");
 			data->cur = policy.cur;
 		} else {
 			if (data->cur != policy.cur && cpufreq_driver->target)
 				cpufreq_out_of_sync(cpu, data->cur,
 								policy.cur);
 		}
 	}
 	ret = __cpufreq_set_policy(data, &policy);
 	unlock_policy_rwsem_write(cpu);
 fail:
 	cpufreq_cpu_put(data);
 no_policy:
 	return ret;
 }
 EXPORT_SYMBOL(cpufreq_update_policy);
 static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
 					unsigned long action, void *hcpu)
 {
 	unsigned int cpu = (unsigned long)hcpu;
 	struct device *dev;
 	dev = get_cpu_device(cpu);
 	if (dev) {
 		switch (action) {
 		case CPU_ONLINE:
 			cpufreq_add_dev(dev, NULL);
 			break;
 		case CPU_DOWN_PREPARE:
 		case CPU_UP_CANCELED_FROZEN:
 			__cpufreq_remove_dev(dev, NULL);
 			break;
 		case CPU_DOWN_FAILED:
 			cpufreq_add_dev(dev, NULL);
 			break;
 		}
 	}
 	return NOTIFY_OK;
 }
 static struct notifier_block __refdata cpufreq_cpu_notifier = {
     .notifier_call = cpufreq_cpu_callback,
 };
 /*********************************************************************
  *               REGISTER / UNREGISTER CPUFREQ DRIVER                *
  *********************************************************************/
 /**
  * cpufreq_register_driver - register a CPU Frequency driver
  * @driver_data: A struct cpufreq_driver containing the values#
  * submitted by the CPU Frequency driver.
  *
  *   Registers a CPU Frequency driver to this core code. This code
  * returns zero on success, -EBUSY when another driver got here first
  * (and isn't unregistered in the meantime).
  *
  */
 int cpufreq_register_driver(struct cpufreq_driver *driver_data)
 {
 	unsigned long flags;
 	int ret;
 	if (cpufreq_disabled())
 		return -ENODEV;
 	if (!driver_data || !driver_data->verify || !driver_data->init ||
 	    ((!driver_data->setpolicy) && (!driver_data->target)))
 		return -EINVAL;
 	pr_debug("trying to register driver %s\n", driver_data->name);
 	if (driver_data->setpolicy)
 		driver_data->flags |= CPUFREQ_CONST_LOOPS;
 	write_lock_irqsave(&cpufreq_driver_lock, flags);
 	if (cpufreq_driver) {
 		write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 		return -EBUSY;
 	}
 	cpufreq_driver = driver_data;
 	write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 	ret = subsys_interface_register(&cpufreq_interface);
 	if (ret)
 		goto err_null_driver;
 	if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) {
 		int i;
 		ret = -ENODEV;
 		/* check for at least one working CPU */
 		for (i = 0; i < nr_cpu_ids; i++)
 			if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
 				ret = 0;
 				break;
 			}
 		/* if all ->init() calls failed, unregister */
 		if (ret) {
 			pr_debug("no CPU initialized for driver %s\n",
 							driver_data->name);
 			goto err_if_unreg;
 		}
 	}
 	register_hotcpu_notifier(&cpufreq_cpu_notifier);
 	pr_debug("driver %s up and running\n", driver_data->name);
 	return 0;
 err_if_unreg:
 	subsys_interface_unregister(&cpufreq_interface);
 err_null_driver:
 	write_lock_irqsave(&cpufreq_driver_lock, flags);
 	cpufreq_driver = NULL;
 	write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(cpufreq_register_driver);
 /**
  * cpufreq_unregister_driver - unregister the current CPUFreq driver
  *
  *    Unregister the current CPUFreq driver. Only call this if you have
  * the right to do so, i.e. if you have succeeded in initialising before!
  * Returns zero if successful, and -EINVAL if the cpufreq_driver is
  * currently not initialised.
  */
 int cpufreq_unregister_driver(struct cpufreq_driver *driver)
 {
 	unsigned long flags;
 	if (!cpufreq_driver || (driver != cpufreq_driver))
 		return -EINVAL;
 	pr_debug("unregistering driver %s\n", driver->name);
 	subsys_interface_unregister(&cpufreq_interface);
 	unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
 	write_lock_irqsave(&cpufreq_driver_lock, flags);
 	cpufreq_driver = NULL;
 	write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
 static int __init cpufreq_core_init(void)
 {
 	int cpu;
 	if (cpufreq_disabled())
 		return -ENODEV;
 	for_each_possible_cpu(cpu) {
 		per_cpu(cpufreq_policy_cpu, cpu) = -1;
 		init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
 	}
-	cpufreq_global_kobject = kobject_create_and_add("cpufreq", &cpu_subsys.dev_root->kobj);
+	cpufreq_global_kobject = kobject_create();
 	BUG_ON(!cpufreq_global_kobject);
 	register_syscore_ops(&cpufreq_syscore_ops);
 	return 0;

drivers/cpufreq/cpufreq_governor.c

Diff comments View file @ 2361be2

 /*
  * drivers/cpufreq/cpufreq_governor.c
  *
  * CPUFREQ governors common code
  *
  * Copyright	(C) 2001 Russell King
  *		(C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
  *		(C) 2003 Jun Nakajima <jun.nakajima@intel.com>
  *		(C) 2009 Alexander Clouter <alex@digriz.org.uk>
  *		(c) 2012 Viresh Kumar <viresh.kumar@linaro.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <asm/cputime.h>
 #include <linux/cpufreq.h>
 #include <linux/cpumask.h>
 #include <linux/export.h>
 #include <linux/kernel_stat.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/workqueue.h>
 #include "cpufreq_governor.h"
 static struct attribute_group *get_sysfs_attr(struct dbs_data *dbs_data)
 {
 	if (have_governor_per_policy())
 		return dbs_data->cdata->attr_group_gov_pol;
 	else
 		return dbs_data->cdata->attr_group_gov_sys;
 }
 void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
 {
 	struct cpu_dbs_common_info *cdbs = dbs_data->cdata->get_cpu_cdbs(cpu);
 	struct od_dbs_tuners *od_tuners = dbs_data->tuners;
 	struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
 	struct cpufreq_policy *policy;
 	unsigned int max_load = 0;
 	unsigned int ignore_nice;
 	unsigned int j;
 	if (dbs_data->cdata->governor == GOV_ONDEMAND)
 		ignore_nice = od_tuners->ignore_nice;
 	else
 		ignore_nice = cs_tuners->ignore_nice;
 	policy = cdbs->cur_policy;
 	/* Get Absolute Load (in terms of freq for ondemand gov) */
 	for_each_cpu(j, policy->cpus) {
 		struct cpu_dbs_common_info *j_cdbs;
 		u64 cur_wall_time, cur_idle_time;
 		unsigned int idle_time, wall_time;
 		unsigned int load;
 		int io_busy = 0;
 		j_cdbs = dbs_data->cdata->get_cpu_cdbs(j);
 		/*
 		 * For the purpose of ondemand, waiting for disk IO is
 		 * an indication that you're performance critical, and
 		 * not that the system is actually idle. So do not add
 		 * the iowait time to the cpu idle time.
 		 */
 		if (dbs_data->cdata->governor == GOV_ONDEMAND)
 			io_busy = od_tuners->io_is_busy;
 		cur_idle_time = get_cpu_idle_time(j, &cur_wall_time, io_busy);
 		wall_time = (unsigned int)
 			(cur_wall_time - j_cdbs->prev_cpu_wall);
 		j_cdbs->prev_cpu_wall = cur_wall_time;
 		idle_time = (unsigned int)
 			(cur_idle_time - j_cdbs->prev_cpu_idle);
 		j_cdbs->prev_cpu_idle = cur_idle_time;
 		if (ignore_nice) {
 			u64 cur_nice;
 			unsigned long cur_nice_jiffies;
 			cur_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE] -
 					 cdbs->prev_cpu_nice;
 			/*
 			 * Assumption: nice time between sampling periods will
 			 * be less than 2^32 jiffies for 32 bit sys
 			 */
 			cur_nice_jiffies = (unsigned long)
 					cputime64_to_jiffies64(cur_nice);
 			cdbs->prev_cpu_nice =
 				kcpustat_cpu(j).cpustat[CPUTIME_NICE];
 			idle_time += jiffies_to_usecs(cur_nice_jiffies);
 		}
 		if (unlikely(!wall_time || wall_time < idle_time))
 			continue;
 		load = 100 * (wall_time - idle_time) / wall_time;
 		if (dbs_data->cdata->governor == GOV_ONDEMAND) {
 			int freq_avg = __cpufreq_driver_getavg(policy, j);
 			if (freq_avg <= 0)
 				freq_avg = policy->cur;
 			load *= freq_avg;
 		}
 		if (load > max_load)
 			max_load = load;
 	}
 	dbs_data->cdata->gov_check_cpu(cpu, max_load);
 }
 EXPORT_SYMBOL_GPL(dbs_check_cpu);
 static inline void __gov_queue_work(int cpu, struct dbs_data *dbs_data,
 		unsigned int delay)
 {
 	struct cpu_dbs_common_info *cdbs = dbs_data->cdata->get_cpu_cdbs(cpu);
 	mod_delayed_work_on(cpu, system_wq, &cdbs->work, delay);
 }
 void gov_queue_work(struct dbs_data *dbs_data, struct cpufreq_policy *policy,
 		unsigned int delay, bool all_cpus)
 {
 	int i;
 	if (!all_cpus) {
 		__gov_queue_work(smp_processor_id(), dbs_data, delay);
 	} else {
 		for_each_cpu(i, policy->cpus)
 			__gov_queue_work(i, dbs_data, delay);
 	}
 }
 EXPORT_SYMBOL_GPL(gov_queue_work);
 static inline void gov_cancel_work(struct dbs_data *dbs_data,
 		struct cpufreq_policy *policy)
 {
 	struct cpu_dbs_common_info *cdbs;
 	int i;
 	for_each_cpu(i, policy->cpus) {
 		cdbs = dbs_data->cdata->get_cpu_cdbs(i);
 		cancel_delayed_work_sync(&cdbs->work);
 	}
 }
 /* Will return if we need to evaluate cpu load again or not */
 bool need_load_eval(struct cpu_dbs_common_info *cdbs,
 		unsigned int sampling_rate)
 {
 	if (policy_is_shared(cdbs->cur_policy)) {
 		ktime_t time_now = ktime_get();
 		s64 delta_us = ktime_us_delta(time_now, cdbs->time_stamp);
 		/* Do nothing if we recently have sampled */
 		if (delta_us < (s64)(sampling_rate / 2))
 			return false;
 		else
 			cdbs->time_stamp = time_now;
 	}
 	return true;
 }
 EXPORT_SYMBOL_GPL(need_load_eval);
 static void set_sampling_rate(struct dbs_data *dbs_data,
 		unsigned int sampling_rate)
 {
 	if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
 		struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
 		cs_tuners->sampling_rate = sampling_rate;
 	} else {
 		struct od_dbs_tuners *od_tuners = dbs_data->tuners;
 		od_tuners->sampling_rate = sampling_rate;
 	}
 }
 int cpufreq_governor_dbs(struct cpufreq_policy *policy,
 		struct common_dbs_data *cdata, unsigned int event)
 {
 	struct dbs_data *dbs_data;
 	struct od_cpu_dbs_info_s *od_dbs_info = NULL;
 	struct cs_cpu_dbs_info_s *cs_dbs_info = NULL;
 	struct od_ops *od_ops = NULL;
 	struct od_dbs_tuners *od_tuners = NULL;
 	struct cs_dbs_tuners *cs_tuners = NULL;
 	struct cpu_dbs_common_info *cpu_cdbs;
 	unsigned int sampling_rate, latency, ignore_nice, j, cpu = policy->cpu;
 	int io_busy = 0;
 	int rc;
 	if (have_governor_per_policy())
 		dbs_data = policy->governor_data;
 	else
 		dbs_data = cdata->gdbs_data;
 	WARN_ON(!dbs_data && (event != CPUFREQ_GOV_POLICY_INIT));
 	switch (event) {
 	case CPUFREQ_GOV_POLICY_INIT:
 		if (have_governor_per_policy()) {
 			WARN_ON(dbs_data);
 		} else if (dbs_data) {
 			dbs_data->usage_count++;
 			policy->governor_data = dbs_data;
 			return 0;
 		}
 		dbs_data = kzalloc(sizeof(*dbs_data), GFP_KERNEL);
 		if (!dbs_data) {
 			pr_err("%s: POLICY_INIT: kzalloc failed\n", __func__);
 			return -ENOMEM;
 		}
 		dbs_data->cdata = cdata;
 		dbs_data->usage_count = 1;
 		rc = cdata->init(dbs_data);
 		if (rc) {
 			pr_err("%s: POLICY_INIT: init() failed\n", __func__);
 			kfree(dbs_data);
 			return rc;
 		}
+		if (!have_governor_per_policy())
+			WARN_ON(cpufreq_get_global_kobject());
 		rc = sysfs_create_group(get_governor_parent_kobj(policy),
 				get_sysfs_attr(dbs_data));
 		if (rc) {
 			cdata->exit(dbs_data);
 			kfree(dbs_data);
 			return rc;
 		}
 		policy->governor_data = dbs_data;
 		/* policy latency is in nS. Convert it to uS first */
 		latency = policy->cpuinfo.transition_latency / 1000;
 		if (latency == 0)
 			latency = 1;
 		/* Bring kernel and HW constraints together */
 		dbs_data->min_sampling_rate = max(dbs_data->min_sampling_rate,
 				MIN_LATENCY_MULTIPLIER * latency);
 		set_sampling_rate(dbs_data, max(dbs_data->min_sampling_rate,
 					latency * LATENCY_MULTIPLIER));
 		if ((cdata->governor == GOV_CONSERVATIVE) &&
 				(!policy->governor->initialized)) {
 			struct cs_ops *cs_ops = dbs_data->cdata->gov_ops;
 			cpufreq_register_notifier(cs_ops->notifier_block,
 					CPUFREQ_TRANSITION_NOTIFIER);
 		}
 		if (!have_governor_per_policy())
 			cdata->gdbs_data = dbs_data;
 		return 0;
 	case CPUFREQ_GOV_POLICY_EXIT:
 		if (!--dbs_data->usage_count) {
 			sysfs_remove_group(get_governor_parent_kobj(policy),
 					get_sysfs_attr(dbs_data));
+			if (!have_governor_per_policy())
+				cpufreq_put_global_kobject();
 			if ((dbs_data->cdata->governor == GOV_CONSERVATIVE) &&
 				(policy->governor->initialized == 1)) {
 				struct cs_ops *cs_ops = dbs_data->cdata->gov_ops;
 				cpufreq_unregister_notifier(cs_ops->notifier_block,
 						CPUFREQ_TRANSITION_NOTIFIER);
 			}
 			cdata->exit(dbs_data);
 			kfree(dbs_data);
 			cdata->gdbs_data = NULL;
 		}
 		policy->governor_data = NULL;
 		return 0;
 	}
 	cpu_cdbs = dbs_data->cdata->get_cpu_cdbs(cpu);
 	if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
 		cs_tuners = dbs_data->tuners;
 		cs_dbs_info = dbs_data->cdata->get_cpu_dbs_info_s(cpu);
 		sampling_rate = cs_tuners->sampling_rate;
 		ignore_nice = cs_tuners->ignore_nice;
 	} else {
 		od_tuners = dbs_data->tuners;
 		od_dbs_info = dbs_data->cdata->get_cpu_dbs_info_s(cpu);
 		sampling_rate = od_tuners->sampling_rate;
 		ignore_nice = od_tuners->ignore_nice;
 		od_ops = dbs_data->cdata->gov_ops;
 		io_busy = od_tuners->io_is_busy;
 	}
 	switch (event) {
 	case CPUFREQ_GOV_START:
 		if (!policy->cur)
 			return -EINVAL;
 		mutex_lock(&dbs_data->mutex);
 		for_each_cpu(j, policy->cpus) {
 			struct cpu_dbs_common_info *j_cdbs =
 				dbs_data->cdata->get_cpu_cdbs(j);
 			j_cdbs->cpu = j;
 			j_cdbs->cur_policy = policy;
 			j_cdbs->prev_cpu_idle = get_cpu_idle_time(j,
 					       &j_cdbs->prev_cpu_wall, io_busy);
 			if (ignore_nice)
 				j_cdbs->prev_cpu_nice =
 					kcpustat_cpu(j).cpustat[CPUTIME_NICE];
 			mutex_init(&j_cdbs->timer_mutex);
 			INIT_DEFERRABLE_WORK(&j_cdbs->work,
 					     dbs_data->cdata->gov_dbs_timer);
 		}
 		/*
 		 * conservative does not implement micro like ondemand
 		 * governor, thus we are bound to jiffes/HZ
 		 */
 		if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
 			cs_dbs_info->down_skip = 0;
 			cs_dbs_info->enable = 1;
 			cs_dbs_info->requested_freq = policy->cur;
 		} else {
 			od_dbs_info->rate_mult = 1;
 			od_dbs_info->sample_type = OD_NORMAL_SAMPLE;
 			od_ops->powersave_bias_init_cpu(cpu);
 		}
 		mutex_unlock(&dbs_data->mutex);
 		/* Initiate timer time stamp */
 		cpu_cdbs->time_stamp = ktime_get();
 		gov_queue_work(dbs_data, policy,
 				delay_for_sampling_rate(sampling_rate), true);
 		break;
 	case CPUFREQ_GOV_STOP:
 		if (dbs_data->cdata->governor == GOV_CONSERVATIVE)
 			cs_dbs_info->enable = 0;
 		gov_cancel_work(dbs_data, policy);
 		mutex_lock(&dbs_data->mutex);
 		mutex_destroy(&cpu_cdbs->timer_mutex);
 		mutex_unlock(&dbs_data->mutex);
 		break;
 	case CPUFREQ_GOV_LIMITS:
 		mutex_lock(&cpu_cdbs->timer_mutex);
 		if (policy->max < cpu_cdbs->cur_policy->cur)
 			__cpufreq_driver_target(cpu_cdbs->cur_policy,
 					policy->max, CPUFREQ_RELATION_H);
 		else if (policy->min > cpu_cdbs->cur_policy->cur)
 			__cpufreq_driver_target(cpu_cdbs->cur_policy,
 					policy->min, CPUFREQ_RELATION_L);
 		dbs_check_cpu(dbs_data, cpu);
 		mutex_unlock(&cpu_cdbs->timer_mutex);
 		break;
 	}
 	return 0;
 }
 EXPORT_SYMBOL_GPL(cpufreq_governor_dbs);

include/linux/cpufreq.h

Diff comments View file @ 2361be2

 /*
  *  linux/include/linux/cpufreq.h
  *
  *  Copyright (C) 2001 Russell King
  *            (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #ifndef _LINUX_CPUFREQ_H
 #define _LINUX_CPUFREQ_H
 #include <asm/cputime.h>
 #include <linux/mutex.h>
 #include <linux/notifier.h>
 #include <linux/threads.h>
 #include <linux/kobject.h>
 #include <linux/sysfs.h>
 #include <linux/completion.h>
 #include <linux/workqueue.h>
 #include <linux/cpumask.h>
 #include <asm/div64.h>
 #define CPUFREQ_NAME_LEN 16
 /* Print length for names. Extra 1 space for accomodating '\n' in prints */
 #define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
 /*********************************************************************
  *                     CPUFREQ NOTIFIER INTERFACE                    *
  *********************************************************************/
 #define CPUFREQ_TRANSITION_NOTIFIER	(0)
 #define CPUFREQ_POLICY_NOTIFIER		(1)
 #ifdef CONFIG_CPU_FREQ
 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
 extern void disable_cpufreq(void);
 #else		/* CONFIG_CPU_FREQ */
 static inline int cpufreq_register_notifier(struct notifier_block *nb,
 						unsigned int list)
 {
 	return 0;
 }
 static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
 						unsigned int list)
 {
 	return 0;
 }
 static inline void disable_cpufreq(void) { }
 #endif		/* CONFIG_CPU_FREQ */
 /* if (cpufreq_driver->target) exists, the ->governor decides what frequency
  * within the limits is used. If (cpufreq_driver->setpolicy> exists, these
  * two generic policies are available:
  */
 #define CPUFREQ_POLICY_POWERSAVE	(1)
 #define CPUFREQ_POLICY_PERFORMANCE	(2)
 /* Frequency values here are CPU kHz so that hardware which doesn't run
  * with some frequencies can complain without having to guess what per
  * cent / per mille means.
  * Maximum transition latency is in nanoseconds - if it's unknown,
  * CPUFREQ_ETERNAL shall be used.
  */
 struct cpufreq_governor;
 /* /sys/devices/system/cpu/cpufreq: entry point for global variables */
 extern struct kobject *cpufreq_global_kobject;
+int cpufreq_get_global_kobject(void);
+void cpufreq_put_global_kobject(void);
+int cpufreq_sysfs_create_file(const struct attribute *attr);
+void cpufreq_sysfs_remove_file(const struct attribute *attr);
 #define CPUFREQ_ETERNAL			(-1)
 struct cpufreq_cpuinfo {
 	unsigned int		max_freq;
 	unsigned int		min_freq;
 	/* in 10^(-9) s = nanoseconds */
 	unsigned int		transition_latency;
 };
 struct cpufreq_real_policy {
 	unsigned int		min;    /* in kHz */
 	unsigned int		max;    /* in kHz */
 	unsigned int		policy; /* see above */
 	struct cpufreq_governor	*governor; /* see below */
 };
 struct cpufreq_policy {
 	/* CPUs sharing clock, require sw coordination */
 	cpumask_var_t		cpus;	/* Online CPUs only */
 	cpumask_var_t		related_cpus; /* Online + Offline CPUs */
 	unsigned int		shared_type; /* ACPI: ANY or ALL affected CPUs
 						should set cpufreq */
 	unsigned int		cpu;    /* cpu nr of CPU managing this policy */
 	unsigned int		last_cpu; /* cpu nr of previous CPU that managed
 					   * this policy */
 	struct cpufreq_cpuinfo	cpuinfo;/* see above */
 	unsigned int		min;    /* in kHz */
 	unsigned int		max;    /* in kHz */
 	unsigned int		cur;    /* in kHz, only needed if cpufreq
 					 * governors are used */
 	unsigned int		policy; /* see above */
 	struct cpufreq_governor	*governor; /* see below */
 	void			*governor_data;
 	struct work_struct	update; /* if update_policy() needs to be
 					 * called, but you're in IRQ context */
 	struct cpufreq_real_policy	user_policy;
 	struct kobject		kobj;
 	struct completion	kobj_unregister;
 };
 #define CPUFREQ_ADJUST			(0)
 #define CPUFREQ_INCOMPATIBLE		(1)
 #define CPUFREQ_NOTIFY			(2)
 #define CPUFREQ_START			(3)
 #define CPUFREQ_UPDATE_POLICY_CPU	(4)
 /* Only for ACPI */
 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
 #define CPUFREQ_SHARED_TYPE_HW	 (1) /* HW does needed coordination */
 #define CPUFREQ_SHARED_TYPE_ALL	 (2) /* All dependent CPUs should set freq */
 #define CPUFREQ_SHARED_TYPE_ANY	 (3) /* Freq can be set from any dependent CPU*/
 static inline bool policy_is_shared(struct cpufreq_policy *policy)
 {
 	return cpumask_weight(policy->cpus) > 1;
 }
 /******************** cpufreq transition notifiers *******************/
 #define CPUFREQ_PRECHANGE	(0)
 #define CPUFREQ_POSTCHANGE	(1)
 #define CPUFREQ_RESUMECHANGE	(8)
 #define CPUFREQ_SUSPENDCHANGE	(9)
 struct cpufreq_freqs {
 	unsigned int cpu;	/* cpu nr */
 	unsigned int old;
 	unsigned int new;
 	u8 flags;		/* flags of cpufreq_driver, see below. */
 };
 /**
  * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch safe)
  * @old:   old value
  * @div:   divisor
  * @mult:  multiplier
  *
  *
  *    new = old * mult / div
  */
 static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mult)
 {
 #if BITS_PER_LONG == 32
 	u64 result = ((u64) old) * ((u64) mult);
 	do_div(result, div);
 	return (unsigned long) result;
 #elif BITS_PER_LONG == 64
 	unsigned long result = old * ((u64) mult);
 	result /= div;
 	return result;
 #endif
 };
 /*********************************************************************
  *                          CPUFREQ GOVERNORS                        *
  *********************************************************************/
 #define CPUFREQ_GOV_START	1
 #define CPUFREQ_GOV_STOP	2
 #define CPUFREQ_GOV_LIMITS	3
 #define CPUFREQ_GOV_POLICY_INIT	4
 #define CPUFREQ_GOV_POLICY_EXIT	5
 struct cpufreq_governor {
 	char	name[CPUFREQ_NAME_LEN];
 	int	initialized;
 	int	(*governor)	(struct cpufreq_policy *policy,
 				 unsigned int event);
 	ssize_t	(*show_setspeed)	(struct cpufreq_policy *policy,
 					 char *buf);
 	int	(*store_setspeed)	(struct cpufreq_policy *policy,
 					 unsigned int freq);
 	unsigned int max_transition_latency; /* HW must be able to switch to
 			next freq faster than this value in nano secs or we
 			will fallback to performance governor */
 	struct list_head	governor_list;
 	struct module		*owner;
 };
 /*
  * Pass a target to the cpufreq driver.
  */
 extern int cpufreq_driver_target(struct cpufreq_policy *policy,
 				 unsigned int target_freq,
 				 unsigned int relation);
 extern int __cpufreq_driver_target(struct cpufreq_policy *policy,
 				   unsigned int target_freq,
 				   unsigned int relation);
 extern int __cpufreq_driver_getavg(struct cpufreq_policy *policy,
 				   unsigned int cpu);
 int cpufreq_register_governor(struct cpufreq_governor *governor);
 void cpufreq_unregister_governor(struct cpufreq_governor *governor);
 /*********************************************************************
  *                      CPUFREQ DRIVER INTERFACE                     *
  *********************************************************************/
 #define CPUFREQ_RELATION_L 0  /* lowest frequency at or above target */
 #define CPUFREQ_RELATION_H 1  /* highest frequency below or at target */
 struct freq_attr;
 struct cpufreq_driver {
 	struct module           *owner;
 	char			name[CPUFREQ_NAME_LEN];
 	u8			flags;
 	/*
 	 * This should be set by platforms having multiple clock-domains, i.e.
 	 * supporting multiple policies. With this sysfs directories of governor
 	 * would be created in cpu/cpu<num>/cpufreq/ directory and so they can
 	 * use the same governor with different tunables for different clusters.
 	 */
 	bool			have_governor_per_policy;
 	/* needed by all drivers */
 	int	(*init)		(struct cpufreq_policy *policy);
 	int	(*verify)	(struct cpufreq_policy *policy);
 	/* define one out of two */
 	int	(*setpolicy)	(struct cpufreq_policy *policy);
 	int	(*target)	(struct cpufreq_policy *policy,
 				 unsigned int target_freq,
 				 unsigned int relation);
 	/* should be defined, if possible */
 	unsigned int	(*get)	(unsigned int cpu);
 	/* optional */
 	unsigned int (*getavg)	(struct cpufreq_policy *policy,
 				 unsigned int cpu);
 	int	(*bios_limit)	(int cpu, unsigned int *limit);
 	int	(*exit)		(struct cpufreq_policy *policy);
 	int	(*suspend)	(struct cpufreq_policy *policy);
 	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 */
 #define CPUFREQ_CONST_LOOPS	0x02	/* loops_per_jiffy or other kernel
 					 * "constants" aren't affected by
 					 * frequency transitions */
 #define CPUFREQ_PM_NO_WARN	0x04	/* don't warn on suspend/resume speed
 					 * mismatches */
 int cpufreq_register_driver(struct cpufreq_driver *driver_data);
 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
 void cpufreq_notify_transition(struct cpufreq_policy *policy,
 		struct cpufreq_freqs *freqs, unsigned int state);
 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned int min, unsigned int max)
 {
 	if (policy->min < min)
 		policy->min = min;
 	if (policy->max < min)
 		policy->max = min;
 	if (policy->min > max)
 		policy->min = max;
 	if (policy->max > max)
 		policy->max = max;
 	if (policy->min > policy->max)
 		policy->min = policy->max;
 	return;
 }
 struct freq_attr {
 	struct attribute attr;
 	ssize_t (*show)(struct cpufreq_policy *, char *);
 	ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
 };
 #define cpufreq_freq_attr_ro(_name)		\
 static struct freq_attr _name =			\
 __ATTR(_name, 0444, show_##_name, NULL)
 #define cpufreq_freq_attr_ro_perm(_name, _perm)	\
 static struct freq_attr _name =			\
 __ATTR(_name, _perm, show_##_name, NULL)
 #define cpufreq_freq_attr_rw(_name)		\
 static struct freq_attr _name =			\
 __ATTR(_name, 0644, show_##_name, store_##_name)
 struct global_attr {
 	struct attribute attr;
 	ssize_t (*show)(struct kobject *kobj,
 			struct attribute *attr, char *buf);
 	ssize_t (*store)(struct kobject *a, struct attribute *b,
 			 const char *c, size_t count);
 };
 #define define_one_global_ro(_name)		\
 static struct global_attr _name =		\
 __ATTR(_name, 0444, show_##_name, NULL)
 #define define_one_global_rw(_name)		\
 static struct global_attr _name =		\
 __ATTR(_name, 0644, show_##_name, store_##_name)
 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
 void cpufreq_cpu_put(struct cpufreq_policy *data);
 const char *cpufreq_get_current_driver(void);
 /*********************************************************************
  *                        CPUFREQ 2.6. INTERFACE                     *
  *********************************************************************/
 u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
 int cpufreq_update_policy(unsigned int cpu);
 bool have_governor_per_policy(void);
 struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
 #ifdef CONFIG_CPU_FREQ
 /* query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it */
 unsigned int cpufreq_get(unsigned int cpu);
 #else
 static inline unsigned int cpufreq_get(unsigned int cpu)
 {
 	return 0;
 }
 #endif
 /* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it */
 #ifdef CONFIG_CPU_FREQ
 unsigned int cpufreq_quick_get(unsigned int cpu);
 unsigned int cpufreq_quick_get_max(unsigned int cpu);
 #else
 static inline unsigned int cpufreq_quick_get(unsigned int cpu)
 {
 	return 0;
 }
 static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
 {
 	return 0;
 }
 #endif
 /*********************************************************************
  *                       CPUFREQ DEFAULT GOVERNOR                    *
  *********************************************************************/
 /*
   Performance governor is fallback governor if any other gov failed to
   auto load due latency restrictions
 */
 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
 extern struct cpufreq_governor cpufreq_gov_performance;
 #endif
 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
 #define CPUFREQ_DEFAULT_GOVERNOR	(&cpufreq_gov_performance)
 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE)
 extern struct cpufreq_governor cpufreq_gov_powersave;
 #define CPUFREQ_DEFAULT_GOVERNOR	(&cpufreq_gov_powersave)
 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
 extern struct cpufreq_governor cpufreq_gov_userspace;
 #define CPUFREQ_DEFAULT_GOVERNOR	(&cpufreq_gov_userspace)
 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND)
 extern struct cpufreq_governor cpufreq_gov_ondemand;
 #define CPUFREQ_DEFAULT_GOVERNOR	(&cpufreq_gov_ondemand)
 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE)
 extern struct cpufreq_governor cpufreq_gov_conservative;
 #define CPUFREQ_DEFAULT_GOVERNOR	(&cpufreq_gov_conservative)
 #endif
 /*********************************************************************
  *                     FREQUENCY TABLE HELPERS                       *
  *********************************************************************/
 #define CPUFREQ_ENTRY_INVALID ~0
 #define CPUFREQ_TABLE_END     ~1
 struct cpufreq_frequency_table {
 	unsigned int	index;     /* any */
 	unsigned int	frequency; /* kHz - doesn't need to be in ascending
 				    * order */
 };
 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
 				    struct cpufreq_frequency_table *table);
 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
 				   struct cpufreq_frequency_table *table);
 int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
 				   struct cpufreq_frequency_table *table,
 				   unsigned int target_freq,
 				   unsigned int relation,
 				   unsigned int *index);
 /* the following 3 funtions are for cpufreq core use only */
 struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
 /* the following are really really optional */
 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
 				      unsigned int cpu);
 void cpufreq_frequency_table_update_policy_cpu(struct cpufreq_policy *policy);
 void cpufreq_frequency_table_put_attr(unsigned int cpu);
 #endif /* _LINUX_CPUFREQ_H */