blob: 65ac58511228907dd6f3197a24d7b698ca4cc751 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/cpufreq/cpufreq.c
3 *
4 * Copyright (C) 2001 Russell King
5 * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
6 *
Ashok Rajc32b6b82005-10-30 14:59:54 -08007 * Oct 2005 - Ashok Raj <ashok.raj@intel.com>
Dave Jones32ee8c32006-02-28 00:43:23 -05008 * Added handling for CPU hotplug
Dave Jones8ff69732006-03-05 03:37:23 -05009 * Feb 2006 - Jacob Shin <jacob.shin@amd.com>
10 * Fix handling for CPU hotplug -- affected CPUs
Ashok Rajc32b6b82005-10-30 14:59:54 -080011 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
15 *
16 */
17
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/kernel.h>
19#include <linux/module.h>
20#include <linux/init.h>
21#include <linux/notifier.h>
22#include <linux/cpufreq.h>
23#include <linux/delay.h>
24#include <linux/interrupt.h>
25#include <linux/spinlock.h>
26#include <linux/device.h>
27#include <linux/slab.h>
28#include <linux/cpu.h>
29#include <linux/completion.h>
akpm@osdl.org3fc54d32006-01-13 15:54:22 -080030#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
Gautham R Shenoye08f5f52006-10-26 16:20:58 +053032#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
33 "cpufreq-core", msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35/**
Dave Jonescd878472006-08-11 17:59:28 -040036 * The "cpufreq driver" - the arch- or hardware-dependent low
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 * level driver of CPUFreq support, and its spinlock. This lock
38 * also protects the cpufreq_cpu_data array.
39 */
Dave Jones7d5e3502006-02-02 17:03:42 -050040static struct cpufreq_driver *cpufreq_driver;
41static struct cpufreq_policy *cpufreq_cpu_data[NR_CPUS];
Thomas Renninger084f3492007-07-09 11:35:28 -070042#ifdef CONFIG_HOTPLUG_CPU
43/* This one keeps track of the previously set governor of a removed CPU */
44static struct cpufreq_governor *cpufreq_cpu_governor[NR_CPUS];
45#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070046static DEFINE_SPINLOCK(cpufreq_driver_lock);
47
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080048/*
49 * cpu_policy_rwsem is a per CPU reader-writer semaphore designed to cure
50 * all cpufreq/hotplug/workqueue/etc related lock issues.
51 *
52 * The rules for this semaphore:
53 * - Any routine that wants to read from the policy structure will
54 * do a down_read on this semaphore.
55 * - Any routine that will write to the policy structure and/or may take away
56 * the policy altogether (eg. CPU hotplug), will hold this lock in write
57 * mode before doing so.
58 *
59 * Additional rules:
60 * - All holders of the lock should check to make sure that the CPU they
61 * are concerned with are online after they get the lock.
62 * - Governor routines that can be called in cpufreq hotplug path should not
63 * take this sem as top level hotplug notifier handler takes this.
64 */
65static DEFINE_PER_CPU(int, policy_cpu);
66static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
67
68#define lock_policy_rwsem(mode, cpu) \
69int lock_policy_rwsem_##mode \
70(int cpu) \
71{ \
72 int policy_cpu = per_cpu(policy_cpu, cpu); \
73 BUG_ON(policy_cpu == -1); \
74 down_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
75 if (unlikely(!cpu_online(cpu))) { \
76 up_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
77 return -1; \
78 } \
79 \
80 return 0; \
81}
82
83lock_policy_rwsem(read, cpu);
84EXPORT_SYMBOL_GPL(lock_policy_rwsem_read);
85
86lock_policy_rwsem(write, cpu);
87EXPORT_SYMBOL_GPL(lock_policy_rwsem_write);
88
89void unlock_policy_rwsem_read(int cpu)
90{
91 int policy_cpu = per_cpu(policy_cpu, cpu);
92 BUG_ON(policy_cpu == -1);
93 up_read(&per_cpu(cpu_policy_rwsem, policy_cpu));
94}
95EXPORT_SYMBOL_GPL(unlock_policy_rwsem_read);
96
97void unlock_policy_rwsem_write(int cpu)
98{
99 int policy_cpu = per_cpu(policy_cpu, cpu);
100 BUG_ON(policy_cpu == -1);
101 up_write(&per_cpu(cpu_policy_rwsem, policy_cpu));
102}
103EXPORT_SYMBOL_GPL(unlock_policy_rwsem_write);
104
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106/* internal prototypes */
107static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800108static unsigned int __cpufreq_get(unsigned int cpu);
David Howells65f27f32006-11-22 14:55:48 +0000109static void handle_update(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111/**
Dave Jones32ee8c32006-02-28 00:43:23 -0500112 * Two notifier lists: the "policy" list is involved in the
113 * validation process for a new CPU frequency policy; the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 * "transition" list for kernel code that needs to handle
115 * changes to devices when the CPU clock speed changes.
116 * The mutex locks both lists.
117 */
Alan Sterne041c682006-03-27 01:16:30 -0800118static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700119static struct srcu_notifier_head cpufreq_transition_notifier_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700121static int __init init_cpufreq_transition_notifier_list(void)
122{
123 srcu_init_notifier_head(&cpufreq_transition_notifier_list);
124 return 0;
125}
Linus Torvaldsb3438f82006-11-20 11:47:18 -0800126pure_initcall(init_cpufreq_transition_notifier_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
128static LIST_HEAD(cpufreq_governor_list);
Dave Jones7d5e3502006-02-02 17:03:42 -0500129static DEFINE_MUTEX (cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
Dave Jones7d5e3502006-02-02 17:03:42 -0500131struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{
133 struct cpufreq_policy *data;
134 unsigned long flags;
135
136 if (cpu >= NR_CPUS)
137 goto err_out;
138
139 /* get the cpufreq driver */
140 spin_lock_irqsave(&cpufreq_driver_lock, flags);
141
142 if (!cpufreq_driver)
143 goto err_out_unlock;
144
145 if (!try_module_get(cpufreq_driver->owner))
146 goto err_out_unlock;
147
148
149 /* get the CPU */
150 data = cpufreq_cpu_data[cpu];
151
152 if (!data)
153 goto err_out_put_module;
154
155 if (!kobject_get(&data->kobj))
156 goto err_out_put_module;
157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 return data;
160
Dave Jones7d5e3502006-02-02 17:03:42 -0500161err_out_put_module:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 module_put(cpufreq_driver->owner);
Dave Jones7d5e3502006-02-02 17:03:42 -0500163err_out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Dave Jones7d5e3502006-02-02 17:03:42 -0500165err_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 return NULL;
167}
168EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
169
Dave Jones7d5e3502006-02-02 17:03:42 -0500170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171void cpufreq_cpu_put(struct cpufreq_policy *data)
172{
173 kobject_put(&data->kobj);
174 module_put(cpufreq_driver->owner);
175}
176EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
177
178
179/*********************************************************************
180 * UNIFIED DEBUG HELPERS *
181 *********************************************************************/
182#ifdef CONFIG_CPU_FREQ_DEBUG
183
184/* what part(s) of the CPUfreq subsystem are debugged? */
185static unsigned int debug;
186
187/* is the debug output ratelimit'ed using printk_ratelimit? User can
188 * set or modify this value.
189 */
190static unsigned int debug_ratelimit = 1;
191
192/* is the printk_ratelimit'ing enabled? It's enabled after a successful
193 * loading of a cpufreq driver, temporarily disabled when a new policy
194 * is set, and disabled upon cpufreq driver removal
195 */
196static unsigned int disable_ratelimit = 1;
197static DEFINE_SPINLOCK(disable_ratelimit_lock);
198
Arjan van de Ven858119e2006-01-14 13:20:43 -0800199static void cpufreq_debug_enable_ratelimit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
201 unsigned long flags;
202
203 spin_lock_irqsave(&disable_ratelimit_lock, flags);
204 if (disable_ratelimit)
205 disable_ratelimit--;
206 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
207}
208
Arjan van de Ven858119e2006-01-14 13:20:43 -0800209static void cpufreq_debug_disable_ratelimit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210{
211 unsigned long flags;
212
213 spin_lock_irqsave(&disable_ratelimit_lock, flags);
214 disable_ratelimit++;
215 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
216}
217
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530218void cpufreq_debug_printk(unsigned int type, const char *prefix,
219 const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220{
221 char s[256];
222 va_list args;
223 unsigned int len;
224 unsigned long flags;
Dave Jones32ee8c32006-02-28 00:43:23 -0500225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 WARN_ON(!prefix);
227 if (type & debug) {
228 spin_lock_irqsave(&disable_ratelimit_lock, flags);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530229 if (!disable_ratelimit && debug_ratelimit
230 && !printk_ratelimit()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
232 return;
233 }
234 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
235
236 len = snprintf(s, 256, KERN_DEBUG "%s: ", prefix);
237
238 va_start(args, fmt);
239 len += vsnprintf(&s[len], (256 - len), fmt, args);
240 va_end(args);
241
242 printk(s);
243
244 WARN_ON(len < 5);
245 }
246}
247EXPORT_SYMBOL(cpufreq_debug_printk);
248
249
250module_param(debug, uint, 0644);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530251MODULE_PARM_DESC(debug, "CPUfreq debugging: add 1 to debug core,"
252 " 2 to debug drivers, and 4 to debug governors.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254module_param(debug_ratelimit, uint, 0644);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530255MODULE_PARM_DESC(debug_ratelimit, "CPUfreq debugging:"
256 " set to 0 to disable ratelimiting.");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
258#else /* !CONFIG_CPU_FREQ_DEBUG */
259
260static inline void cpufreq_debug_enable_ratelimit(void) { return; }
261static inline void cpufreq_debug_disable_ratelimit(void) { return; }
262
263#endif /* CONFIG_CPU_FREQ_DEBUG */
264
265
266/*********************************************************************
267 * EXTERNALLY AFFECTING FREQUENCY CHANGES *
268 *********************************************************************/
269
270/**
271 * adjust_jiffies - adjust the system "loops_per_jiffy"
272 *
273 * This function alters the system "loops_per_jiffy" for the clock
274 * speed change. Note that loops_per_jiffy cannot be updated on SMP
Dave Jones32ee8c32006-02-28 00:43:23 -0500275 * systems as each CPU might be scaled differently. So, use the arch
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 * per-CPU loops_per_jiffy value wherever possible.
277 */
278#ifndef CONFIG_SMP
279static unsigned long l_p_j_ref;
280static unsigned int l_p_j_ref_freq;
281
Arjan van de Ven858119e2006-01-14 13:20:43 -0800282static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
284 if (ci->flags & CPUFREQ_CONST_LOOPS)
285 return;
286
287 if (!l_p_j_ref_freq) {
288 l_p_j_ref = loops_per_jiffy;
289 l_p_j_ref_freq = ci->old;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530290 dprintk("saving %lu as reference value for loops_per_jiffy;"
291 "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 }
293 if ((val == CPUFREQ_PRECHANGE && ci->old < ci->new) ||
294 (val == CPUFREQ_POSTCHANGE && ci->old > ci->new) ||
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -0700295 (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530296 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
297 ci->new);
298 dprintk("scaling loops_per_jiffy to %lu"
299 "for frequency %u kHz\n", loops_per_jiffy, ci->new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 }
301}
302#else
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530303static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
304{
305 return;
306}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307#endif
308
309
310/**
Dave Jonese4472cb2006-01-31 15:53:55 -0800311 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
312 * on frequency transition.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 *
Dave Jonese4472cb2006-01-31 15:53:55 -0800314 * This function calls the transition notifiers and the "adjust_jiffies"
315 * function. It is called twice on all CPU frequency changes that have
Dave Jones32ee8c32006-02-28 00:43:23 -0500316 * external effects.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 */
318void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
319{
Dave Jonese4472cb2006-01-31 15:53:55 -0800320 struct cpufreq_policy *policy;
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 BUG_ON(irqs_disabled());
323
324 freqs->flags = cpufreq_driver->flags;
Dave Jonese4472cb2006-01-31 15:53:55 -0800325 dprintk("notification %u of frequency transition to %u kHz\n",
326 state, freqs->new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
Dave Jonese4472cb2006-01-31 15:53:55 -0800328 policy = cpufreq_cpu_data[freqs->cpu];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 switch (state) {
Dave Jonese4472cb2006-01-31 15:53:55 -0800330
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 case CPUFREQ_PRECHANGE:
Dave Jones32ee8c32006-02-28 00:43:23 -0500332 /* detect if the driver reported a value as "old frequency"
Dave Jonese4472cb2006-01-31 15:53:55 -0800333 * which is not equal to what the cpufreq core thinks is
334 * "old frequency".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 */
336 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
Dave Jonese4472cb2006-01-31 15:53:55 -0800337 if ((policy) && (policy->cpu == freqs->cpu) &&
338 (policy->cur) && (policy->cur != freqs->old)) {
Jan Beulichb10eec22006-04-28 13:47:13 +0200339 dprintk("Warning: CPU frequency is"
Dave Jonese4472cb2006-01-31 15:53:55 -0800340 " %u, cpufreq assumed %u kHz.\n",
341 freqs->old, policy->cur);
342 freqs->old = policy->cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 }
344 }
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700345 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Alan Sterne041c682006-03-27 01:16:30 -0800346 CPUFREQ_PRECHANGE, freqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
348 break;
Dave Jonese4472cb2006-01-31 15:53:55 -0800349
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 case CPUFREQ_POSTCHANGE:
351 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700352 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Alan Sterne041c682006-03-27 01:16:30 -0800353 CPUFREQ_POSTCHANGE, freqs);
Dave Jonese4472cb2006-01-31 15:53:55 -0800354 if (likely(policy) && likely(policy->cpu == freqs->cpu))
355 policy->cur = freqs->new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 break;
357 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358}
359EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
360
361
362
363/*********************************************************************
364 * SYSFS INTERFACE *
365 *********************************************************************/
366
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700367static struct cpufreq_governor *__find_governor(const char *str_governor)
368{
369 struct cpufreq_governor *t;
370
371 list_for_each_entry(t, &cpufreq_governor_list, governor_list)
372 if (!strnicmp(str_governor,t->name,CPUFREQ_NAME_LEN))
373 return t;
374
375 return NULL;
376}
377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378/**
379 * cpufreq_parse_governor - parse a governor string
380 */
381static int cpufreq_parse_governor (char *str_governor, unsigned int *policy,
382 struct cpufreq_governor **governor)
383{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700384 int err = -EINVAL;
385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 if (!cpufreq_driver)
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700387 goto out;
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 if (cpufreq_driver->setpolicy) {
390 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
391 *policy = CPUFREQ_POLICY_PERFORMANCE;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700392 err = 0;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530393 } else if (!strnicmp(str_governor, "powersave",
394 CPUFREQ_NAME_LEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 *policy = CPUFREQ_POLICY_POWERSAVE;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700396 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700398 } else if (cpufreq_driver->target) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 struct cpufreq_governor *t;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700400
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800401 mutex_lock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700402
403 t = __find_governor(str_governor);
404
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700405 if (t == NULL) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530406 char *name = kasprintf(GFP_KERNEL, "cpufreq_%s",
407 str_governor);
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700408
409 if (name) {
410 int ret;
411
412 mutex_unlock(&cpufreq_governor_mutex);
413 ret = request_module(name);
414 mutex_lock(&cpufreq_governor_mutex);
415
416 if (ret == 0)
417 t = __find_governor(str_governor);
418 }
419
420 kfree(name);
421 }
422
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700423 if (t != NULL) {
424 *governor = t;
425 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700427
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800428 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700430 out:
431 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434
435/* drivers/base/cpu.c */
436extern struct sysdev_class cpu_sysdev_class;
437
438
439/**
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530440 * cpufreq_per_cpu_attr_read() / show_##file_name() -
441 * print out cpufreq information
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 *
443 * Write out information from cpufreq_driver->policy[cpu]; object must be
444 * "unsigned int".
445 */
446
Dave Jones32ee8c32006-02-28 00:43:23 -0500447#define show_one(file_name, object) \
448static ssize_t show_##file_name \
449(struct cpufreq_policy * policy, char *buf) \
450{ \
451 return sprintf (buf, "%u\n", policy->object); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452}
453
454show_one(cpuinfo_min_freq, cpuinfo.min_freq);
455show_one(cpuinfo_max_freq, cpuinfo.max_freq);
456show_one(scaling_min_freq, min);
457show_one(scaling_max_freq, max);
458show_one(scaling_cur_freq, cur);
459
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530460static int __cpufreq_set_policy(struct cpufreq_policy *data,
461 struct cpufreq_policy *policy);
Thomas Renninger7970e082006-04-13 15:14:04 +0200462
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463/**
464 * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
465 */
466#define store_one(file_name, object) \
467static ssize_t store_##file_name \
468(struct cpufreq_policy * policy, const char *buf, size_t count) \
469{ \
470 unsigned int ret = -EINVAL; \
471 struct cpufreq_policy new_policy; \
472 \
473 ret = cpufreq_get_policy(&new_policy, policy->cpu); \
474 if (ret) \
475 return -EINVAL; \
476 \
477 ret = sscanf (buf, "%u", &new_policy.object); \
478 if (ret != 1) \
479 return -EINVAL; \
480 \
Thomas Renninger7970e082006-04-13 15:14:04 +0200481 ret = __cpufreq_set_policy(policy, &new_policy); \
482 policy->user_policy.object = policy->object; \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 \
484 return ret ? ret : count; \
485}
486
487store_one(scaling_min_freq,min);
488store_one(scaling_max_freq,max);
489
490/**
491 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
492 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530493static ssize_t show_cpuinfo_cur_freq (struct cpufreq_policy * policy,
494 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495{
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800496 unsigned int cur_freq = __cpufreq_get(policy->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 if (!cur_freq)
498 return sprintf(buf, "<unknown>");
499 return sprintf(buf, "%u\n", cur_freq);
500}
501
502
503/**
504 * show_scaling_governor - show the current policy for the specified CPU
505 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530506static ssize_t show_scaling_governor (struct cpufreq_policy * policy,
507 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508{
509 if(policy->policy == CPUFREQ_POLICY_POWERSAVE)
510 return sprintf(buf, "powersave\n");
511 else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
512 return sprintf(buf, "performance\n");
513 else if (policy->governor)
514 return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", policy->governor->name);
515 return -EINVAL;
516}
517
518
519/**
520 * store_scaling_governor - store policy for the specified CPU
521 */
Dave Jones32ee8c32006-02-28 00:43:23 -0500522static ssize_t store_scaling_governor (struct cpufreq_policy * policy,
523 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524{
525 unsigned int ret = -EINVAL;
526 char str_governor[16];
527 struct cpufreq_policy new_policy;
528
529 ret = cpufreq_get_policy(&new_policy, policy->cpu);
530 if (ret)
531 return ret;
532
533 ret = sscanf (buf, "%15s", str_governor);
534 if (ret != 1)
535 return -EINVAL;
536
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530537 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
538 &new_policy.governor))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 return -EINVAL;
540
Thomas Renninger7970e082006-04-13 15:14:04 +0200541 /* Do not use cpufreq_set_policy here or the user_policy.max
542 will be wrongly overridden */
Thomas Renninger7970e082006-04-13 15:14:04 +0200543 ret = __cpufreq_set_policy(policy, &new_policy);
544
545 policy->user_policy.policy = policy->policy;
546 policy->user_policy.governor = policy->governor;
Thomas Renninger7970e082006-04-13 15:14:04 +0200547
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530548 if (ret)
549 return ret;
550 else
551 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552}
553
554/**
555 * show_scaling_driver - show the cpufreq driver currently loaded
556 */
557static ssize_t show_scaling_driver (struct cpufreq_policy * policy, char *buf)
558{
559 return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", cpufreq_driver->name);
560}
561
562/**
563 * show_scaling_available_governors - show the available CPUfreq governors
564 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530565static ssize_t show_scaling_available_governors (struct cpufreq_policy *policy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 char *buf)
567{
568 ssize_t i = 0;
569 struct cpufreq_governor *t;
570
571 if (!cpufreq_driver->target) {
572 i += sprintf(buf, "performance powersave");
573 goto out;
574 }
575
576 list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
577 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char)) - (CPUFREQ_NAME_LEN + 2)))
578 goto out;
579 i += scnprintf(&buf[i], CPUFREQ_NAME_LEN, "%s ", t->name);
580 }
Dave Jones7d5e3502006-02-02 17:03:42 -0500581out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 i += sprintf(&buf[i], "\n");
583 return i;
584}
585/**
586 * show_affected_cpus - show the CPUs affected by each transition
587 */
588static ssize_t show_affected_cpus (struct cpufreq_policy * policy, char *buf)
589{
590 ssize_t i = 0;
591 unsigned int cpu;
592
593 for_each_cpu_mask(cpu, policy->cpus) {
594 if (i)
595 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
596 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
597 if (i >= (PAGE_SIZE - 5))
598 break;
599 }
600 i += sprintf(&buf[i], "\n");
601 return i;
602}
603
604
605#define define_one_ro(_name) \
606static struct freq_attr _name = \
607__ATTR(_name, 0444, show_##_name, NULL)
608
609#define define_one_ro0400(_name) \
610static struct freq_attr _name = \
611__ATTR(_name, 0400, show_##_name, NULL)
612
613#define define_one_rw(_name) \
614static struct freq_attr _name = \
615__ATTR(_name, 0644, show_##_name, store_##_name)
616
617define_one_ro0400(cpuinfo_cur_freq);
618define_one_ro(cpuinfo_min_freq);
619define_one_ro(cpuinfo_max_freq);
620define_one_ro(scaling_available_governors);
621define_one_ro(scaling_driver);
622define_one_ro(scaling_cur_freq);
623define_one_ro(affected_cpus);
624define_one_rw(scaling_min_freq);
625define_one_rw(scaling_max_freq);
626define_one_rw(scaling_governor);
627
628static struct attribute * default_attrs[] = {
629 &cpuinfo_min_freq.attr,
630 &cpuinfo_max_freq.attr,
631 &scaling_min_freq.attr,
632 &scaling_max_freq.attr,
633 &affected_cpus.attr,
634 &scaling_governor.attr,
635 &scaling_driver.attr,
636 &scaling_available_governors.attr,
637 NULL
638};
639
640#define to_policy(k) container_of(k,struct cpufreq_policy,kobj)
641#define to_attr(a) container_of(a,struct freq_attr,attr)
642
643static ssize_t show(struct kobject * kobj, struct attribute * attr ,char * buf)
644{
645 struct cpufreq_policy * policy = to_policy(kobj);
646 struct freq_attr * fattr = to_attr(attr);
647 ssize_t ret;
648 policy = cpufreq_cpu_get(policy->cpu);
649 if (!policy)
650 return -EINVAL;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800651
652 if (lock_policy_rwsem_read(policy->cpu) < 0)
653 return -EINVAL;
654
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530655 if (fattr->show)
656 ret = fattr->show(policy, buf);
657 else
658 ret = -EIO;
659
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800660 unlock_policy_rwsem_read(policy->cpu);
661
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 cpufreq_cpu_put(policy);
663 return ret;
664}
665
Dave Jones32ee8c32006-02-28 00:43:23 -0500666static ssize_t store(struct kobject * kobj, struct attribute * attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 const char * buf, size_t count)
668{
669 struct cpufreq_policy * policy = to_policy(kobj);
670 struct freq_attr * fattr = to_attr(attr);
671 ssize_t ret;
672 policy = cpufreq_cpu_get(policy->cpu);
673 if (!policy)
674 return -EINVAL;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800675
676 if (lock_policy_rwsem_write(policy->cpu) < 0)
677 return -EINVAL;
678
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530679 if (fattr->store)
680 ret = fattr->store(policy, buf, count);
681 else
682 ret = -EIO;
683
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800684 unlock_policy_rwsem_write(policy->cpu);
685
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 cpufreq_cpu_put(policy);
687 return ret;
688}
689
690static void cpufreq_sysfs_release(struct kobject * kobj)
691{
692 struct cpufreq_policy * policy = to_policy(kobj);
693 dprintk("last reference is dropped\n");
694 complete(&policy->kobj_unregister);
695}
696
697static struct sysfs_ops sysfs_ops = {
698 .show = show,
699 .store = store,
700};
701
702static struct kobj_type ktype_cpufreq = {
703 .sysfs_ops = &sysfs_ops,
704 .default_attrs = default_attrs,
705 .release = cpufreq_sysfs_release,
706};
707
708
709/**
710 * cpufreq_add_dev - add a CPU device
711 *
Dave Jones32ee8c32006-02-28 00:43:23 -0500712 * Adds the cpufreq interface for a CPU device.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 */
714static int cpufreq_add_dev (struct sys_device * sys_dev)
715{
716 unsigned int cpu = sys_dev->id;
717 int ret = 0;
718 struct cpufreq_policy new_policy;
719 struct cpufreq_policy *policy;
720 struct freq_attr **drv_attr;
Dave Jones8ff69732006-03-05 03:37:23 -0500721 struct sys_device *cpu_sys_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 unsigned long flags;
723 unsigned int j;
Dave Jones8ff69732006-03-05 03:37:23 -0500724#ifdef CONFIG_SMP
725 struct cpufreq_policy *managed_policy;
726#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
Ashok Rajc32b6b82005-10-30 14:59:54 -0800728 if (cpu_is_offline(cpu))
729 return 0;
730
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 cpufreq_debug_disable_ratelimit();
732 dprintk("adding CPU %u\n", cpu);
733
734#ifdef CONFIG_SMP
735 /* check whether a different CPU already registered this
736 * CPU because it is in the same boat. */
737 policy = cpufreq_cpu_get(cpu);
738 if (unlikely(policy)) {
Dave Jones8ff69732006-03-05 03:37:23 -0500739 cpufreq_cpu_put(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 cpufreq_debug_enable_ratelimit();
741 return 0;
742 }
743#endif
744
745 if (!try_module_get(cpufreq_driver->owner)) {
746 ret = -EINVAL;
747 goto module_out;
748 }
749
Dave Jonese98df502005-10-20 15:17:43 -0700750 policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 if (!policy) {
752 ret = -ENOMEM;
753 goto nomem_out;
754 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
756 policy->cpu = cpu;
757 policy->cpus = cpumask_of_cpu(cpu);
758
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800759 /* Initially set CPU itself as the policy_cpu */
760 per_cpu(policy_cpu, cpu) = cpu;
761 lock_policy_rwsem_write(cpu);
762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 init_completion(&policy->kobj_unregister);
David Howells65f27f32006-11-22 14:55:48 +0000764 INIT_WORK(&policy->update, handle_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Thomas Renninger8122c6c2007-10-02 13:28:09 -0700766 /* Set governor before ->init, so that driver could check it */
767 policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 /* call driver. From then on the cpufreq must be able
769 * to accept all calls to ->verify and ->setpolicy for this CPU
770 */
771 ret = cpufreq_driver->init(policy);
772 if (ret) {
773 dprintk("initialization failed\n");
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800774 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 goto err_out;
776 }
Thomas Renninger22c970f2007-04-19 15:48:34 +0200777 policy->user_policy.min = policy->cpuinfo.min_freq;
778 policy->user_policy.max = policy->cpuinfo.max_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Dave Jones8ff69732006-03-05 03:37:23 -0500780#ifdef CONFIG_SMP
Thomas Renninger084f3492007-07-09 11:35:28 -0700781
782#ifdef CONFIG_HOTPLUG_CPU
783 if (cpufreq_cpu_governor[cpu]){
784 policy->governor = cpufreq_cpu_governor[cpu];
785 dprintk("Restoring governor %s for cpu %d\n",
786 policy->governor->name, cpu);
787 }
788#endif
789
Dave Jones8ff69732006-03-05 03:37:23 -0500790 for_each_cpu_mask(j, policy->cpus) {
791 if (cpu == j)
792 continue;
793
794 /* check for existing affected CPUs. They may not be aware
795 * of it due to CPU Hotplug.
796 */
797 managed_policy = cpufreq_cpu_get(j);
798 if (unlikely(managed_policy)) {
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800799
800 /* Set proper policy_cpu */
801 unlock_policy_rwsem_write(cpu);
802 per_cpu(policy_cpu, cpu) = managed_policy->cpu;
803
804 if (lock_policy_rwsem_write(cpu) < 0)
805 goto err_out_driver_exit;
806
Dave Jones8ff69732006-03-05 03:37:23 -0500807 spin_lock_irqsave(&cpufreq_driver_lock, flags);
808 managed_policy->cpus = policy->cpus;
809 cpufreq_cpu_data[cpu] = managed_policy;
810 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
811
812 dprintk("CPU already managed, adding link\n");
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200813 ret = sysfs_create_link(&sys_dev->kobj,
814 &managed_policy->kobj,
815 "cpufreq");
816 if (ret) {
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800817 unlock_policy_rwsem_write(cpu);
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200818 goto err_out_driver_exit;
819 }
Dave Jones8ff69732006-03-05 03:37:23 -0500820
821 cpufreq_debug_enable_ratelimit();
Dave Jones8ff69732006-03-05 03:37:23 -0500822 ret = 0;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800823 unlock_policy_rwsem_write(cpu);
Dave Jones8ff69732006-03-05 03:37:23 -0500824 goto err_out_driver_exit; /* call driver->exit() */
825 }
826 }
827#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
829
830 /* prepare interface data */
831 policy->kobj.parent = &sys_dev->kobj;
832 policy->kobj.ktype = &ktype_cpufreq;
833 strlcpy(policy->kobj.name, "cpufreq", KOBJ_NAME_LEN);
834
835 ret = kobject_register(&policy->kobj);
Andrew Mortonf3876c12006-01-18 13:40:54 -0800836 if (ret) {
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800837 unlock_policy_rwsem_write(cpu);
Venkatesh Pallipadi8085e1f2005-08-25 13:14:06 -0700838 goto err_out_driver_exit;
Andrew Mortonf3876c12006-01-18 13:40:54 -0800839 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 /* set up files for this cpu device */
841 drv_attr = cpufreq_driver->attr;
842 while ((drv_attr) && (*drv_attr)) {
Tobias Klauser58a72952007-06-14 00:28:15 +0200843 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
844 if (ret)
Thomas Renninger0a4b2cc2007-05-21 07:20:04 -0500845 goto err_out_driver_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 drv_attr++;
847 }
Thomas Renninger0a4b2cc2007-05-21 07:20:04 -0500848 if (cpufreq_driver->get){
Tobias Klauser58a72952007-06-14 00:28:15 +0200849 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
850 if (ret)
Thomas Renninger0a4b2cc2007-05-21 07:20:04 -0500851 goto err_out_driver_exit;
852 }
853 if (cpufreq_driver->target){
Tobias Klauser58a72952007-06-14 00:28:15 +0200854 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
855 if (ret)
Thomas Renninger0a4b2cc2007-05-21 07:20:04 -0500856 goto err_out_driver_exit;
857 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
859 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800860 for_each_cpu_mask(j, policy->cpus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 cpufreq_cpu_data[j] = policy;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800862 per_cpu(policy_cpu, j) = policy->cpu;
863 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Dave Jones8ff69732006-03-05 03:37:23 -0500865
866 /* symlink affected CPUs */
867 for_each_cpu_mask(j, policy->cpus) {
868 if (j == cpu)
869 continue;
870 if (!cpu_online(j))
871 continue;
872
Dave Jones1f8b2c92006-03-29 01:40:04 -0500873 dprintk("CPU %u already managed, adding link\n", j);
Dave Jones8ff69732006-03-05 03:37:23 -0500874 cpufreq_cpu_get(cpu);
875 cpu_sys_dev = get_cpu_sysdev(j);
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200876 ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
877 "cpufreq");
878 if (ret) {
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800879 unlock_policy_rwsem_write(cpu);
Ahmed S. Darwish0142f9d2007-01-05 05:44:54 +0200880 goto err_out_unregister;
881 }
Dave Jones8ff69732006-03-05 03:37:23 -0500882 }
883
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 policy->governor = NULL; /* to assure that the starting sequence is
885 * run in cpufreq_set_policy */
Dave Jones87c32272006-03-29 01:48:37 -0500886
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 /* set default policy */
Thomas Renninger22c970f2007-04-19 15:48:34 +0200888 ret = __cpufreq_set_policy(policy, &new_policy);
889 policy->user_policy.policy = policy->policy;
Thomas Renninger084f3492007-07-09 11:35:28 -0700890 policy->user_policy.governor = policy->governor;
Thomas Renninger22c970f2007-04-19 15:48:34 +0200891
892 unlock_policy_rwsem_write(cpu);
893
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 if (ret) {
895 dprintk("setting policy failed\n");
896 goto err_out_unregister;
897 }
898
899 module_put(cpufreq_driver->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 dprintk("initialization complete\n");
901 cpufreq_debug_enable_ratelimit();
Dave Jones87c32272006-03-29 01:48:37 -0500902
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 return 0;
904
905
906err_out_unregister:
907 spin_lock_irqsave(&cpufreq_driver_lock, flags);
908 for_each_cpu_mask(j, policy->cpus)
909 cpufreq_cpu_data[j] = NULL;
910 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
911
912 kobject_unregister(&policy->kobj);
913 wait_for_completion(&policy->kobj_unregister);
914
Venkatesh Pallipadi8085e1f2005-08-25 13:14:06 -0700915err_out_driver_exit:
916 if (cpufreq_driver->exit)
917 cpufreq_driver->exit(policy);
918
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919err_out:
920 kfree(policy);
921
922nomem_out:
923 module_put(cpufreq_driver->owner);
Ashok Rajc32b6b82005-10-30 14:59:54 -0800924module_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 cpufreq_debug_enable_ratelimit();
926 return ret;
927}
928
929
930/**
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800931 * __cpufreq_remove_dev - remove a CPU device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 *
933 * Removes the cpufreq interface for a CPU device.
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800934 * Caller should already have policy_rwsem in write mode for this CPU.
935 * This routine frees the rwsem before returning.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 */
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800937static int __cpufreq_remove_dev (struct sys_device * sys_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938{
939 unsigned int cpu = sys_dev->id;
940 unsigned long flags;
941 struct cpufreq_policy *data;
942#ifdef CONFIG_SMP
Grant Coadye738cf62005-11-21 21:32:28 -0800943 struct sys_device *cpu_sys_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 unsigned int j;
945#endif
946
947 cpufreq_debug_disable_ratelimit();
948 dprintk("unregistering CPU %u\n", cpu);
949
950 spin_lock_irqsave(&cpufreq_driver_lock, flags);
951 data = cpufreq_cpu_data[cpu];
952
953 if (!data) {
954 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 cpufreq_debug_enable_ratelimit();
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800956 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 return -EINVAL;
958 }
959 cpufreq_cpu_data[cpu] = NULL;
960
961
962#ifdef CONFIG_SMP
963 /* if this isn't the CPU which is the parent of the kobj, we
Dave Jones32ee8c32006-02-28 00:43:23 -0500964 * only need to unlink, put and exit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 */
966 if (unlikely(cpu != data->cpu)) {
967 dprintk("removing link\n");
Dave Jones8ff69732006-03-05 03:37:23 -0500968 cpu_clear(cpu, data->cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
970 sysfs_remove_link(&sys_dev->kobj, "cpufreq");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 cpufreq_cpu_put(data);
972 cpufreq_debug_enable_ratelimit();
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800973 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 return 0;
975 }
976#endif
977
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
979 if (!kobject_get(&data->kobj)) {
980 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
981 cpufreq_debug_enable_ratelimit();
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800982 unlock_policy_rwsem_write(cpu);
Dave Jones32ee8c32006-02-28 00:43:23 -0500983 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 }
985
986#ifdef CONFIG_SMP
Thomas Renninger084f3492007-07-09 11:35:28 -0700987
988#ifdef CONFIG_HOTPLUG_CPU
989 cpufreq_cpu_governor[cpu] = data->governor;
990#endif
991
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 /* if we have other CPUs still registered, we need to unlink them,
993 * or else wait_for_completion below will lock up. Clean the
994 * cpufreq_cpu_data[] while holding the lock, and remove the sysfs
995 * links afterwards.
996 */
997 if (unlikely(cpus_weight(data->cpus) > 1)) {
998 for_each_cpu_mask(j, data->cpus) {
999 if (j == cpu)
1000 continue;
1001 cpufreq_cpu_data[j] = NULL;
1002 }
1003 }
1004
1005 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1006
1007 if (unlikely(cpus_weight(data->cpus) > 1)) {
1008 for_each_cpu_mask(j, data->cpus) {
1009 if (j == cpu)
1010 continue;
1011 dprintk("removing link for cpu %u\n", j);
Thomas Renninger084f3492007-07-09 11:35:28 -07001012#ifdef CONFIG_HOTPLUG_CPU
1013 cpufreq_cpu_governor[j] = data->governor;
1014#endif
Ashok Rajd434fca2005-10-30 14:59:52 -08001015 cpu_sys_dev = get_cpu_sysdev(j);
1016 sysfs_remove_link(&cpu_sys_dev->kobj, "cpufreq");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 cpufreq_cpu_put(data);
1018 }
1019 }
1020#else
1021 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1022#endif
1023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 if (cpufreq_driver->target)
1025 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001026
1027 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028
1029 kobject_unregister(&data->kobj);
1030
1031 kobject_put(&data->kobj);
1032
1033 /* we need to make sure that the underlying kobj is actually
Dave Jones32ee8c32006-02-28 00:43:23 -05001034 * not referenced anymore by anybody before we proceed with
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 * unloading.
1036 */
1037 dprintk("waiting for dropping of refcount\n");
1038 wait_for_completion(&data->kobj_unregister);
1039 dprintk("wait complete\n");
1040
1041 if (cpufreq_driver->exit)
1042 cpufreq_driver->exit(data);
1043
1044 kfree(data);
1045
1046 cpufreq_debug_enable_ratelimit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 return 0;
1048}
1049
1050
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001051static int cpufreq_remove_dev (struct sys_device * sys_dev)
1052{
1053 unsigned int cpu = sys_dev->id;
1054 int retval;
Venki Pallipadiec282972007-03-26 12:03:19 -07001055
1056 if (cpu_is_offline(cpu))
1057 return 0;
1058
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001059 if (unlikely(lock_policy_rwsem_write(cpu)))
1060 BUG();
1061
1062 retval = __cpufreq_remove_dev(sys_dev);
1063 return retval;
1064}
1065
1066
David Howells65f27f32006-11-22 14:55:48 +00001067static void handle_update(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068{
David Howells65f27f32006-11-22 14:55:48 +00001069 struct cpufreq_policy *policy =
1070 container_of(work, struct cpufreq_policy, update);
1071 unsigned int cpu = policy->cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 dprintk("handle_update for cpu %u called\n", cpu);
1073 cpufreq_update_policy(cpu);
1074}
1075
1076/**
1077 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
1078 * @cpu: cpu number
1079 * @old_freq: CPU frequency the kernel thinks the CPU runs at
1080 * @new_freq: CPU frequency the CPU actually runs at
1081 *
1082 * We adjust to current frequency first, and need to clean up later. So either call
1083 * to cpufreq_update_policy() or schedule handle_update()).
1084 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301085static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1086 unsigned int new_freq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087{
1088 struct cpufreq_freqs freqs;
1089
Jan Beulichb10eec22006-04-28 13:47:13 +02001090 dprintk("Warning: CPU frequency out of sync: cpufreq and timing "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1092
1093 freqs.cpu = cpu;
1094 freqs.old = old_freq;
1095 freqs.new = new_freq;
1096 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
1097 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
1098}
1099
1100
Dave Jones32ee8c32006-02-28 00:43:23 -05001101/**
Dhaval Giani4ab70df2006-12-13 14:49:15 +05301102 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001103 * @cpu: CPU number
1104 *
1105 * This is the last known freq, without actually getting it from the driver.
1106 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1107 */
1108unsigned int cpufreq_quick_get(unsigned int cpu)
1109{
1110 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301111 unsigned int ret_freq = 0;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001112
1113 if (policy) {
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001114 if (unlikely(lock_policy_rwsem_read(cpu)))
1115 return ret_freq;
1116
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301117 ret_freq = policy->cur;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001118
1119 unlock_policy_rwsem_read(cpu);
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001120 cpufreq_cpu_put(policy);
1121 }
1122
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301123 return (ret_freq);
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001124}
1125EXPORT_SYMBOL(cpufreq_quick_get);
1126
1127
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001128static unsigned int __cpufreq_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129{
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001130 struct cpufreq_policy *policy = cpufreq_cpu_data[cpu];
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301131 unsigned int ret_freq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 if (!cpufreq_driver->get)
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001134 return (ret_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301136 ret_freq = cpufreq_driver->get(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301138 if (ret_freq && policy->cur &&
1139 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1140 /* verify no discrepancy between actual and
1141 saved value exists */
1142 if (unlikely(ret_freq != policy->cur)) {
1143 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 schedule_work(&policy->update);
1145 }
1146 }
1147
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001148 return (ret_freq);
1149}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001151/**
1152 * cpufreq_get - get the current CPU frequency (in kHz)
1153 * @cpu: CPU number
1154 *
1155 * Get the CPU current (static) CPU frequency
1156 */
1157unsigned int cpufreq_get(unsigned int cpu)
1158{
1159 unsigned int ret_freq = 0;
1160 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1161
1162 if (!policy)
1163 goto out;
1164
1165 if (unlikely(lock_policy_rwsem_read(cpu)))
1166 goto out_policy;
1167
1168 ret_freq = __cpufreq_get(cpu);
1169
1170 unlock_policy_rwsem_read(cpu);
1171
1172out_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 cpufreq_cpu_put(policy);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001174out:
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301175 return (ret_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176}
1177EXPORT_SYMBOL(cpufreq_get);
1178
1179
1180/**
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001181 * cpufreq_suspend - let the low level driver prepare for suspend
1182 */
1183
Bernard Blackhame00d9962005-07-07 17:56:42 -07001184static int cpufreq_suspend(struct sys_device * sysdev, pm_message_t pmsg)
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001185{
1186 int cpu = sysdev->id;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301187 int ret = 0;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001188 unsigned int cur_freq = 0;
1189 struct cpufreq_policy *cpu_policy;
1190
Dave Jones0e37b152006-09-26 23:02:34 -04001191 dprintk("suspending cpu %u\n", cpu);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001192
1193 if (!cpu_online(cpu))
1194 return 0;
1195
1196 /* we may be lax here as interrupts are off. Nonetheless
1197 * we need to grab the correct cpu policy, as to check
1198 * whether we really run on this CPU.
1199 */
1200
1201 cpu_policy = cpufreq_cpu_get(cpu);
1202 if (!cpu_policy)
1203 return -EINVAL;
1204
1205 /* only handle each CPU group once */
1206 if (unlikely(cpu_policy->cpu != cpu)) {
1207 cpufreq_cpu_put(cpu_policy);
1208 return 0;
1209 }
1210
1211 if (cpufreq_driver->suspend) {
Bernard Blackhame00d9962005-07-07 17:56:42 -07001212 ret = cpufreq_driver->suspend(cpu_policy, pmsg);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001213 if (ret) {
1214 printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1215 "step on CPU %u\n", cpu_policy->cpu);
1216 cpufreq_cpu_put(cpu_policy);
1217 return ret;
1218 }
1219 }
1220
1221
1222 if (cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)
1223 goto out;
1224
1225 if (cpufreq_driver->get)
1226 cur_freq = cpufreq_driver->get(cpu_policy->cpu);
1227
1228 if (!cur_freq || !cpu_policy->cur) {
1229 printk(KERN_ERR "cpufreq: suspend failed to assert current "
1230 "frequency is what timing core thinks it is.\n");
1231 goto out;
1232 }
1233
1234 if (unlikely(cur_freq != cpu_policy->cur)) {
1235 struct cpufreq_freqs freqs;
1236
1237 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
Jan Beulichb10eec22006-04-28 13:47:13 +02001238 dprintk("Warning: CPU frequency is %u, "
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001239 "cpufreq assumed %u kHz.\n",
1240 cur_freq, cpu_policy->cur);
1241
1242 freqs.cpu = cpu;
1243 freqs.old = cpu_policy->cur;
1244 freqs.new = cur_freq;
1245
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001246 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001247 CPUFREQ_SUSPENDCHANGE, &freqs);
1248 adjust_jiffies(CPUFREQ_SUSPENDCHANGE, &freqs);
1249
1250 cpu_policy->cur = cur_freq;
1251 }
1252
Dave Jones7d5e3502006-02-02 17:03:42 -05001253out:
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001254 cpufreq_cpu_put(cpu_policy);
1255 return 0;
1256}
1257
1258/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 * cpufreq_resume - restore proper CPU frequency handling after resume
1260 *
1261 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
1262 * 2.) if ->target and !CPUFREQ_CONST_LOOPS: verify we're in sync
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001263 * 3.) schedule call cpufreq_update_policy() ASAP as interrupts are
1264 * restored.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 */
1266static int cpufreq_resume(struct sys_device * sysdev)
1267{
1268 int cpu = sysdev->id;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301269 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 struct cpufreq_policy *cpu_policy;
1271
1272 dprintk("resuming cpu %u\n", cpu);
1273
1274 if (!cpu_online(cpu))
1275 return 0;
1276
1277 /* we may be lax here as interrupts are off. Nonetheless
1278 * we need to grab the correct cpu policy, as to check
1279 * whether we really run on this CPU.
1280 */
1281
1282 cpu_policy = cpufreq_cpu_get(cpu);
1283 if (!cpu_policy)
1284 return -EINVAL;
1285
1286 /* only handle each CPU group once */
1287 if (unlikely(cpu_policy->cpu != cpu)) {
1288 cpufreq_cpu_put(cpu_policy);
1289 return 0;
1290 }
1291
1292 if (cpufreq_driver->resume) {
1293 ret = cpufreq_driver->resume(cpu_policy);
1294 if (ret) {
1295 printk(KERN_ERR "cpufreq: resume failed in ->resume "
1296 "step on CPU %u\n", cpu_policy->cpu);
1297 cpufreq_cpu_put(cpu_policy);
1298 return ret;
1299 }
1300 }
1301
1302 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1303 unsigned int cur_freq = 0;
1304
1305 if (cpufreq_driver->get)
1306 cur_freq = cpufreq_driver->get(cpu_policy->cpu);
1307
1308 if (!cur_freq || !cpu_policy->cur) {
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001309 printk(KERN_ERR "cpufreq: resume failed to assert "
1310 "current frequency is what timing core "
1311 "thinks it is.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 goto out;
1313 }
1314
1315 if (unlikely(cur_freq != cpu_policy->cur)) {
1316 struct cpufreq_freqs freqs;
1317
Benjamin Herrenschmidtac09f692005-05-02 16:25:10 +10001318 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
Jan Beulichb10eec22006-04-28 13:47:13 +02001319 dprintk("Warning: CPU frequency"
Benjamin Herrenschmidtac09f692005-05-02 16:25:10 +10001320 "is %u, cpufreq assumed %u kHz.\n",
1321 cur_freq, cpu_policy->cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322
1323 freqs.cpu = cpu;
1324 freqs.old = cpu_policy->cur;
1325 freqs.new = cur_freq;
1326
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001327 srcu_notifier_call_chain(
Alan Sterne041c682006-03-27 01:16:30 -08001328 &cpufreq_transition_notifier_list,
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001329 CPUFREQ_RESUMECHANGE, &freqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 adjust_jiffies(CPUFREQ_RESUMECHANGE, &freqs);
1331
1332 cpu_policy->cur = cur_freq;
1333 }
1334 }
1335
1336out:
1337 schedule_work(&cpu_policy->update);
1338 cpufreq_cpu_put(cpu_policy);
1339 return ret;
1340}
1341
1342static struct sysdev_driver cpufreq_sysdev_driver = {
1343 .add = cpufreq_add_dev,
1344 .remove = cpufreq_remove_dev,
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001345 .suspend = cpufreq_suspend,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 .resume = cpufreq_resume,
1347};
1348
1349
1350/*********************************************************************
1351 * NOTIFIER LISTS INTERFACE *
1352 *********************************************************************/
1353
1354/**
1355 * cpufreq_register_notifier - register a driver with cpufreq
1356 * @nb: notifier function to register
1357 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1358 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001359 * Add a driver to one of two lists: either a list of drivers that
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 * are notified about clock rate changes (once before and once after
1361 * the transition), or a list of drivers that are notified about
1362 * changes in cpufreq policy.
1363 *
1364 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001365 * blocking_notifier_chain_register.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 */
1367int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1368{
1369 int ret;
1370
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 switch (list) {
1372 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001373 ret = srcu_notifier_chain_register(
Alan Sterne041c682006-03-27 01:16:30 -08001374 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 break;
1376 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001377 ret = blocking_notifier_chain_register(
1378 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 break;
1380 default:
1381 ret = -EINVAL;
1382 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383
1384 return ret;
1385}
1386EXPORT_SYMBOL(cpufreq_register_notifier);
1387
1388
1389/**
1390 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1391 * @nb: notifier block to be unregistered
1392 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1393 *
1394 * Remove a driver from the CPU frequency notifier list.
1395 *
1396 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001397 * blocking_notifier_chain_unregister.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 */
1399int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1400{
1401 int ret;
1402
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 switch (list) {
1404 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001405 ret = srcu_notifier_chain_unregister(
Alan Sterne041c682006-03-27 01:16:30 -08001406 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 break;
1408 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001409 ret = blocking_notifier_chain_unregister(
1410 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 break;
1412 default:
1413 ret = -EINVAL;
1414 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415
1416 return ret;
1417}
1418EXPORT_SYMBOL(cpufreq_unregister_notifier);
1419
1420
1421/*********************************************************************
1422 * GOVERNORS *
1423 *********************************************************************/
1424
1425
1426int __cpufreq_driver_target(struct cpufreq_policy *policy,
1427 unsigned int target_freq,
1428 unsigned int relation)
1429{
1430 int retval = -EINVAL;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001431
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
1433 target_freq, relation);
1434 if (cpu_online(policy->cpu) && cpufreq_driver->target)
1435 retval = cpufreq_driver->target(policy, target_freq, relation);
Ashok Raj90d45d12005-11-08 21:34:24 -08001436
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 return retval;
1438}
1439EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1440
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441int cpufreq_driver_target(struct cpufreq_policy *policy,
1442 unsigned int target_freq,
1443 unsigned int relation)
1444{
Dave Jonescc993ca2005-07-28 09:43:56 -07001445 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446
1447 policy = cpufreq_cpu_get(policy->cpu);
1448 if (!policy)
1449 return -EINVAL;
1450
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001451 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
1452 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453
1454 ret = __cpufreq_driver_target(policy, target_freq, relation);
1455
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001456 unlock_policy_rwsem_write(policy->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457
1458 cpufreq_cpu_put(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 return ret;
1460}
1461EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1462
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001463int __cpufreq_driver_getavg(struct cpufreq_policy *policy)
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001464{
1465 int ret = 0;
1466
1467 policy = cpufreq_cpu_get(policy->cpu);
1468 if (!policy)
1469 return -EINVAL;
1470
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001471 if (cpu_online(policy->cpu) && cpufreq_driver->getavg)
1472 ret = cpufreq_driver->getavg(policy->cpu);
1473
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001474 cpufreq_cpu_put(policy);
1475 return ret;
1476}
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001477EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001478
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001479/*
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001480 * when "event" is CPUFREQ_GOV_LIMITS
1481 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301483static int __cpufreq_governor(struct cpufreq_policy *policy,
1484 unsigned int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485{
Dave Jonescc993ca2005-07-28 09:43:56 -07001486 int ret;
Thomas Renninger6afde102007-10-02 13:28:13 -07001487
1488 /* Only must be defined when default governor is known to have latency
1489 restrictions, like e.g. conservative or ondemand.
1490 That this is the case is already ensured in Kconfig
1491 */
1492#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1493 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1494#else
1495 struct cpufreq_governor *gov = NULL;
1496#endif
Thomas Renninger1c256242007-10-02 13:28:12 -07001497
1498 if (policy->governor->max_transition_latency &&
1499 policy->cpuinfo.transition_latency >
1500 policy->governor->max_transition_latency) {
Thomas Renninger6afde102007-10-02 13:28:13 -07001501 if (!gov)
1502 return -EINVAL;
1503 else {
1504 printk(KERN_WARNING "%s governor failed, too long"
1505 " transition latency of HW, fallback"
1506 " to %s governor\n",
1507 policy->governor->name,
1508 gov->name);
1509 policy->governor = gov;
1510 }
Thomas Renninger1c256242007-10-02 13:28:12 -07001511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512
1513 if (!try_module_get(policy->governor->owner))
1514 return -EINVAL;
1515
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301516 dprintk("__cpufreq_governor for CPU %u, event %u\n",
1517 policy->cpu, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 ret = policy->governor->governor(policy, event);
1519
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301520 /* we keep one module reference alive for
1521 each CPU governed by this CPU */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 if ((event != CPUFREQ_GOV_START) || ret)
1523 module_put(policy->governor->owner);
1524 if ((event == CPUFREQ_GOV_STOP) && !ret)
1525 module_put(policy->governor->owner);
1526
1527 return ret;
1528}
1529
1530
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531int cpufreq_register_governor(struct cpufreq_governor *governor)
1532{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001533 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534
1535 if (!governor)
1536 return -EINVAL;
1537
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001538 mutex_lock(&cpufreq_governor_mutex);
Dave Jones32ee8c32006-02-28 00:43:23 -05001539
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001540 err = -EBUSY;
1541 if (__find_governor(governor->name) == NULL) {
1542 err = 0;
1543 list_add(&governor->governor_list, &cpufreq_governor_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545
Dave Jones32ee8c32006-02-28 00:43:23 -05001546 mutex_unlock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001547 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548}
1549EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1550
1551
1552void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1553{
1554 if (!governor)
1555 return;
1556
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001557 mutex_lock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 list_del(&governor->governor_list);
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001559 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 return;
1561}
1562EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1563
1564
1565
1566/*********************************************************************
1567 * POLICY INTERFACE *
1568 *********************************************************************/
1569
1570/**
1571 * cpufreq_get_policy - get the current cpufreq_policy
1572 * @policy: struct cpufreq_policy into which the current cpufreq_policy is written
1573 *
1574 * Reads the current cpufreq policy.
1575 */
1576int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1577{
1578 struct cpufreq_policy *cpu_policy;
1579 if (!policy)
1580 return -EINVAL;
1581
1582 cpu_policy = cpufreq_cpu_get(cpu);
1583 if (!cpu_policy)
1584 return -EINVAL;
1585
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587
1588 cpufreq_cpu_put(cpu_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 return 0;
1590}
1591EXPORT_SYMBOL(cpufreq_get_policy);
1592
1593
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001594/*
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301595 * data : current policy.
1596 * policy : policy to be set.
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001597 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301598static int __cpufreq_set_policy(struct cpufreq_policy *data,
1599 struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600{
1601 int ret = 0;
1602
1603 cpufreq_debug_disable_ratelimit();
1604 dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
1605 policy->min, policy->max);
1606
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301607 memcpy(&policy->cpuinfo, &data->cpuinfo,
1608 sizeof(struct cpufreq_cpuinfo));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609
Mattia Dongili9c9a43e2006-07-05 23:12:20 +02001610 if (policy->min > data->min && policy->min > policy->max) {
1611 ret = -EINVAL;
1612 goto error_out;
1613 }
1614
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 /* verify the cpu speed can be set within this limit */
1616 ret = cpufreq_driver->verify(policy);
1617 if (ret)
1618 goto error_out;
1619
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 /* adjust if necessary - all reasons */
Alan Sterne041c682006-03-27 01:16:30 -08001621 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1622 CPUFREQ_ADJUST, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623
1624 /* adjust if necessary - hardware incompatibility*/
Alan Sterne041c682006-03-27 01:16:30 -08001625 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1626 CPUFREQ_INCOMPATIBLE, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
1628 /* verify the cpu speed can be set within this limit,
1629 which might be different to the first one */
1630 ret = cpufreq_driver->verify(policy);
Alan Sterne041c682006-03-27 01:16:30 -08001631 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 goto error_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
1634 /* notification of the new policy */
Alan Sterne041c682006-03-27 01:16:30 -08001635 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1636 CPUFREQ_NOTIFY, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
Dave Jones7d5e3502006-02-02 17:03:42 -05001638 data->min = policy->min;
1639 data->max = policy->max;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301641 dprintk("new min and max freqs are %u - %u kHz\n",
1642 data->min, data->max);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643
1644 if (cpufreq_driver->setpolicy) {
1645 data->policy = policy->policy;
1646 dprintk("setting range\n");
1647 ret = cpufreq_driver->setpolicy(policy);
1648 } else {
1649 if (policy->governor != data->governor) {
1650 /* save old, working values */
1651 struct cpufreq_governor *old_gov = data->governor;
1652
1653 dprintk("governor switch\n");
1654
1655 /* end old governor */
1656 if (data->governor)
1657 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1658
1659 /* start new governor */
1660 data->governor = policy->governor;
1661 if (__cpufreq_governor(data, CPUFREQ_GOV_START)) {
1662 /* new governor failed, so re-start old one */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301663 dprintk("starting governor %s failed\n",
1664 data->governor->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 if (old_gov) {
1666 data->governor = old_gov;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301667 __cpufreq_governor(data,
1668 CPUFREQ_GOV_START);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 }
1670 ret = -EINVAL;
1671 goto error_out;
1672 }
1673 /* might be a policy change, too, so fall through */
1674 }
1675 dprintk("governor: change or update limits\n");
1676 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1677 }
1678
Dave Jones7d5e3502006-02-02 17:03:42 -05001679error_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 cpufreq_debug_enable_ratelimit();
1681 return ret;
1682}
1683
1684/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1686 * @cpu: CPU which shall be re-evaluated
1687 *
1688 * Usefull for policy notifiers which have different necessities
1689 * at different times.
1690 */
1691int cpufreq_update_policy(unsigned int cpu)
1692{
1693 struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
1694 struct cpufreq_policy policy;
1695 int ret = 0;
1696
1697 if (!data)
1698 return -ENODEV;
1699
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001700 if (unlikely(lock_policy_rwsem_write(cpu)))
1701 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702
1703 dprintk("updating policy for CPU %u\n", cpu);
Dave Jones7d5e3502006-02-02 17:03:42 -05001704 memcpy(&policy, data, sizeof(struct cpufreq_policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 policy.min = data->user_policy.min;
1706 policy.max = data->user_policy.max;
1707 policy.policy = data->user_policy.policy;
1708 policy.governor = data->user_policy.governor;
1709
Thomas Renninger0961dd02006-01-26 18:46:33 +01001710 /* BIOS might change freq behind our back
1711 -> ask driver for current freq and notify governors about a change */
1712 if (cpufreq_driver->get) {
1713 policy.cur = cpufreq_driver->get(cpu);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001714 if (!data->cur) {
1715 dprintk("Driver did not initialize current freq");
1716 data->cur = policy.cur;
1717 } else {
1718 if (data->cur != policy.cur)
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301719 cpufreq_out_of_sync(cpu, data->cur,
1720 policy.cur);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001721 }
Thomas Renninger0961dd02006-01-26 18:46:33 +01001722 }
1723
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 ret = __cpufreq_set_policy(data, &policy);
1725
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001726 unlock_policy_rwsem_write(cpu);
1727
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 cpufreq_cpu_put(data);
1729 return ret;
1730}
1731EXPORT_SYMBOL(cpufreq_update_policy);
1732
Chandra Seetharaman65edc682006-06-27 02:54:08 -07001733static int cpufreq_cpu_callback(struct notifier_block *nfb,
Ashok Rajc32b6b82005-10-30 14:59:54 -08001734 unsigned long action, void *hcpu)
1735{
1736 unsigned int cpu = (unsigned long)hcpu;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001737 struct sys_device *sys_dev;
1738
1739 sys_dev = get_cpu_sysdev(cpu);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001740 if (sys_dev) {
1741 switch (action) {
1742 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001743 case CPU_ONLINE_FROZEN:
Ashok Rajc32b6b82005-10-30 14:59:54 -08001744 cpufreq_add_dev(sys_dev);
1745 break;
1746 case CPU_DOWN_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001747 case CPU_DOWN_PREPARE_FROZEN:
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001748 if (unlikely(lock_policy_rwsem_write(cpu)))
1749 BUG();
1750
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001751 __cpufreq_remove_dev(sys_dev);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001752 break;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001753 case CPU_DOWN_FAILED:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001754 case CPU_DOWN_FAILED_FROZEN:
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001755 cpufreq_add_dev(sys_dev);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001756 break;
1757 }
1758 }
1759 return NOTIFY_OK;
1760}
1761
Chandra Seetharaman74b85f32006-06-27 02:54:09 -07001762static struct notifier_block __cpuinitdata cpufreq_cpu_notifier =
Ashok Rajc32b6b82005-10-30 14:59:54 -08001763{
1764 .notifier_call = cpufreq_cpu_callback,
1765};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766
1767/*********************************************************************
1768 * REGISTER / UNREGISTER CPUFREQ DRIVER *
1769 *********************************************************************/
1770
1771/**
1772 * cpufreq_register_driver - register a CPU Frequency driver
1773 * @driver_data: A struct cpufreq_driver containing the values#
1774 * submitted by the CPU Frequency driver.
1775 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001776 * Registers a CPU Frequency driver to this core code. This code
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 * returns zero on success, -EBUSY when another driver got here first
Dave Jones32ee8c32006-02-28 00:43:23 -05001778 * (and isn't unregistered in the meantime).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 *
1780 */
Linus Torvalds221dee22007-02-26 14:55:48 -08001781int cpufreq_register_driver(struct cpufreq_driver *driver_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782{
1783 unsigned long flags;
1784 int ret;
1785
1786 if (!driver_data || !driver_data->verify || !driver_data->init ||
1787 ((!driver_data->setpolicy) && (!driver_data->target)))
1788 return -EINVAL;
1789
1790 dprintk("trying to register driver %s\n", driver_data->name);
1791
1792 if (driver_data->setpolicy)
1793 driver_data->flags |= CPUFREQ_CONST_LOOPS;
1794
1795 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1796 if (cpufreq_driver) {
1797 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1798 return -EBUSY;
1799 }
1800 cpufreq_driver = driver_data;
1801 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1802
1803 ret = sysdev_driver_register(&cpu_sysdev_class,&cpufreq_sysdev_driver);
1804
1805 if ((!ret) && !(cpufreq_driver->flags & CPUFREQ_STICKY)) {
1806 int i;
1807 ret = -ENODEV;
1808
1809 /* check for at least one working CPU */
1810 for (i=0; i<NR_CPUS; i++)
1811 if (cpufreq_cpu_data[i])
1812 ret = 0;
1813
1814 /* if all ->init() calls failed, unregister */
1815 if (ret) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301816 dprintk("no CPU initialized for driver %s\n",
1817 driver_data->name);
1818 sysdev_driver_unregister(&cpu_sysdev_class,
1819 &cpufreq_sysdev_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820
1821 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1822 cpufreq_driver = NULL;
1823 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1824 }
1825 }
1826
1827 if (!ret) {
Chandra Seetharaman65edc682006-06-27 02:54:08 -07001828 register_hotcpu_notifier(&cpufreq_cpu_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 dprintk("driver %s up and running\n", driver_data->name);
1830 cpufreq_debug_enable_ratelimit();
1831 }
1832
1833 return (ret);
1834}
1835EXPORT_SYMBOL_GPL(cpufreq_register_driver);
1836
1837
1838/**
1839 * cpufreq_unregister_driver - unregister the current CPUFreq driver
1840 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001841 * Unregister the current CPUFreq driver. Only call this if you have
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 * the right to do so, i.e. if you have succeeded in initialising before!
1843 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
1844 * currently not initialised.
1845 */
Linus Torvalds221dee22007-02-26 14:55:48 -08001846int cpufreq_unregister_driver(struct cpufreq_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847{
1848 unsigned long flags;
1849
1850 cpufreq_debug_disable_ratelimit();
1851
1852 if (!cpufreq_driver || (driver != cpufreq_driver)) {
1853 cpufreq_debug_enable_ratelimit();
1854 return -EINVAL;
1855 }
1856
1857 dprintk("unregistering driver %s\n", driver->name);
1858
1859 sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
Chandra Seetharaman65edc682006-06-27 02:54:08 -07001860 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861
1862 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1863 cpufreq_driver = NULL;
1864 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1865
1866 return 0;
1867}
1868EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001869
1870static int __init cpufreq_core_init(void)
1871{
1872 int cpu;
1873
1874 for_each_possible_cpu(cpu) {
1875 per_cpu(policy_cpu, cpu) = -1;
1876 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
1877 }
1878 return 0;
1879}
1880
1881core_initcall(cpufreq_core_init);