]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/cpufreq/cpufreq.c
[CPUFREQ] Remove debugging message from e_powersaver
[mirror_ubuntu-artful-kernel.git] / drivers / cpufreq / cpufreq.c
CommitLineData
1da177e4
LT
1/*
2 * linux/drivers/cpufreq/cpufreq.c
3 *
4 * Copyright (C) 2001 Russell King
5 * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
6 *
c32b6b8e 7 * Oct 2005 - Ashok Raj <ashok.raj@intel.com>
32ee8c3e 8 * Added handling for CPU hotplug
8ff69732
DJ
9 * Feb 2006 - Jacob Shin <jacob.shin@amd.com>
10 * Fix handling for CPU hotplug -- affected CPUs
c32b6b8e 11 *
1da177e4
LT
12 * 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
1da177e4
LT
18#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>
3fc54d37 30#include <linux/mutex.h>
1da177e4 31
e08f5f5b
GS
32#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
33 "cpufreq-core", msg)
1da177e4
LT
34
35/**
cd878479 36 * The "cpufreq driver" - the arch- or hardware-dependent low
1da177e4
LT
37 * level driver of CPUFreq support, and its spinlock. This lock
38 * also protects the cpufreq_cpu_data array.
39 */
7d5e350f
DJ
40static struct cpufreq_driver *cpufreq_driver;
41static struct cpufreq_policy *cpufreq_cpu_data[NR_CPUS];
084f3493
TR
42#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
1da177e4
LT
46static DEFINE_SPINLOCK(cpufreq_driver_lock);
47
5a01f2e8
VP
48/*
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
1da177e4
LT
106/* internal prototypes */
107static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event);
5a01f2e8 108static unsigned int __cpufreq_get(unsigned int cpu);
65f27f38 109static void handle_update(struct work_struct *work);
1da177e4
LT
110
111/**
32ee8c3e
DJ
112 * Two notifier lists: the "policy" list is involved in the
113 * validation process for a new CPU frequency policy; the
1da177e4
LT
114 * "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 */
e041c683 118static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
b4dfdbb3 119static struct srcu_notifier_head cpufreq_transition_notifier_list;
1da177e4 120
b4dfdbb3
AS
121static int __init init_cpufreq_transition_notifier_list(void)
122{
123 srcu_init_notifier_head(&cpufreq_transition_notifier_list);
124 return 0;
125}
b3438f82 126pure_initcall(init_cpufreq_transition_notifier_list);
1da177e4
LT
127
128static LIST_HEAD(cpufreq_governor_list);
7d5e350f 129static DEFINE_MUTEX (cpufreq_governor_mutex);
1da177e4 130
7d5e350f 131struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
1da177e4
LT
132{
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
1da177e4 158 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1da177e4
LT
159 return data;
160
7d5e350f 161err_out_put_module:
1da177e4 162 module_put(cpufreq_driver->owner);
7d5e350f 163err_out_unlock:
1da177e4 164 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
7d5e350f 165err_out:
1da177e4
LT
166 return NULL;
167}
168EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
169
7d5e350f 170
1da177e4
LT
171void 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
858119e1 199static void cpufreq_debug_enable_ratelimit(void)
1da177e4
LT
200{
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
858119e1 209static void cpufreq_debug_disable_ratelimit(void)
1da177e4
LT
210{
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
e08f5f5b
GS
218void cpufreq_debug_printk(unsigned int type, const char *prefix,
219 const char *fmt, ...)
1da177e4
LT
220{
221 char s[256];
222 va_list args;
223 unsigned int len;
224 unsigned long flags;
32ee8c3e 225
1da177e4
LT
226 WARN_ON(!prefix);
227 if (type & debug) {
228 spin_lock_irqsave(&disable_ratelimit_lock, flags);
e08f5f5b
GS
229 if (!disable_ratelimit && debug_ratelimit
230 && !printk_ratelimit()) {
1da177e4
LT
231 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);
e08f5f5b
GS
251MODULE_PARM_DESC(debug, "CPUfreq debugging: add 1 to debug core,"
252 " 2 to debug drivers, and 4 to debug governors.");
1da177e4
LT
253
254module_param(debug_ratelimit, uint, 0644);
e08f5f5b
GS
255MODULE_PARM_DESC(debug_ratelimit, "CPUfreq debugging:"
256 " set to 0 to disable ratelimiting.");
1da177e4
LT
257
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
32ee8c3e 275 * systems as each CPU might be scaled differently. So, use the arch
1da177e4
LT
276 * 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
858119e1 282static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
1da177e4
LT
283{
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;
a4a9df58 290 dprintk("saving %lu as reference value for loops_per_jiffy; "
e08f5f5b 291 "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
1da177e4
LT
292 }
293 if ((val == CPUFREQ_PRECHANGE && ci->old < ci->new) ||
294 (val == CPUFREQ_POSTCHANGE && ci->old > ci->new) ||
42d4dc3f 295 (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
e08f5f5b
GS
296 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
297 ci->new);
a4a9df58 298 dprintk("scaling loops_per_jiffy to %lu "
e08f5f5b 299 "for frequency %u kHz\n", loops_per_jiffy, ci->new);
1da177e4
LT
300 }
301}
302#else
e08f5f5b
GS
303static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
304{
305 return;
306}
1da177e4
LT
307#endif
308
309
310/**
e4472cb3
DJ
311 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
312 * on frequency transition.
1da177e4 313 *
e4472cb3
DJ
314 * This function calls the transition notifiers and the "adjust_jiffies"
315 * function. It is called twice on all CPU frequency changes that have
32ee8c3e 316 * external effects.
1da177e4
LT
317 */
318void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
319{
e4472cb3
DJ
320 struct cpufreq_policy *policy;
321
1da177e4
LT
322 BUG_ON(irqs_disabled());
323
324 freqs->flags = cpufreq_driver->flags;
e4472cb3
DJ
325 dprintk("notification %u of frequency transition to %u kHz\n",
326 state, freqs->new);
1da177e4 327
e4472cb3 328 policy = cpufreq_cpu_data[freqs->cpu];
1da177e4 329 switch (state) {
e4472cb3 330
1da177e4 331 case CPUFREQ_PRECHANGE:
32ee8c3e 332 /* detect if the driver reported a value as "old frequency"
e4472cb3
DJ
333 * which is not equal to what the cpufreq core thinks is
334 * "old frequency".
1da177e4
LT
335 */
336 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
e4472cb3
DJ
337 if ((policy) && (policy->cpu == freqs->cpu) &&
338 (policy->cur) && (policy->cur != freqs->old)) {
b10eec22 339 dprintk("Warning: CPU frequency is"
e4472cb3
DJ
340 " %u, cpufreq assumed %u kHz.\n",
341 freqs->old, policy->cur);
342 freqs->old = policy->cur;
1da177e4
LT
343 }
344 }
b4dfdbb3 345 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
e041c683 346 CPUFREQ_PRECHANGE, freqs);
1da177e4
LT
347 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
348 break;
e4472cb3 349
1da177e4
LT
350 case CPUFREQ_POSTCHANGE:
351 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
b4dfdbb3 352 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
e041c683 353 CPUFREQ_POSTCHANGE, freqs);
e4472cb3
DJ
354 if (likely(policy) && likely(policy->cpu == freqs->cpu))
355 policy->cur = freqs->new;
1da177e4
LT
356 break;
357 }
1da177e4
LT
358}
359EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
360
361
362
363/*********************************************************************
364 * SYSFS INTERFACE *
365 *********************************************************************/
366
3bcb09a3
JF
367static 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
1da177e4
LT
378/**
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{
3bcb09a3
JF
384 int err = -EINVAL;
385
1da177e4 386 if (!cpufreq_driver)
3bcb09a3
JF
387 goto out;
388
1da177e4
LT
389 if (cpufreq_driver->setpolicy) {
390 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
391 *policy = CPUFREQ_POLICY_PERFORMANCE;
3bcb09a3 392 err = 0;
e08f5f5b
GS
393 } else if (!strnicmp(str_governor, "powersave",
394 CPUFREQ_NAME_LEN)) {
1da177e4 395 *policy = CPUFREQ_POLICY_POWERSAVE;
3bcb09a3 396 err = 0;
1da177e4 397 }
3bcb09a3 398 } else if (cpufreq_driver->target) {
1da177e4 399 struct cpufreq_governor *t;
3bcb09a3 400
3fc54d37 401 mutex_lock(&cpufreq_governor_mutex);
3bcb09a3
JF
402
403 t = __find_governor(str_governor);
404
ea714970 405 if (t == NULL) {
e08f5f5b
GS
406 char *name = kasprintf(GFP_KERNEL, "cpufreq_%s",
407 str_governor);
ea714970
JF
408
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
3bcb09a3
JF
423 if (t != NULL) {
424 *governor = t;
425 err = 0;
1da177e4 426 }
3bcb09a3 427
3fc54d37 428 mutex_unlock(&cpufreq_governor_mutex);
1da177e4 429 }
3bcb09a3
JF
430 out:
431 return err;
1da177e4 432}
1da177e4
LT
433
434
435/* drivers/base/cpu.c */
436extern struct sysdev_class cpu_sysdev_class;
437
438
439/**
e08f5f5b
GS
440 * cpufreq_per_cpu_attr_read() / show_##file_name() -
441 * print out cpufreq information
1da177e4
LT
442 *
443 * Write out information from cpufreq_driver->policy[cpu]; object must be
444 * "unsigned int".
445 */
446
32ee8c3e
DJ
447#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); \
1da177e4
LT
452}
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
e08f5f5b
GS
460static int __cpufreq_set_policy(struct cpufreq_policy *data,
461 struct cpufreq_policy *policy);
7970e08b 462
1da177e4
LT
463/**
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 \
7970e08b
TR
481 ret = __cpufreq_set_policy(policy, &new_policy); \
482 policy->user_policy.object = policy->object; \
1da177e4
LT
483 \
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 */
e08f5f5b
GS
493static ssize_t show_cpuinfo_cur_freq (struct cpufreq_policy * policy,
494 char *buf)
1da177e4 495{
5a01f2e8 496 unsigned int cur_freq = __cpufreq_get(policy->cpu);
1da177e4
LT
497 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 */
e08f5f5b
GS
506static ssize_t show_scaling_governor (struct cpufreq_policy * policy,
507 char *buf)
1da177e4
LT
508{
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 */
32ee8c3e
DJ
522static ssize_t store_scaling_governor (struct cpufreq_policy * policy,
523 const char *buf, size_t count)
1da177e4
LT
524{
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
e08f5f5b
GS
537 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
538 &new_policy.governor))
1da177e4
LT
539 return -EINVAL;
540
7970e08b
TR
541 /* Do not use cpufreq_set_policy here or the user_policy.max
542 will be wrongly overridden */
7970e08b
TR
543 ret = __cpufreq_set_policy(policy, &new_policy);
544
545 policy->user_policy.policy = policy->policy;
546 policy->user_policy.governor = policy->governor;
7970e08b 547
e08f5f5b
GS
548 if (ret)
549 return ret;
550 else
551 return count;
1da177e4
LT
552}
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 */
e08f5f5b 565static ssize_t show_scaling_available_governors (struct cpufreq_policy *policy,
1da177e4
LT
566 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 }
7d5e350f 581out:
1da177e4
LT
582 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
9e76988e
VP
604static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
605 const char *buf, size_t count)
606{
607 unsigned int freq = 0;
608 unsigned int ret;
609
610 if (!policy->governor->store_setspeed)
611 return -EINVAL;
612
613 ret = sscanf(buf, "%u", &freq);
614 if (ret != 1)
615 return -EINVAL;
616
617 policy->governor->store_setspeed(policy, freq);
618
619 return count;
620}
621
622static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
623{
624 if (!policy->governor->show_setspeed)
625 return sprintf(buf, "<unsupported>\n");
626
627 return policy->governor->show_setspeed(policy, buf);
628}
1da177e4
LT
629
630#define define_one_ro(_name) \
631static struct freq_attr _name = \
632__ATTR(_name, 0444, show_##_name, NULL)
633
634#define define_one_ro0400(_name) \
635static struct freq_attr _name = \
636__ATTR(_name, 0400, show_##_name, NULL)
637
638#define define_one_rw(_name) \
639static struct freq_attr _name = \
640__ATTR(_name, 0644, show_##_name, store_##_name)
641
642define_one_ro0400(cpuinfo_cur_freq);
643define_one_ro(cpuinfo_min_freq);
644define_one_ro(cpuinfo_max_freq);
645define_one_ro(scaling_available_governors);
646define_one_ro(scaling_driver);
647define_one_ro(scaling_cur_freq);
648define_one_ro(affected_cpus);
649define_one_rw(scaling_min_freq);
650define_one_rw(scaling_max_freq);
651define_one_rw(scaling_governor);
9e76988e 652define_one_rw(scaling_setspeed);
1da177e4
LT
653
654static struct attribute * default_attrs[] = {
655 &cpuinfo_min_freq.attr,
656 &cpuinfo_max_freq.attr,
657 &scaling_min_freq.attr,
658 &scaling_max_freq.attr,
659 &affected_cpus.attr,
660 &scaling_governor.attr,
661 &scaling_driver.attr,
662 &scaling_available_governors.attr,
9e76988e 663 &scaling_setspeed.attr,
1da177e4
LT
664 NULL
665};
666
667#define to_policy(k) container_of(k,struct cpufreq_policy,kobj)
668#define to_attr(a) container_of(a,struct freq_attr,attr)
669
670static ssize_t show(struct kobject * kobj, struct attribute * attr ,char * buf)
671{
672 struct cpufreq_policy * policy = to_policy(kobj);
673 struct freq_attr * fattr = to_attr(attr);
0db4a8a9 674 ssize_t ret = -EINVAL;
1da177e4
LT
675 policy = cpufreq_cpu_get(policy->cpu);
676 if (!policy)
0db4a8a9 677 goto no_policy;
5a01f2e8
VP
678
679 if (lock_policy_rwsem_read(policy->cpu) < 0)
0db4a8a9 680 goto fail;
5a01f2e8 681
e08f5f5b
GS
682 if (fattr->show)
683 ret = fattr->show(policy, buf);
684 else
685 ret = -EIO;
686
5a01f2e8 687 unlock_policy_rwsem_read(policy->cpu);
0db4a8a9 688fail:
1da177e4 689 cpufreq_cpu_put(policy);
0db4a8a9 690no_policy:
1da177e4
LT
691 return ret;
692}
693
32ee8c3e 694static ssize_t store(struct kobject * kobj, struct attribute * attr,
1da177e4
LT
695 const char * buf, size_t count)
696{
697 struct cpufreq_policy * policy = to_policy(kobj);
698 struct freq_attr * fattr = to_attr(attr);
a07530b4 699 ssize_t ret = -EINVAL;
1da177e4
LT
700 policy = cpufreq_cpu_get(policy->cpu);
701 if (!policy)
a07530b4 702 goto no_policy;
5a01f2e8
VP
703
704 if (lock_policy_rwsem_write(policy->cpu) < 0)
a07530b4 705 goto fail;
5a01f2e8 706
e08f5f5b
GS
707 if (fattr->store)
708 ret = fattr->store(policy, buf, count);
709 else
710 ret = -EIO;
711
5a01f2e8 712 unlock_policy_rwsem_write(policy->cpu);
a07530b4 713fail:
1da177e4 714 cpufreq_cpu_put(policy);
a07530b4 715no_policy:
1da177e4
LT
716 return ret;
717}
718
719static void cpufreq_sysfs_release(struct kobject * kobj)
720{
721 struct cpufreq_policy * policy = to_policy(kobj);
722 dprintk("last reference is dropped\n");
723 complete(&policy->kobj_unregister);
724}
725
726static struct sysfs_ops sysfs_ops = {
727 .show = show,
728 .store = store,
729};
730
731static struct kobj_type ktype_cpufreq = {
732 .sysfs_ops = &sysfs_ops,
733 .default_attrs = default_attrs,
734 .release = cpufreq_sysfs_release,
735};
736
737
738/**
739 * cpufreq_add_dev - add a CPU device
740 *
32ee8c3e 741 * Adds the cpufreq interface for a CPU device.
1da177e4
LT
742 */
743static int cpufreq_add_dev (struct sys_device * sys_dev)
744{
745 unsigned int cpu = sys_dev->id;
746 int ret = 0;
747 struct cpufreq_policy new_policy;
748 struct cpufreq_policy *policy;
749 struct freq_attr **drv_attr;
8ff69732 750 struct sys_device *cpu_sys_dev;
1da177e4
LT
751 unsigned long flags;
752 unsigned int j;
8ff69732
DJ
753#ifdef CONFIG_SMP
754 struct cpufreq_policy *managed_policy;
755#endif
1da177e4 756
c32b6b8e
AR
757 if (cpu_is_offline(cpu))
758 return 0;
759
1da177e4
LT
760 cpufreq_debug_disable_ratelimit();
761 dprintk("adding CPU %u\n", cpu);
762
763#ifdef CONFIG_SMP
764 /* check whether a different CPU already registered this
765 * CPU because it is in the same boat. */
766 policy = cpufreq_cpu_get(cpu);
767 if (unlikely(policy)) {
8ff69732 768 cpufreq_cpu_put(policy);
1da177e4
LT
769 cpufreq_debug_enable_ratelimit();
770 return 0;
771 }
772#endif
773
774 if (!try_module_get(cpufreq_driver->owner)) {
775 ret = -EINVAL;
776 goto module_out;
777 }
778
e98df50c 779 policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
1da177e4
LT
780 if (!policy) {
781 ret = -ENOMEM;
782 goto nomem_out;
783 }
1da177e4
LT
784
785 policy->cpu = cpu;
786 policy->cpus = cpumask_of_cpu(cpu);
787
5a01f2e8
VP
788 /* Initially set CPU itself as the policy_cpu */
789 per_cpu(policy_cpu, cpu) = cpu;
790 lock_policy_rwsem_write(cpu);
791
1da177e4 792 init_completion(&policy->kobj_unregister);
65f27f38 793 INIT_WORK(&policy->update, handle_update);
1da177e4 794
8122c6ce
TR
795 /* Set governor before ->init, so that driver could check it */
796 policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
1da177e4
LT
797 /* call driver. From then on the cpufreq must be able
798 * to accept all calls to ->verify and ->setpolicy for this CPU
799 */
800 ret = cpufreq_driver->init(policy);
801 if (ret) {
802 dprintk("initialization failed\n");
5a01f2e8 803 unlock_policy_rwsem_write(cpu);
1da177e4
LT
804 goto err_out;
805 }
22c970f3
TR
806 policy->user_policy.min = policy->cpuinfo.min_freq;
807 policy->user_policy.max = policy->cpuinfo.max_freq;
1da177e4 808
8ff69732 809#ifdef CONFIG_SMP
084f3493
TR
810
811#ifdef CONFIG_HOTPLUG_CPU
812 if (cpufreq_cpu_governor[cpu]){
813 policy->governor = cpufreq_cpu_governor[cpu];
814 dprintk("Restoring governor %s for cpu %d\n",
815 policy->governor->name, cpu);
816 }
817#endif
818
8ff69732
DJ
819 for_each_cpu_mask(j, policy->cpus) {
820 if (cpu == j)
821 continue;
822
823 /* check for existing affected CPUs. They may not be aware
824 * of it due to CPU Hotplug.
825 */
826 managed_policy = cpufreq_cpu_get(j);
827 if (unlikely(managed_policy)) {
5a01f2e8
VP
828
829 /* Set proper policy_cpu */
830 unlock_policy_rwsem_write(cpu);
831 per_cpu(policy_cpu, cpu) = managed_policy->cpu;
832
833 if (lock_policy_rwsem_write(cpu) < 0)
834 goto err_out_driver_exit;
835
8ff69732
DJ
836 spin_lock_irqsave(&cpufreq_driver_lock, flags);
837 managed_policy->cpus = policy->cpus;
838 cpufreq_cpu_data[cpu] = managed_policy;
839 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
840
841 dprintk("CPU already managed, adding link\n");
0142f9dc
AD
842 ret = sysfs_create_link(&sys_dev->kobj,
843 &managed_policy->kobj,
844 "cpufreq");
845 if (ret) {
5a01f2e8 846 unlock_policy_rwsem_write(cpu);
0142f9dc
AD
847 goto err_out_driver_exit;
848 }
8ff69732
DJ
849
850 cpufreq_debug_enable_ratelimit();
8ff69732 851 ret = 0;
5a01f2e8 852 unlock_policy_rwsem_write(cpu);
8ff69732
DJ
853 goto err_out_driver_exit; /* call driver->exit() */
854 }
855 }
856#endif
1da177e4
LT
857 memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
858
859 /* prepare interface data */
038c5b3e
GKH
860 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq, &sys_dev->kobj,
861 "cpufreq");
f3876c1b 862 if (ret) {
5a01f2e8 863 unlock_policy_rwsem_write(cpu);
8085e1f1 864 goto err_out_driver_exit;
f3876c1b 865 }
1da177e4
LT
866 /* set up files for this cpu device */
867 drv_attr = cpufreq_driver->attr;
868 while ((drv_attr) && (*drv_attr)) {
58a7295b 869 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
bd6cba53
DJ
870 if (ret) {
871 unlock_policy_rwsem_write(cpu);
0a4b2ccc 872 goto err_out_driver_exit;
bd6cba53 873 }
1da177e4
LT
874 drv_attr++;
875 }
0a4b2ccc 876 if (cpufreq_driver->get){
58a7295b 877 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
bd6cba53
DJ
878 if (ret) {
879 unlock_policy_rwsem_write(cpu);
0a4b2ccc 880 goto err_out_driver_exit;
bd6cba53 881 }
0a4b2ccc
TR
882 }
883 if (cpufreq_driver->target){
58a7295b 884 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
bd6cba53
DJ
885 if (ret) {
886 unlock_policy_rwsem_write(cpu);
0a4b2ccc 887 goto err_out_driver_exit;
bd6cba53 888 }
0a4b2ccc 889 }
1da177e4
LT
890
891 spin_lock_irqsave(&cpufreq_driver_lock, flags);
5a01f2e8 892 for_each_cpu_mask(j, policy->cpus) {
1da177e4 893 cpufreq_cpu_data[j] = policy;
5a01f2e8
VP
894 per_cpu(policy_cpu, j) = policy->cpu;
895 }
1da177e4 896 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
8ff69732
DJ
897
898 /* symlink affected CPUs */
899 for_each_cpu_mask(j, policy->cpus) {
900 if (j == cpu)
901 continue;
902 if (!cpu_online(j))
903 continue;
904
1f8b2c9d 905 dprintk("CPU %u already managed, adding link\n", j);
8ff69732
DJ
906 cpufreq_cpu_get(cpu);
907 cpu_sys_dev = get_cpu_sysdev(j);
0142f9dc
AD
908 ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
909 "cpufreq");
910 if (ret) {
5a01f2e8 911 unlock_policy_rwsem_write(cpu);
0142f9dc
AD
912 goto err_out_unregister;
913 }
8ff69732
DJ
914 }
915
1da177e4
LT
916 policy->governor = NULL; /* to assure that the starting sequence is
917 * run in cpufreq_set_policy */
87c32271 918
1da177e4 919 /* set default policy */
22c970f3
TR
920 ret = __cpufreq_set_policy(policy, &new_policy);
921 policy->user_policy.policy = policy->policy;
084f3493 922 policy->user_policy.governor = policy->governor;
22c970f3
TR
923
924 unlock_policy_rwsem_write(cpu);
925
1da177e4
LT
926 if (ret) {
927 dprintk("setting policy failed\n");
928 goto err_out_unregister;
929 }
930
038c5b3e 931 kobject_uevent(&policy->kobj, KOBJ_ADD);
1da177e4 932 module_put(cpufreq_driver->owner);
1da177e4
LT
933 dprintk("initialization complete\n");
934 cpufreq_debug_enable_ratelimit();
87c32271 935
1da177e4
LT
936 return 0;
937
938
939err_out_unregister:
940 spin_lock_irqsave(&cpufreq_driver_lock, flags);
941 for_each_cpu_mask(j, policy->cpus)
942 cpufreq_cpu_data[j] = NULL;
943 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
944
c10997f6 945 kobject_put(&policy->kobj);
1da177e4
LT
946 wait_for_completion(&policy->kobj_unregister);
947
8085e1f1
VP
948err_out_driver_exit:
949 if (cpufreq_driver->exit)
950 cpufreq_driver->exit(policy);
951
1da177e4
LT
952err_out:
953 kfree(policy);
954
955nomem_out:
956 module_put(cpufreq_driver->owner);
c32b6b8e 957module_out:
1da177e4
LT
958 cpufreq_debug_enable_ratelimit();
959 return ret;
960}
961
962
963/**
5a01f2e8 964 * __cpufreq_remove_dev - remove a CPU device
1da177e4
LT
965 *
966 * Removes the cpufreq interface for a CPU device.
5a01f2e8
VP
967 * Caller should already have policy_rwsem in write mode for this CPU.
968 * This routine frees the rwsem before returning.
1da177e4 969 */
5a01f2e8 970static int __cpufreq_remove_dev (struct sys_device * sys_dev)
1da177e4
LT
971{
972 unsigned int cpu = sys_dev->id;
973 unsigned long flags;
974 struct cpufreq_policy *data;
975#ifdef CONFIG_SMP
e738cf6d 976 struct sys_device *cpu_sys_dev;
1da177e4
LT
977 unsigned int j;
978#endif
979
980 cpufreq_debug_disable_ratelimit();
981 dprintk("unregistering CPU %u\n", cpu);
982
983 spin_lock_irqsave(&cpufreq_driver_lock, flags);
984 data = cpufreq_cpu_data[cpu];
985
986 if (!data) {
987 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1da177e4 988 cpufreq_debug_enable_ratelimit();
5a01f2e8 989 unlock_policy_rwsem_write(cpu);
1da177e4
LT
990 return -EINVAL;
991 }
992 cpufreq_cpu_data[cpu] = NULL;
993
994
995#ifdef CONFIG_SMP
996 /* if this isn't the CPU which is the parent of the kobj, we
32ee8c3e 997 * only need to unlink, put and exit
1da177e4
LT
998 */
999 if (unlikely(cpu != data->cpu)) {
1000 dprintk("removing link\n");
8ff69732 1001 cpu_clear(cpu, data->cpus);
1da177e4
LT
1002 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1003 sysfs_remove_link(&sys_dev->kobj, "cpufreq");
1da177e4
LT
1004 cpufreq_cpu_put(data);
1005 cpufreq_debug_enable_ratelimit();
5a01f2e8 1006 unlock_policy_rwsem_write(cpu);
1da177e4
LT
1007 return 0;
1008 }
1009#endif
1010
1da177e4 1011#ifdef CONFIG_SMP
084f3493
TR
1012
1013#ifdef CONFIG_HOTPLUG_CPU
1014 cpufreq_cpu_governor[cpu] = data->governor;
1015#endif
1016
1da177e4
LT
1017 /* if we have other CPUs still registered, we need to unlink them,
1018 * or else wait_for_completion below will lock up. Clean the
1019 * cpufreq_cpu_data[] while holding the lock, and remove the sysfs
1020 * links afterwards.
1021 */
1022 if (unlikely(cpus_weight(data->cpus) > 1)) {
1023 for_each_cpu_mask(j, data->cpus) {
1024 if (j == cpu)
1025 continue;
1026 cpufreq_cpu_data[j] = NULL;
1027 }
1028 }
1029
1030 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1031
1032 if (unlikely(cpus_weight(data->cpus) > 1)) {
1033 for_each_cpu_mask(j, data->cpus) {
1034 if (j == cpu)
1035 continue;
1036 dprintk("removing link for cpu %u\n", j);
084f3493
TR
1037#ifdef CONFIG_HOTPLUG_CPU
1038 cpufreq_cpu_governor[j] = data->governor;
1039#endif
d434fca7
AR
1040 cpu_sys_dev = get_cpu_sysdev(j);
1041 sysfs_remove_link(&cpu_sys_dev->kobj, "cpufreq");
1da177e4
LT
1042 cpufreq_cpu_put(data);
1043 }
1044 }
1045#else
1046 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1047#endif
1048
1da177e4
LT
1049 if (cpufreq_driver->target)
1050 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
5a01f2e8
VP
1051
1052 unlock_policy_rwsem_write(cpu);
1da177e4 1053
1da177e4
LT
1054 kobject_put(&data->kobj);
1055
1056 /* we need to make sure that the underlying kobj is actually
32ee8c3e 1057 * not referenced anymore by anybody before we proceed with
1da177e4
LT
1058 * unloading.
1059 */
1060 dprintk("waiting for dropping of refcount\n");
1061 wait_for_completion(&data->kobj_unregister);
1062 dprintk("wait complete\n");
1063
1064 if (cpufreq_driver->exit)
1065 cpufreq_driver->exit(data);
1066
1067 kfree(data);
1068
1069 cpufreq_debug_enable_ratelimit();
1da177e4
LT
1070 return 0;
1071}
1072
1073
5a01f2e8
VP
1074static int cpufreq_remove_dev (struct sys_device * sys_dev)
1075{
1076 unsigned int cpu = sys_dev->id;
1077 int retval;
ec28297a
VP
1078
1079 if (cpu_is_offline(cpu))
1080 return 0;
1081
5a01f2e8
VP
1082 if (unlikely(lock_policy_rwsem_write(cpu)))
1083 BUG();
1084
1085 retval = __cpufreq_remove_dev(sys_dev);
1086 return retval;
1087}
1088
1089
65f27f38 1090static void handle_update(struct work_struct *work)
1da177e4 1091{
65f27f38
DH
1092 struct cpufreq_policy *policy =
1093 container_of(work, struct cpufreq_policy, update);
1094 unsigned int cpu = policy->cpu;
1da177e4
LT
1095 dprintk("handle_update for cpu %u called\n", cpu);
1096 cpufreq_update_policy(cpu);
1097}
1098
1099/**
1100 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
1101 * @cpu: cpu number
1102 * @old_freq: CPU frequency the kernel thinks the CPU runs at
1103 * @new_freq: CPU frequency the CPU actually runs at
1104 *
1105 * We adjust to current frequency first, and need to clean up later. So either call
1106 * to cpufreq_update_policy() or schedule handle_update()).
1107 */
e08f5f5b
GS
1108static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1109 unsigned int new_freq)
1da177e4
LT
1110{
1111 struct cpufreq_freqs freqs;
1112
b10eec22 1113 dprintk("Warning: CPU frequency out of sync: cpufreq and timing "
1da177e4
LT
1114 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1115
1116 freqs.cpu = cpu;
1117 freqs.old = old_freq;
1118 freqs.new = new_freq;
1119 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
1120 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
1121}
1122
1123
32ee8c3e 1124/**
4ab70df4 1125 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
95235ca2
VP
1126 * @cpu: CPU number
1127 *
1128 * This is the last known freq, without actually getting it from the driver.
1129 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1130 */
1131unsigned int cpufreq_quick_get(unsigned int cpu)
1132{
1133 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
e08f5f5b 1134 unsigned int ret_freq = 0;
95235ca2
VP
1135
1136 if (policy) {
e08f5f5b 1137 ret_freq = policy->cur;
95235ca2
VP
1138 cpufreq_cpu_put(policy);
1139 }
1140
e08f5f5b 1141 return (ret_freq);
95235ca2
VP
1142}
1143EXPORT_SYMBOL(cpufreq_quick_get);
1144
1145
5a01f2e8 1146static unsigned int __cpufreq_get(unsigned int cpu)
1da177e4 1147{
5a01f2e8 1148 struct cpufreq_policy *policy = cpufreq_cpu_data[cpu];
e08f5f5b 1149 unsigned int ret_freq = 0;
1da177e4 1150
1da177e4 1151 if (!cpufreq_driver->get)
5a01f2e8 1152 return (ret_freq);
1da177e4 1153
e08f5f5b 1154 ret_freq = cpufreq_driver->get(cpu);
1da177e4 1155
e08f5f5b
GS
1156 if (ret_freq && policy->cur &&
1157 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1158 /* verify no discrepancy between actual and
1159 saved value exists */
1160 if (unlikely(ret_freq != policy->cur)) {
1161 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
1da177e4
LT
1162 schedule_work(&policy->update);
1163 }
1164 }
1165
5a01f2e8
VP
1166 return (ret_freq);
1167}
1da177e4 1168
5a01f2e8
VP
1169/**
1170 * cpufreq_get - get the current CPU frequency (in kHz)
1171 * @cpu: CPU number
1172 *
1173 * Get the CPU current (static) CPU frequency
1174 */
1175unsigned int cpufreq_get(unsigned int cpu)
1176{
1177 unsigned int ret_freq = 0;
1178 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1179
1180 if (!policy)
1181 goto out;
1182
1183 if (unlikely(lock_policy_rwsem_read(cpu)))
1184 goto out_policy;
1185
1186 ret_freq = __cpufreq_get(cpu);
1187
1188 unlock_policy_rwsem_read(cpu);
1da177e4 1189
5a01f2e8
VP
1190out_policy:
1191 cpufreq_cpu_put(policy);
1192out:
e08f5f5b 1193 return (ret_freq);
1da177e4
LT
1194}
1195EXPORT_SYMBOL(cpufreq_get);
1196
1197
42d4dc3f
BH
1198/**
1199 * cpufreq_suspend - let the low level driver prepare for suspend
1200 */
1201
e00d9967 1202static int cpufreq_suspend(struct sys_device * sysdev, pm_message_t pmsg)
42d4dc3f
BH
1203{
1204 int cpu = sysdev->id;
e08f5f5b 1205 int ret = 0;
42d4dc3f
BH
1206 unsigned int cur_freq = 0;
1207 struct cpufreq_policy *cpu_policy;
1208
0e37b159 1209 dprintk("suspending cpu %u\n", cpu);
42d4dc3f
BH
1210
1211 if (!cpu_online(cpu))
1212 return 0;
1213
1214 /* we may be lax here as interrupts are off. Nonetheless
1215 * we need to grab the correct cpu policy, as to check
1216 * whether we really run on this CPU.
1217 */
1218
1219 cpu_policy = cpufreq_cpu_get(cpu);
1220 if (!cpu_policy)
1221 return -EINVAL;
1222
1223 /* only handle each CPU group once */
1224 if (unlikely(cpu_policy->cpu != cpu)) {
1225 cpufreq_cpu_put(cpu_policy);
1226 return 0;
1227 }
1228
1229 if (cpufreq_driver->suspend) {
e00d9967 1230 ret = cpufreq_driver->suspend(cpu_policy, pmsg);
42d4dc3f
BH
1231 if (ret) {
1232 printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1233 "step on CPU %u\n", cpu_policy->cpu);
1234 cpufreq_cpu_put(cpu_policy);
1235 return ret;
1236 }
1237 }
1238
1239
1240 if (cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)
1241 goto out;
1242
1243 if (cpufreq_driver->get)
1244 cur_freq = cpufreq_driver->get(cpu_policy->cpu);
1245
1246 if (!cur_freq || !cpu_policy->cur) {
1247 printk(KERN_ERR "cpufreq: suspend failed to assert current "
1248 "frequency is what timing core thinks it is.\n");
1249 goto out;
1250 }
1251
1252 if (unlikely(cur_freq != cpu_policy->cur)) {
1253 struct cpufreq_freqs freqs;
1254
1255 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
b10eec22 1256 dprintk("Warning: CPU frequency is %u, "
42d4dc3f
BH
1257 "cpufreq assumed %u kHz.\n",
1258 cur_freq, cpu_policy->cur);
1259
1260 freqs.cpu = cpu;
1261 freqs.old = cpu_policy->cur;
1262 freqs.new = cur_freq;
1263
b4dfdbb3 1264 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
42d4dc3f
BH
1265 CPUFREQ_SUSPENDCHANGE, &freqs);
1266 adjust_jiffies(CPUFREQ_SUSPENDCHANGE, &freqs);
1267
1268 cpu_policy->cur = cur_freq;
1269 }
1270
7d5e350f 1271out:
42d4dc3f
BH
1272 cpufreq_cpu_put(cpu_policy);
1273 return 0;
1274}
1275
1da177e4
LT
1276/**
1277 * cpufreq_resume - restore proper CPU frequency handling after resume
1278 *
1279 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
1280 * 2.) if ->target and !CPUFREQ_CONST_LOOPS: verify we're in sync
42d4dc3f
BH
1281 * 3.) schedule call cpufreq_update_policy() ASAP as interrupts are
1282 * restored.
1da177e4
LT
1283 */
1284static int cpufreq_resume(struct sys_device * sysdev)
1285{
1286 int cpu = sysdev->id;
e08f5f5b 1287 int ret = 0;
1da177e4
LT
1288 struct cpufreq_policy *cpu_policy;
1289
1290 dprintk("resuming cpu %u\n", cpu);
1291
1292 if (!cpu_online(cpu))
1293 return 0;
1294
1295 /* we may be lax here as interrupts are off. Nonetheless
1296 * we need to grab the correct cpu policy, as to check
1297 * whether we really run on this CPU.
1298 */
1299
1300 cpu_policy = cpufreq_cpu_get(cpu);
1301 if (!cpu_policy)
1302 return -EINVAL;
1303
1304 /* only handle each CPU group once */
1305 if (unlikely(cpu_policy->cpu != cpu)) {
1306 cpufreq_cpu_put(cpu_policy);
1307 return 0;
1308 }
1309
1310 if (cpufreq_driver->resume) {
1311 ret = cpufreq_driver->resume(cpu_policy);
1312 if (ret) {
1313 printk(KERN_ERR "cpufreq: resume failed in ->resume "
1314 "step on CPU %u\n", cpu_policy->cpu);
1315 cpufreq_cpu_put(cpu_policy);
1316 return ret;
1317 }
1318 }
1319
1320 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1321 unsigned int cur_freq = 0;
1322
1323 if (cpufreq_driver->get)
1324 cur_freq = cpufreq_driver->get(cpu_policy->cpu);
1325
1326 if (!cur_freq || !cpu_policy->cur) {
42d4dc3f
BH
1327 printk(KERN_ERR "cpufreq: resume failed to assert "
1328 "current frequency is what timing core "
1329 "thinks it is.\n");
1da177e4
LT
1330 goto out;
1331 }
1332
1333 if (unlikely(cur_freq != cpu_policy->cur)) {
1334 struct cpufreq_freqs freqs;
1335
ac09f698 1336 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
a4a9df58 1337 dprintk("Warning: CPU frequency "
ac09f698
BH
1338 "is %u, cpufreq assumed %u kHz.\n",
1339 cur_freq, cpu_policy->cur);
1da177e4
LT
1340
1341 freqs.cpu = cpu;
1342 freqs.old = cpu_policy->cur;
1343 freqs.new = cur_freq;
1344
b4dfdbb3 1345 srcu_notifier_call_chain(
e041c683 1346 &cpufreq_transition_notifier_list,
42d4dc3f 1347 CPUFREQ_RESUMECHANGE, &freqs);
1da177e4
LT
1348 adjust_jiffies(CPUFREQ_RESUMECHANGE, &freqs);
1349
1350 cpu_policy->cur = cur_freq;
1351 }
1352 }
1353
1354out:
1355 schedule_work(&cpu_policy->update);
1356 cpufreq_cpu_put(cpu_policy);
1357 return ret;
1358}
1359
1360static struct sysdev_driver cpufreq_sysdev_driver = {
1361 .add = cpufreq_add_dev,
1362 .remove = cpufreq_remove_dev,
42d4dc3f 1363 .suspend = cpufreq_suspend,
1da177e4
LT
1364 .resume = cpufreq_resume,
1365};
1366
1367
1368/*********************************************************************
1369 * NOTIFIER LISTS INTERFACE *
1370 *********************************************************************/
1371
1372/**
1373 * cpufreq_register_notifier - register a driver with cpufreq
1374 * @nb: notifier function to register
1375 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1376 *
32ee8c3e 1377 * Add a driver to one of two lists: either a list of drivers that
1da177e4
LT
1378 * are notified about clock rate changes (once before and once after
1379 * the transition), or a list of drivers that are notified about
1380 * changes in cpufreq policy.
1381 *
1382 * This function may sleep, and has the same return conditions as
e041c683 1383 * blocking_notifier_chain_register.
1da177e4
LT
1384 */
1385int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1386{
1387 int ret;
1388
1da177e4
LT
1389 switch (list) {
1390 case CPUFREQ_TRANSITION_NOTIFIER:
b4dfdbb3 1391 ret = srcu_notifier_chain_register(
e041c683 1392 &cpufreq_transition_notifier_list, nb);
1da177e4
LT
1393 break;
1394 case CPUFREQ_POLICY_NOTIFIER:
e041c683
AS
1395 ret = blocking_notifier_chain_register(
1396 &cpufreq_policy_notifier_list, nb);
1da177e4
LT
1397 break;
1398 default:
1399 ret = -EINVAL;
1400 }
1da177e4
LT
1401
1402 return ret;
1403}
1404EXPORT_SYMBOL(cpufreq_register_notifier);
1405
1406
1407/**
1408 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1409 * @nb: notifier block to be unregistered
1410 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1411 *
1412 * Remove a driver from the CPU frequency notifier list.
1413 *
1414 * This function may sleep, and has the same return conditions as
e041c683 1415 * blocking_notifier_chain_unregister.
1da177e4
LT
1416 */
1417int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1418{
1419 int ret;
1420
1da177e4
LT
1421 switch (list) {
1422 case CPUFREQ_TRANSITION_NOTIFIER:
b4dfdbb3 1423 ret = srcu_notifier_chain_unregister(
e041c683 1424 &cpufreq_transition_notifier_list, nb);
1da177e4
LT
1425 break;
1426 case CPUFREQ_POLICY_NOTIFIER:
e041c683
AS
1427 ret = blocking_notifier_chain_unregister(
1428 &cpufreq_policy_notifier_list, nb);
1da177e4
LT
1429 break;
1430 default:
1431 ret = -EINVAL;
1432 }
1da177e4
LT
1433
1434 return ret;
1435}
1436EXPORT_SYMBOL(cpufreq_unregister_notifier);
1437
1438
1439/*********************************************************************
1440 * GOVERNORS *
1441 *********************************************************************/
1442
1443
1444int __cpufreq_driver_target(struct cpufreq_policy *policy,
1445 unsigned int target_freq,
1446 unsigned int relation)
1447{
1448 int retval = -EINVAL;
c32b6b8e 1449
1da177e4
LT
1450 dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
1451 target_freq, relation);
1452 if (cpu_online(policy->cpu) && cpufreq_driver->target)
1453 retval = cpufreq_driver->target(policy, target_freq, relation);
90d45d17 1454
1da177e4
LT
1455 return retval;
1456}
1457EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1458
1da177e4
LT
1459int cpufreq_driver_target(struct cpufreq_policy *policy,
1460 unsigned int target_freq,
1461 unsigned int relation)
1462{
cc993cab 1463 int ret;
1da177e4
LT
1464
1465 policy = cpufreq_cpu_get(policy->cpu);
1466 if (!policy)
1467 return -EINVAL;
1468
5a01f2e8
VP
1469 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
1470 return -EINVAL;
1da177e4
LT
1471
1472 ret = __cpufreq_driver_target(policy, target_freq, relation);
1473
5a01f2e8 1474 unlock_policy_rwsem_write(policy->cpu);
1da177e4
LT
1475
1476 cpufreq_cpu_put(policy);
1da177e4
LT
1477 return ret;
1478}
1479EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1480
5a01f2e8 1481int __cpufreq_driver_getavg(struct cpufreq_policy *policy)
dfde5d62
VP
1482{
1483 int ret = 0;
1484
1485 policy = cpufreq_cpu_get(policy->cpu);
1486 if (!policy)
1487 return -EINVAL;
1488
dfde5d62
VP
1489 if (cpu_online(policy->cpu) && cpufreq_driver->getavg)
1490 ret = cpufreq_driver->getavg(policy->cpu);
1491
dfde5d62
VP
1492 cpufreq_cpu_put(policy);
1493 return ret;
1494}
5a01f2e8 1495EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
dfde5d62 1496
153d7f3f 1497/*
153d7f3f
AV
1498 * when "event" is CPUFREQ_GOV_LIMITS
1499 */
1da177e4 1500
e08f5f5b
GS
1501static int __cpufreq_governor(struct cpufreq_policy *policy,
1502 unsigned int event)
1da177e4 1503{
cc993cab 1504 int ret;
6afde10c
TR
1505
1506 /* Only must be defined when default governor is known to have latency
1507 restrictions, like e.g. conservative or ondemand.
1508 That this is the case is already ensured in Kconfig
1509 */
1510#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1511 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1512#else
1513 struct cpufreq_governor *gov = NULL;
1514#endif
1c256245
TR
1515
1516 if (policy->governor->max_transition_latency &&
1517 policy->cpuinfo.transition_latency >
1518 policy->governor->max_transition_latency) {
6afde10c
TR
1519 if (!gov)
1520 return -EINVAL;
1521 else {
1522 printk(KERN_WARNING "%s governor failed, too long"
1523 " transition latency of HW, fallback"
1524 " to %s governor\n",
1525 policy->governor->name,
1526 gov->name);
1527 policy->governor = gov;
1528 }
1c256245 1529 }
1da177e4
LT
1530
1531 if (!try_module_get(policy->governor->owner))
1532 return -EINVAL;
1533
e08f5f5b
GS
1534 dprintk("__cpufreq_governor for CPU %u, event %u\n",
1535 policy->cpu, event);
1da177e4
LT
1536 ret = policy->governor->governor(policy, event);
1537
e08f5f5b
GS
1538 /* we keep one module reference alive for
1539 each CPU governed by this CPU */
1da177e4
LT
1540 if ((event != CPUFREQ_GOV_START) || ret)
1541 module_put(policy->governor->owner);
1542 if ((event == CPUFREQ_GOV_STOP) && !ret)
1543 module_put(policy->governor->owner);
1544
1545 return ret;
1546}
1547
1548
1da177e4
LT
1549int cpufreq_register_governor(struct cpufreq_governor *governor)
1550{
3bcb09a3 1551 int err;
1da177e4
LT
1552
1553 if (!governor)
1554 return -EINVAL;
1555
3fc54d37 1556 mutex_lock(&cpufreq_governor_mutex);
32ee8c3e 1557
3bcb09a3
JF
1558 err = -EBUSY;
1559 if (__find_governor(governor->name) == NULL) {
1560 err = 0;
1561 list_add(&governor->governor_list, &cpufreq_governor_list);
1da177e4 1562 }
1da177e4 1563
32ee8c3e 1564 mutex_unlock(&cpufreq_governor_mutex);
3bcb09a3 1565 return err;
1da177e4
LT
1566}
1567EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1568
1569
1570void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1571{
1572 if (!governor)
1573 return;
1574
3fc54d37 1575 mutex_lock(&cpufreq_governor_mutex);
1da177e4 1576 list_del(&governor->governor_list);
3fc54d37 1577 mutex_unlock(&cpufreq_governor_mutex);
1da177e4
LT
1578 return;
1579}
1580EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1581
1582
1583
1584/*********************************************************************
1585 * POLICY INTERFACE *
1586 *********************************************************************/
1587
1588/**
1589 * cpufreq_get_policy - get the current cpufreq_policy
1590 * @policy: struct cpufreq_policy into which the current cpufreq_policy is written
1591 *
1592 * Reads the current cpufreq policy.
1593 */
1594int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1595{
1596 struct cpufreq_policy *cpu_policy;
1597 if (!policy)
1598 return -EINVAL;
1599
1600 cpu_policy = cpufreq_cpu_get(cpu);
1601 if (!cpu_policy)
1602 return -EINVAL;
1603
1da177e4 1604 memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
1da177e4
LT
1605
1606 cpufreq_cpu_put(cpu_policy);
1da177e4
LT
1607 return 0;
1608}
1609EXPORT_SYMBOL(cpufreq_get_policy);
1610
1611
153d7f3f 1612/*
e08f5f5b
GS
1613 * data : current policy.
1614 * policy : policy to be set.
153d7f3f 1615 */
e08f5f5b
GS
1616static int __cpufreq_set_policy(struct cpufreq_policy *data,
1617 struct cpufreq_policy *policy)
1da177e4
LT
1618{
1619 int ret = 0;
1620
1621 cpufreq_debug_disable_ratelimit();
1622 dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
1623 policy->min, policy->max);
1624
e08f5f5b
GS
1625 memcpy(&policy->cpuinfo, &data->cpuinfo,
1626 sizeof(struct cpufreq_cpuinfo));
1da177e4 1627
53391fa2 1628 if (policy->min > data->max || policy->max < data->min) {
9c9a43ed
MD
1629 ret = -EINVAL;
1630 goto error_out;
1631 }
1632
1da177e4
LT
1633 /* verify the cpu speed can be set within this limit */
1634 ret = cpufreq_driver->verify(policy);
1635 if (ret)
1636 goto error_out;
1637
1da177e4 1638 /* adjust if necessary - all reasons */
e041c683
AS
1639 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1640 CPUFREQ_ADJUST, policy);
1da177e4
LT
1641
1642 /* adjust if necessary - hardware incompatibility*/
e041c683
AS
1643 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1644 CPUFREQ_INCOMPATIBLE, policy);
1da177e4
LT
1645
1646 /* verify the cpu speed can be set within this limit,
1647 which might be different to the first one */
1648 ret = cpufreq_driver->verify(policy);
e041c683 1649 if (ret)
1da177e4 1650 goto error_out;
1da177e4
LT
1651
1652 /* notification of the new policy */
e041c683
AS
1653 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1654 CPUFREQ_NOTIFY, policy);
1da177e4 1655
7d5e350f
DJ
1656 data->min = policy->min;
1657 data->max = policy->max;
1da177e4 1658
e08f5f5b
GS
1659 dprintk("new min and max freqs are %u - %u kHz\n",
1660 data->min, data->max);
1da177e4
LT
1661
1662 if (cpufreq_driver->setpolicy) {
1663 data->policy = policy->policy;
1664 dprintk("setting range\n");
1665 ret = cpufreq_driver->setpolicy(policy);
1666 } else {
1667 if (policy->governor != data->governor) {
1668 /* save old, working values */
1669 struct cpufreq_governor *old_gov = data->governor;
1670
1671 dprintk("governor switch\n");
1672
1673 /* end old governor */
1674 if (data->governor)
1675 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1676
1677 /* start new governor */
1678 data->governor = policy->governor;
1679 if (__cpufreq_governor(data, CPUFREQ_GOV_START)) {
1680 /* new governor failed, so re-start old one */
e08f5f5b
GS
1681 dprintk("starting governor %s failed\n",
1682 data->governor->name);
1da177e4
LT
1683 if (old_gov) {
1684 data->governor = old_gov;
e08f5f5b
GS
1685 __cpufreq_governor(data,
1686 CPUFREQ_GOV_START);
1da177e4
LT
1687 }
1688 ret = -EINVAL;
1689 goto error_out;
1690 }
1691 /* might be a policy change, too, so fall through */
1692 }
1693 dprintk("governor: change or update limits\n");
1694 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1695 }
1696
7d5e350f 1697error_out:
1da177e4
LT
1698 cpufreq_debug_enable_ratelimit();
1699 return ret;
1700}
1701
1da177e4
LT
1702/**
1703 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1704 * @cpu: CPU which shall be re-evaluated
1705 *
1706 * Usefull for policy notifiers which have different necessities
1707 * at different times.
1708 */
1709int cpufreq_update_policy(unsigned int cpu)
1710{
1711 struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
1712 struct cpufreq_policy policy;
1713 int ret = 0;
1714
1715 if (!data)
1716 return -ENODEV;
1717
5a01f2e8
VP
1718 if (unlikely(lock_policy_rwsem_write(cpu)))
1719 return -EINVAL;
1da177e4
LT
1720
1721 dprintk("updating policy for CPU %u\n", cpu);
7d5e350f 1722 memcpy(&policy, data, sizeof(struct cpufreq_policy));
1da177e4
LT
1723 policy.min = data->user_policy.min;
1724 policy.max = data->user_policy.max;
1725 policy.policy = data->user_policy.policy;
1726 policy.governor = data->user_policy.governor;
1727
0961dd0d
TR
1728 /* BIOS might change freq behind our back
1729 -> ask driver for current freq and notify governors about a change */
1730 if (cpufreq_driver->get) {
1731 policy.cur = cpufreq_driver->get(cpu);
a85f7bd3
TR
1732 if (!data->cur) {
1733 dprintk("Driver did not initialize current freq");
1734 data->cur = policy.cur;
1735 } else {
1736 if (data->cur != policy.cur)
e08f5f5b
GS
1737 cpufreq_out_of_sync(cpu, data->cur,
1738 policy.cur);
a85f7bd3 1739 }
0961dd0d
TR
1740 }
1741
1da177e4
LT
1742 ret = __cpufreq_set_policy(data, &policy);
1743
5a01f2e8
VP
1744 unlock_policy_rwsem_write(cpu);
1745
1da177e4
LT
1746 cpufreq_cpu_put(data);
1747 return ret;
1748}
1749EXPORT_SYMBOL(cpufreq_update_policy);
1750
dd184a01 1751static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
c32b6b8e
AR
1752 unsigned long action, void *hcpu)
1753{
1754 unsigned int cpu = (unsigned long)hcpu;
c32b6b8e
AR
1755 struct sys_device *sys_dev;
1756
1757 sys_dev = get_cpu_sysdev(cpu);
c32b6b8e
AR
1758 if (sys_dev) {
1759 switch (action) {
1760 case CPU_ONLINE:
8bb78442 1761 case CPU_ONLINE_FROZEN:
c32b6b8e
AR
1762 cpufreq_add_dev(sys_dev);
1763 break;
1764 case CPU_DOWN_PREPARE:
8bb78442 1765 case CPU_DOWN_PREPARE_FROZEN:
5a01f2e8
VP
1766 if (unlikely(lock_policy_rwsem_write(cpu)))
1767 BUG();
1768
5a01f2e8 1769 __cpufreq_remove_dev(sys_dev);
c32b6b8e 1770 break;
5a01f2e8 1771 case CPU_DOWN_FAILED:
8bb78442 1772 case CPU_DOWN_FAILED_FROZEN:
5a01f2e8 1773 cpufreq_add_dev(sys_dev);
c32b6b8e
AR
1774 break;
1775 }
1776 }
1777 return NOTIFY_OK;
1778}
1779
74b85f37 1780static struct notifier_block __cpuinitdata cpufreq_cpu_notifier =
c32b6b8e
AR
1781{
1782 .notifier_call = cpufreq_cpu_callback,
1783};
1da177e4
LT
1784
1785/*********************************************************************
1786 * REGISTER / UNREGISTER CPUFREQ DRIVER *
1787 *********************************************************************/
1788
1789/**
1790 * cpufreq_register_driver - register a CPU Frequency driver
1791 * @driver_data: A struct cpufreq_driver containing the values#
1792 * submitted by the CPU Frequency driver.
1793 *
32ee8c3e 1794 * Registers a CPU Frequency driver to this core code. This code
1da177e4 1795 * returns zero on success, -EBUSY when another driver got here first
32ee8c3e 1796 * (and isn't unregistered in the meantime).
1da177e4
LT
1797 *
1798 */
221dee28 1799int cpufreq_register_driver(struct cpufreq_driver *driver_data)
1da177e4
LT
1800{
1801 unsigned long flags;
1802 int ret;
1803
1804 if (!driver_data || !driver_data->verify || !driver_data->init ||
1805 ((!driver_data->setpolicy) && (!driver_data->target)))
1806 return -EINVAL;
1807
1808 dprintk("trying to register driver %s\n", driver_data->name);
1809
1810 if (driver_data->setpolicy)
1811 driver_data->flags |= CPUFREQ_CONST_LOOPS;
1812
1813 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1814 if (cpufreq_driver) {
1815 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1816 return -EBUSY;
1817 }
1818 cpufreq_driver = driver_data;
1819 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1820
1821 ret = sysdev_driver_register(&cpu_sysdev_class,&cpufreq_sysdev_driver);
1822
1823 if ((!ret) && !(cpufreq_driver->flags & CPUFREQ_STICKY)) {
1824 int i;
1825 ret = -ENODEV;
1826
1827 /* check for at least one working CPU */
1828 for (i=0; i<NR_CPUS; i++)
1829 if (cpufreq_cpu_data[i])
1830 ret = 0;
1831
1832 /* if all ->init() calls failed, unregister */
1833 if (ret) {
e08f5f5b
GS
1834 dprintk("no CPU initialized for driver %s\n",
1835 driver_data->name);
1836 sysdev_driver_unregister(&cpu_sysdev_class,
1837 &cpufreq_sysdev_driver);
1da177e4
LT
1838
1839 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1840 cpufreq_driver = NULL;
1841 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1842 }
1843 }
1844
1845 if (!ret) {
65edc68c 1846 register_hotcpu_notifier(&cpufreq_cpu_notifier);
1da177e4
LT
1847 dprintk("driver %s up and running\n", driver_data->name);
1848 cpufreq_debug_enable_ratelimit();
1849 }
1850
1851 return (ret);
1852}
1853EXPORT_SYMBOL_GPL(cpufreq_register_driver);
1854
1855
1856/**
1857 * cpufreq_unregister_driver - unregister the current CPUFreq driver
1858 *
32ee8c3e 1859 * Unregister the current CPUFreq driver. Only call this if you have
1da177e4
LT
1860 * the right to do so, i.e. if you have succeeded in initialising before!
1861 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
1862 * currently not initialised.
1863 */
221dee28 1864int cpufreq_unregister_driver(struct cpufreq_driver *driver)
1da177e4
LT
1865{
1866 unsigned long flags;
1867
1868 cpufreq_debug_disable_ratelimit();
1869
1870 if (!cpufreq_driver || (driver != cpufreq_driver)) {
1871 cpufreq_debug_enable_ratelimit();
1872 return -EINVAL;
1873 }
1874
1875 dprintk("unregistering driver %s\n", driver->name);
1876
1877 sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
65edc68c 1878 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
1da177e4
LT
1879
1880 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1881 cpufreq_driver = NULL;
1882 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1883
1884 return 0;
1885}
1886EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
5a01f2e8
VP
1887
1888static int __init cpufreq_core_init(void)
1889{
1890 int cpu;
1891
1892 for_each_possible_cpu(cpu) {
1893 per_cpu(policy_cpu, cpu) = -1;
1894 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
1895 }
1896 return 0;
1897}
1898
1899core_initcall(cpufreq_core_init);