2 * linux/drivers/cpufreq/cpufreq.c
4 * Copyright (C) 2001 Russell King
5 * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
7 * Oct 2005 - Ashok Raj <ashok.raj@intel.com>
8 * Added handling for CPU hotplug
9 * Feb 2006 - Jacob Shin <jacob.shin@amd.com>
10 * Fix handling for CPU hotplug -- affected CPUs
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.
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>
30 #include <linux/mutex.h>
32 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
36 * The "cpufreq driver" - the arch- or hardware-dependent low
37 * level driver of CPUFreq support, and its spinlock. This lock
38 * also protects the cpufreq_cpu_data array.
40 static struct cpufreq_driver
*cpufreq_driver
;
41 static struct cpufreq_policy
*cpufreq_cpu_data
[NR_CPUS
];
42 #ifdef CONFIG_HOTPLUG_CPU
43 /* This one keeps track of the previously set governor of a removed CPU */
44 static struct cpufreq_governor
*cpufreq_cpu_governor
[NR_CPUS
];
46 static DEFINE_SPINLOCK(cpufreq_driver_lock
);
49 * cpu_policy_rwsem is a per CPU reader-writer semaphore designed to cure
50 * all cpufreq/hotplug/workqueue/etc related lock issues.
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.
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.
65 static DEFINE_PER_CPU(int, policy_cpu
);
66 static DEFINE_PER_CPU(struct rw_semaphore
, cpu_policy_rwsem
);
68 #define lock_policy_rwsem(mode, cpu) \
69 int lock_policy_rwsem_##mode \
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)); \
83 lock_policy_rwsem(read
, cpu
);
84 EXPORT_SYMBOL_GPL(lock_policy_rwsem_read
);
86 lock_policy_rwsem(write
, cpu
);
87 EXPORT_SYMBOL_GPL(lock_policy_rwsem_write
);
89 void unlock_policy_rwsem_read(int cpu
)
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
));
95 EXPORT_SYMBOL_GPL(unlock_policy_rwsem_read
);
97 void unlock_policy_rwsem_write(int cpu
)
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
));
103 EXPORT_SYMBOL_GPL(unlock_policy_rwsem_write
);
106 /* internal prototypes */
107 static int __cpufreq_governor(struct cpufreq_policy
*policy
, unsigned int event
);
108 static unsigned int __cpufreq_get(unsigned int cpu
);
109 static void handle_update(struct work_struct
*work
);
112 * Two notifier lists: the "policy" list is involved in the
113 * validation process for a new CPU frequency policy; the
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.
118 static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list
);
119 static struct srcu_notifier_head cpufreq_transition_notifier_list
;
121 static int __init
init_cpufreq_transition_notifier_list(void)
123 srcu_init_notifier_head(&cpufreq_transition_notifier_list
);
126 pure_initcall(init_cpufreq_transition_notifier_list
);
128 static LIST_HEAD(cpufreq_governor_list
);
129 static DEFINE_MUTEX (cpufreq_governor_mutex
);
131 struct cpufreq_policy
*cpufreq_cpu_get(unsigned int cpu
)
133 struct cpufreq_policy
*data
;
139 /* get the cpufreq driver */
140 spin_lock_irqsave(&cpufreq_driver_lock
, flags
);
145 if (!try_module_get(cpufreq_driver
->owner
))
150 data
= cpufreq_cpu_data
[cpu
];
153 goto err_out_put_module
;
155 if (!kobject_get(&data
->kobj
))
156 goto err_out_put_module
;
158 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
162 module_put(cpufreq_driver
->owner
);
164 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
168 EXPORT_SYMBOL_GPL(cpufreq_cpu_get
);
171 void cpufreq_cpu_put(struct cpufreq_policy
*data
)
173 kobject_put(&data
->kobj
);
174 module_put(cpufreq_driver
->owner
);
176 EXPORT_SYMBOL_GPL(cpufreq_cpu_put
);
179 /*********************************************************************
180 * UNIFIED DEBUG HELPERS *
181 *********************************************************************/
182 #ifdef CONFIG_CPU_FREQ_DEBUG
184 /* what part(s) of the CPUfreq subsystem are debugged? */
185 static unsigned int debug
;
187 /* is the debug output ratelimit'ed using printk_ratelimit? User can
188 * set or modify this value.
190 static unsigned int debug_ratelimit
= 1;
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
196 static unsigned int disable_ratelimit
= 1;
197 static DEFINE_SPINLOCK(disable_ratelimit_lock
);
199 static void cpufreq_debug_enable_ratelimit(void)
203 spin_lock_irqsave(&disable_ratelimit_lock
, flags
);
204 if (disable_ratelimit
)
206 spin_unlock_irqrestore(&disable_ratelimit_lock
, flags
);
209 static void cpufreq_debug_disable_ratelimit(void)
213 spin_lock_irqsave(&disable_ratelimit_lock
, flags
);
215 spin_unlock_irqrestore(&disable_ratelimit_lock
, flags
);
218 void cpufreq_debug_printk(unsigned int type
, const char *prefix
,
219 const char *fmt
, ...)
228 spin_lock_irqsave(&disable_ratelimit_lock
, flags
);
229 if (!disable_ratelimit
&& debug_ratelimit
230 && !printk_ratelimit()) {
231 spin_unlock_irqrestore(&disable_ratelimit_lock
, flags
);
234 spin_unlock_irqrestore(&disable_ratelimit_lock
, flags
);
236 len
= snprintf(s
, 256, KERN_DEBUG
"%s: ", prefix
);
239 len
+= vsnprintf(&s
[len
], (256 - len
), fmt
, args
);
247 EXPORT_SYMBOL(cpufreq_debug_printk
);
250 module_param(debug
, uint
, 0644);
251 MODULE_PARM_DESC(debug
, "CPUfreq debugging: add 1 to debug core,"
252 " 2 to debug drivers, and 4 to debug governors.");
254 module_param(debug_ratelimit
, uint
, 0644);
255 MODULE_PARM_DESC(debug_ratelimit
, "CPUfreq debugging:"
256 " set to 0 to disable ratelimiting.");
258 #else /* !CONFIG_CPU_FREQ_DEBUG */
260 static inline void cpufreq_debug_enable_ratelimit(void) { return; }
261 static inline void cpufreq_debug_disable_ratelimit(void) { return; }
263 #endif /* CONFIG_CPU_FREQ_DEBUG */
266 /*********************************************************************
267 * EXTERNALLY AFFECTING FREQUENCY CHANGES *
268 *********************************************************************/
271 * adjust_jiffies - adjust the system "loops_per_jiffy"
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
275 * systems as each CPU might be scaled differently. So, use the arch
276 * per-CPU loops_per_jiffy value wherever possible.
279 static unsigned long l_p_j_ref
;
280 static unsigned int l_p_j_ref_freq
;
282 static void adjust_jiffies(unsigned long val
, struct cpufreq_freqs
*ci
)
284 if (ci
->flags
& CPUFREQ_CONST_LOOPS
)
287 if (!l_p_j_ref_freq
) {
288 l_p_j_ref
= loops_per_jiffy
;
289 l_p_j_ref_freq
= ci
->old
;
290 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
);
293 if ((val
== CPUFREQ_PRECHANGE
&& ci
->old
< ci
->new) ||
294 (val
== CPUFREQ_POSTCHANGE
&& ci
->old
> ci
->new) ||
295 (val
== CPUFREQ_RESUMECHANGE
|| val
== CPUFREQ_SUSPENDCHANGE
)) {
296 loops_per_jiffy
= cpufreq_scale(l_p_j_ref
, l_p_j_ref_freq
,
298 dprintk("scaling loops_per_jiffy to %lu "
299 "for frequency %u kHz\n", loops_per_jiffy
, ci
->new);
303 static inline void adjust_jiffies(unsigned long val
, struct cpufreq_freqs
*ci
)
311 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
312 * on frequency transition.
314 * This function calls the transition notifiers and the "adjust_jiffies"
315 * function. It is called twice on all CPU frequency changes that have
318 void cpufreq_notify_transition(struct cpufreq_freqs
*freqs
, unsigned int state
)
320 struct cpufreq_policy
*policy
;
322 BUG_ON(irqs_disabled());
324 freqs
->flags
= cpufreq_driver
->flags
;
325 dprintk("notification %u of frequency transition to %u kHz\n",
328 policy
= cpufreq_cpu_data
[freqs
->cpu
];
331 case CPUFREQ_PRECHANGE
:
332 /* detect if the driver reported a value as "old frequency"
333 * which is not equal to what the cpufreq core thinks is
336 if (!(cpufreq_driver
->flags
& CPUFREQ_CONST_LOOPS
)) {
337 if ((policy
) && (policy
->cpu
== freqs
->cpu
) &&
338 (policy
->cur
) && (policy
->cur
!= freqs
->old
)) {
339 dprintk("Warning: CPU frequency is"
340 " %u, cpufreq assumed %u kHz.\n",
341 freqs
->old
, policy
->cur
);
342 freqs
->old
= policy
->cur
;
345 srcu_notifier_call_chain(&cpufreq_transition_notifier_list
,
346 CPUFREQ_PRECHANGE
, freqs
);
347 adjust_jiffies(CPUFREQ_PRECHANGE
, freqs
);
350 case CPUFREQ_POSTCHANGE
:
351 adjust_jiffies(CPUFREQ_POSTCHANGE
, freqs
);
352 srcu_notifier_call_chain(&cpufreq_transition_notifier_list
,
353 CPUFREQ_POSTCHANGE
, freqs
);
354 if (likely(policy
) && likely(policy
->cpu
== freqs
->cpu
))
355 policy
->cur
= freqs
->new;
359 EXPORT_SYMBOL_GPL(cpufreq_notify_transition
);
363 /*********************************************************************
365 *********************************************************************/
367 static struct cpufreq_governor
*__find_governor(const char *str_governor
)
369 struct cpufreq_governor
*t
;
371 list_for_each_entry(t
, &cpufreq_governor_list
, governor_list
)
372 if (!strnicmp(str_governor
,t
->name
,CPUFREQ_NAME_LEN
))
379 * cpufreq_parse_governor - parse a governor string
381 static int cpufreq_parse_governor (char *str_governor
, unsigned int *policy
,
382 struct cpufreq_governor
**governor
)
389 if (cpufreq_driver
->setpolicy
) {
390 if (!strnicmp(str_governor
, "performance", CPUFREQ_NAME_LEN
)) {
391 *policy
= CPUFREQ_POLICY_PERFORMANCE
;
393 } else if (!strnicmp(str_governor
, "powersave",
395 *policy
= CPUFREQ_POLICY_POWERSAVE
;
398 } else if (cpufreq_driver
->target
) {
399 struct cpufreq_governor
*t
;
401 mutex_lock(&cpufreq_governor_mutex
);
403 t
= __find_governor(str_governor
);
406 char *name
= kasprintf(GFP_KERNEL
, "cpufreq_%s",
412 mutex_unlock(&cpufreq_governor_mutex
);
413 ret
= request_module(name
);
414 mutex_lock(&cpufreq_governor_mutex
);
417 t
= __find_governor(str_governor
);
428 mutex_unlock(&cpufreq_governor_mutex
);
435 /* drivers/base/cpu.c */
436 extern struct sysdev_class cpu_sysdev_class
;
440 * cpufreq_per_cpu_attr_read() / show_##file_name() -
441 * print out cpufreq information
443 * Write out information from cpufreq_driver->policy[cpu]; object must be
447 #define show_one(file_name, object) \
448 static ssize_t show_##file_name \
449 (struct cpufreq_policy * policy, char *buf) \
451 return sprintf (buf, "%u\n", policy->object); \
454 show_one(cpuinfo_min_freq
, cpuinfo
.min_freq
);
455 show_one(cpuinfo_max_freq
, cpuinfo
.max_freq
);
456 show_one(scaling_min_freq
, min
);
457 show_one(scaling_max_freq
, max
);
458 show_one(scaling_cur_freq
, cur
);
460 static int __cpufreq_set_policy(struct cpufreq_policy
*data
,
461 struct cpufreq_policy
*policy
);
464 * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
466 #define store_one(file_name, object) \
467 static ssize_t store_##file_name \
468 (struct cpufreq_policy * policy, const char *buf, size_t count) \
470 unsigned int ret = -EINVAL; \
471 struct cpufreq_policy new_policy; \
473 ret = cpufreq_get_policy(&new_policy, policy->cpu); \
477 ret = sscanf (buf, "%u", &new_policy.object); \
481 ret = __cpufreq_set_policy(policy, &new_policy); \
482 policy->user_policy.object = policy->object; \
484 return ret ? ret : count; \
487 store_one(scaling_min_freq
,min
);
488 store_one(scaling_max_freq
,max
);
491 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
493 static ssize_t
show_cpuinfo_cur_freq (struct cpufreq_policy
* policy
,
496 unsigned int cur_freq
= __cpufreq_get(policy
->cpu
);
498 return sprintf(buf
, "<unknown>");
499 return sprintf(buf
, "%u\n", cur_freq
);
504 * show_scaling_governor - show the current policy for the specified CPU
506 static ssize_t
show_scaling_governor (struct cpufreq_policy
* policy
,
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
);
520 * store_scaling_governor - store policy for the specified CPU
522 static ssize_t
store_scaling_governor (struct cpufreq_policy
* policy
,
523 const char *buf
, size_t count
)
525 unsigned int ret
= -EINVAL
;
526 char str_governor
[16];
527 struct cpufreq_policy new_policy
;
529 ret
= cpufreq_get_policy(&new_policy
, policy
->cpu
);
533 ret
= sscanf (buf
, "%15s", str_governor
);
537 if (cpufreq_parse_governor(str_governor
, &new_policy
.policy
,
538 &new_policy
.governor
))
541 /* Do not use cpufreq_set_policy here or the user_policy.max
542 will be wrongly overridden */
543 ret
= __cpufreq_set_policy(policy
, &new_policy
);
545 policy
->user_policy
.policy
= policy
->policy
;
546 policy
->user_policy
.governor
= policy
->governor
;
555 * show_scaling_driver - show the cpufreq driver currently loaded
557 static ssize_t
show_scaling_driver (struct cpufreq_policy
* policy
, char *buf
)
559 return scnprintf(buf
, CPUFREQ_NAME_LEN
, "%s\n", cpufreq_driver
->name
);
563 * show_scaling_available_governors - show the available CPUfreq governors
565 static ssize_t
show_scaling_available_governors (struct cpufreq_policy
*policy
,
569 struct cpufreq_governor
*t
;
571 if (!cpufreq_driver
->target
) {
572 i
+= sprintf(buf
, "performance powersave");
576 list_for_each_entry(t
, &cpufreq_governor_list
, governor_list
) {
577 if (i
>= (ssize_t
) ((PAGE_SIZE
/ sizeof(char)) - (CPUFREQ_NAME_LEN
+ 2)))
579 i
+= scnprintf(&buf
[i
], CPUFREQ_NAME_LEN
, "%s ", t
->name
);
582 i
+= sprintf(&buf
[i
], "\n");
586 * show_affected_cpus - show the CPUs affected by each transition
588 static ssize_t
show_affected_cpus (struct cpufreq_policy
* policy
, char *buf
)
593 for_each_cpu_mask(cpu
, policy
->cpus
) {
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))
600 i
+= sprintf(&buf
[i
], "\n");
604 static ssize_t
store_scaling_setspeed(struct cpufreq_policy
*policy
,
605 const char *buf
, size_t count
)
607 unsigned int freq
= 0;
610 if (!policy
->governor
->store_setspeed
)
613 ret
= sscanf(buf
, "%u", &freq
);
617 policy
->governor
->store_setspeed(policy
, freq
);
622 static ssize_t
show_scaling_setspeed(struct cpufreq_policy
*policy
, char *buf
)
624 if (!policy
->governor
->show_setspeed
)
625 return sprintf(buf
, "<unsupported>\n");
627 return policy
->governor
->show_setspeed(policy
, buf
);
630 #define define_one_ro(_name) \
631 static struct freq_attr _name = \
632 __ATTR(_name, 0444, show_##_name, NULL)
634 #define define_one_ro0400(_name) \
635 static struct freq_attr _name = \
636 __ATTR(_name, 0400, show_##_name, NULL)
638 #define define_one_rw(_name) \
639 static struct freq_attr _name = \
640 __ATTR(_name, 0644, show_##_name, store_##_name)
642 define_one_ro0400(cpuinfo_cur_freq
);
643 define_one_ro(cpuinfo_min_freq
);
644 define_one_ro(cpuinfo_max_freq
);
645 define_one_ro(scaling_available_governors
);
646 define_one_ro(scaling_driver
);
647 define_one_ro(scaling_cur_freq
);
648 define_one_ro(affected_cpus
);
649 define_one_rw(scaling_min_freq
);
650 define_one_rw(scaling_max_freq
);
651 define_one_rw(scaling_governor
);
652 define_one_rw(scaling_setspeed
);
654 static struct attribute
* default_attrs
[] = {
655 &cpuinfo_min_freq
.attr
,
656 &cpuinfo_max_freq
.attr
,
657 &scaling_min_freq
.attr
,
658 &scaling_max_freq
.attr
,
660 &scaling_governor
.attr
,
661 &scaling_driver
.attr
,
662 &scaling_available_governors
.attr
,
663 &scaling_setspeed
.attr
,
667 #define to_policy(k) container_of(k,struct cpufreq_policy,kobj)
668 #define to_attr(a) container_of(a,struct freq_attr,attr)
670 static ssize_t
show(struct kobject
* kobj
, struct attribute
* attr
,char * buf
)
672 struct cpufreq_policy
* policy
= to_policy(kobj
);
673 struct freq_attr
* fattr
= to_attr(attr
);
674 ssize_t ret
= -EINVAL
;
675 policy
= cpufreq_cpu_get(policy
->cpu
);
679 if (lock_policy_rwsem_read(policy
->cpu
) < 0)
683 ret
= fattr
->show(policy
, buf
);
687 unlock_policy_rwsem_read(policy
->cpu
);
689 cpufreq_cpu_put(policy
);
694 static ssize_t
store(struct kobject
* kobj
, struct attribute
* attr
,
695 const char * buf
, size_t count
)
697 struct cpufreq_policy
* policy
= to_policy(kobj
);
698 struct freq_attr
* fattr
= to_attr(attr
);
699 ssize_t ret
= -EINVAL
;
700 policy
= cpufreq_cpu_get(policy
->cpu
);
704 if (lock_policy_rwsem_write(policy
->cpu
) < 0)
708 ret
= fattr
->store(policy
, buf
, count
);
712 unlock_policy_rwsem_write(policy
->cpu
);
714 cpufreq_cpu_put(policy
);
719 static void cpufreq_sysfs_release(struct kobject
* kobj
)
721 struct cpufreq_policy
* policy
= to_policy(kobj
);
722 dprintk("last reference is dropped\n");
723 complete(&policy
->kobj_unregister
);
726 static struct sysfs_ops sysfs_ops
= {
731 static struct kobj_type ktype_cpufreq
= {
732 .sysfs_ops
= &sysfs_ops
,
733 .default_attrs
= default_attrs
,
734 .release
= cpufreq_sysfs_release
,
739 * cpufreq_add_dev - add a CPU device
741 * Adds the cpufreq interface for a CPU device.
743 static int cpufreq_add_dev (struct sys_device
* sys_dev
)
745 unsigned int cpu
= sys_dev
->id
;
747 struct cpufreq_policy new_policy
;
748 struct cpufreq_policy
*policy
;
749 struct freq_attr
**drv_attr
;
750 struct sys_device
*cpu_sys_dev
;
754 struct cpufreq_policy
*managed_policy
;
757 if (cpu_is_offline(cpu
))
760 cpufreq_debug_disable_ratelimit();
761 dprintk("adding CPU %u\n", cpu
);
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
)) {
768 cpufreq_cpu_put(policy
);
769 cpufreq_debug_enable_ratelimit();
774 if (!try_module_get(cpufreq_driver
->owner
)) {
779 policy
= kzalloc(sizeof(struct cpufreq_policy
), GFP_KERNEL
);
786 policy
->cpus
= cpumask_of_cpu(cpu
);
788 /* Initially set CPU itself as the policy_cpu */
789 per_cpu(policy_cpu
, cpu
) = cpu
;
790 lock_policy_rwsem_write(cpu
);
792 init_completion(&policy
->kobj_unregister
);
793 INIT_WORK(&policy
->update
, handle_update
);
795 /* Set governor before ->init, so that driver could check it */
796 policy
->governor
= CPUFREQ_DEFAULT_GOVERNOR
;
797 /* call driver. From then on the cpufreq must be able
798 * to accept all calls to ->verify and ->setpolicy for this CPU
800 ret
= cpufreq_driver
->init(policy
);
802 dprintk("initialization failed\n");
803 unlock_policy_rwsem_write(cpu
);
806 policy
->user_policy
.min
= policy
->cpuinfo
.min_freq
;
807 policy
->user_policy
.max
= policy
->cpuinfo
.max_freq
;
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
);
819 for_each_cpu_mask(j
, policy
->cpus
) {
823 /* check for existing affected CPUs. They may not be aware
824 * of it due to CPU Hotplug.
826 managed_policy
= cpufreq_cpu_get(j
);
827 if (unlikely(managed_policy
)) {
829 /* Set proper policy_cpu */
830 unlock_policy_rwsem_write(cpu
);
831 per_cpu(policy_cpu
, cpu
) = managed_policy
->cpu
;
833 if (lock_policy_rwsem_write(cpu
) < 0)
834 goto err_out_driver_exit
;
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
);
841 dprintk("CPU already managed, adding link\n");
842 ret
= sysfs_create_link(&sys_dev
->kobj
,
843 &managed_policy
->kobj
,
846 unlock_policy_rwsem_write(cpu
);
847 goto err_out_driver_exit
;
850 cpufreq_debug_enable_ratelimit();
852 unlock_policy_rwsem_write(cpu
);
853 goto err_out_driver_exit
; /* call driver->exit() */
857 memcpy(&new_policy
, policy
, sizeof(struct cpufreq_policy
));
859 /* prepare interface data */
860 ret
= kobject_init_and_add(&policy
->kobj
, &ktype_cpufreq
, &sys_dev
->kobj
,
863 unlock_policy_rwsem_write(cpu
);
864 goto err_out_driver_exit
;
866 /* set up files for this cpu device */
867 drv_attr
= cpufreq_driver
->attr
;
868 while ((drv_attr
) && (*drv_attr
)) {
869 ret
= sysfs_create_file(&policy
->kobj
, &((*drv_attr
)->attr
));
871 unlock_policy_rwsem_write(cpu
);
872 goto err_out_driver_exit
;
876 if (cpufreq_driver
->get
){
877 ret
= sysfs_create_file(&policy
->kobj
, &cpuinfo_cur_freq
.attr
);
879 unlock_policy_rwsem_write(cpu
);
880 goto err_out_driver_exit
;
883 if (cpufreq_driver
->target
){
884 ret
= sysfs_create_file(&policy
->kobj
, &scaling_cur_freq
.attr
);
886 unlock_policy_rwsem_write(cpu
);
887 goto err_out_driver_exit
;
891 spin_lock_irqsave(&cpufreq_driver_lock
, flags
);
892 for_each_cpu_mask(j
, policy
->cpus
) {
893 cpufreq_cpu_data
[j
] = policy
;
894 per_cpu(policy_cpu
, j
) = policy
->cpu
;
896 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
898 /* symlink affected CPUs */
899 for_each_cpu_mask(j
, policy
->cpus
) {
905 dprintk("CPU %u already managed, adding link\n", j
);
906 cpufreq_cpu_get(cpu
);
907 cpu_sys_dev
= get_cpu_sysdev(j
);
908 ret
= sysfs_create_link(&cpu_sys_dev
->kobj
, &policy
->kobj
,
911 unlock_policy_rwsem_write(cpu
);
912 goto err_out_unregister
;
916 policy
->governor
= NULL
; /* to assure that the starting sequence is
917 * run in cpufreq_set_policy */
919 /* set default policy */
920 ret
= __cpufreq_set_policy(policy
, &new_policy
);
921 policy
->user_policy
.policy
= policy
->policy
;
922 policy
->user_policy
.governor
= policy
->governor
;
924 unlock_policy_rwsem_write(cpu
);
927 dprintk("setting policy failed\n");
928 goto err_out_unregister
;
931 kobject_uevent(&policy
->kobj
, KOBJ_ADD
);
932 module_put(cpufreq_driver
->owner
);
933 dprintk("initialization complete\n");
934 cpufreq_debug_enable_ratelimit();
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
);
945 kobject_put(&policy
->kobj
);
946 wait_for_completion(&policy
->kobj_unregister
);
949 if (cpufreq_driver
->exit
)
950 cpufreq_driver
->exit(policy
);
956 module_put(cpufreq_driver
->owner
);
958 cpufreq_debug_enable_ratelimit();
964 * __cpufreq_remove_dev - remove a CPU device
966 * Removes the cpufreq interface for a CPU device.
967 * Caller should already have policy_rwsem in write mode for this CPU.
968 * This routine frees the rwsem before returning.
970 static int __cpufreq_remove_dev (struct sys_device
* sys_dev
)
972 unsigned int cpu
= sys_dev
->id
;
974 struct cpufreq_policy
*data
;
976 struct sys_device
*cpu_sys_dev
;
980 cpufreq_debug_disable_ratelimit();
981 dprintk("unregistering CPU %u\n", cpu
);
983 spin_lock_irqsave(&cpufreq_driver_lock
, flags
);
984 data
= cpufreq_cpu_data
[cpu
];
987 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
988 cpufreq_debug_enable_ratelimit();
989 unlock_policy_rwsem_write(cpu
);
992 cpufreq_cpu_data
[cpu
] = NULL
;
996 /* if this isn't the CPU which is the parent of the kobj, we
997 * only need to unlink, put and exit
999 if (unlikely(cpu
!= data
->cpu
)) {
1000 dprintk("removing link\n");
1001 cpu_clear(cpu
, data
->cpus
);
1002 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
1003 sysfs_remove_link(&sys_dev
->kobj
, "cpufreq");
1004 cpufreq_cpu_put(data
);
1005 cpufreq_debug_enable_ratelimit();
1006 unlock_policy_rwsem_write(cpu
);
1013 #ifdef CONFIG_HOTPLUG_CPU
1014 cpufreq_cpu_governor
[cpu
] = data
->governor
;
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
1022 if (unlikely(cpus_weight(data
->cpus
) > 1)) {
1023 for_each_cpu_mask(j
, data
->cpus
) {
1026 cpufreq_cpu_data
[j
] = NULL
;
1030 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
1032 if (unlikely(cpus_weight(data
->cpus
) > 1)) {
1033 for_each_cpu_mask(j
, data
->cpus
) {
1036 dprintk("removing link for cpu %u\n", j
);
1037 #ifdef CONFIG_HOTPLUG_CPU
1038 cpufreq_cpu_governor
[j
] = data
->governor
;
1040 cpu_sys_dev
= get_cpu_sysdev(j
);
1041 sysfs_remove_link(&cpu_sys_dev
->kobj
, "cpufreq");
1042 cpufreq_cpu_put(data
);
1046 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
1049 if (cpufreq_driver
->target
)
1050 __cpufreq_governor(data
, CPUFREQ_GOV_STOP
);
1052 unlock_policy_rwsem_write(cpu
);
1054 kobject_put(&data
->kobj
);
1056 /* we need to make sure that the underlying kobj is actually
1057 * not referenced anymore by anybody before we proceed with
1060 dprintk("waiting for dropping of refcount\n");
1061 wait_for_completion(&data
->kobj_unregister
);
1062 dprintk("wait complete\n");
1064 if (cpufreq_driver
->exit
)
1065 cpufreq_driver
->exit(data
);
1069 cpufreq_debug_enable_ratelimit();
1074 static int cpufreq_remove_dev (struct sys_device
* sys_dev
)
1076 unsigned int cpu
= sys_dev
->id
;
1079 if (cpu_is_offline(cpu
))
1082 if (unlikely(lock_policy_rwsem_write(cpu
)))
1085 retval
= __cpufreq_remove_dev(sys_dev
);
1090 static void handle_update(struct work_struct
*work
)
1092 struct cpufreq_policy
*policy
=
1093 container_of(work
, struct cpufreq_policy
, update
);
1094 unsigned int cpu
= policy
->cpu
;
1095 dprintk("handle_update for cpu %u called\n", cpu
);
1096 cpufreq_update_policy(cpu
);
1100 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
1102 * @old_freq: CPU frequency the kernel thinks the CPU runs at
1103 * @new_freq: CPU frequency the CPU actually runs at
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()).
1108 static void cpufreq_out_of_sync(unsigned int cpu
, unsigned int old_freq
,
1109 unsigned int new_freq
)
1111 struct cpufreq_freqs freqs
;
1113 dprintk("Warning: CPU frequency out of sync: cpufreq and timing "
1114 "core thinks of %u, is %u kHz.\n", old_freq
, new_freq
);
1117 freqs
.old
= old_freq
;
1118 freqs
.new = new_freq
;
1119 cpufreq_notify_transition(&freqs
, CPUFREQ_PRECHANGE
);
1120 cpufreq_notify_transition(&freqs
, CPUFREQ_POSTCHANGE
);
1125 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
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.
1131 unsigned int cpufreq_quick_get(unsigned int cpu
)
1133 struct cpufreq_policy
*policy
= cpufreq_cpu_get(cpu
);
1134 unsigned int ret_freq
= 0;
1137 ret_freq
= policy
->cur
;
1138 cpufreq_cpu_put(policy
);
1143 EXPORT_SYMBOL(cpufreq_quick_get
);
1146 static unsigned int __cpufreq_get(unsigned int cpu
)
1148 struct cpufreq_policy
*policy
= cpufreq_cpu_data
[cpu
];
1149 unsigned int ret_freq
= 0;
1151 if (!cpufreq_driver
->get
)
1154 ret_freq
= cpufreq_driver
->get(cpu
);
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
);
1162 schedule_work(&policy
->update
);
1170 * cpufreq_get - get the current CPU frequency (in kHz)
1173 * Get the CPU current (static) CPU frequency
1175 unsigned int cpufreq_get(unsigned int cpu
)
1177 unsigned int ret_freq
= 0;
1178 struct cpufreq_policy
*policy
= cpufreq_cpu_get(cpu
);
1183 if (unlikely(lock_policy_rwsem_read(cpu
)))
1186 ret_freq
= __cpufreq_get(cpu
);
1188 unlock_policy_rwsem_read(cpu
);
1191 cpufreq_cpu_put(policy
);
1195 EXPORT_SYMBOL(cpufreq_get
);
1199 * cpufreq_suspend - let the low level driver prepare for suspend
1202 static int cpufreq_suspend(struct sys_device
* sysdev
, pm_message_t pmsg
)
1204 int cpu
= sysdev
->id
;
1206 unsigned int cur_freq
= 0;
1207 struct cpufreq_policy
*cpu_policy
;
1209 dprintk("suspending cpu %u\n", cpu
);
1211 if (!cpu_online(cpu
))
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.
1219 cpu_policy
= cpufreq_cpu_get(cpu
);
1223 /* only handle each CPU group once */
1224 if (unlikely(cpu_policy
->cpu
!= cpu
))
1227 if (cpufreq_driver
->suspend
) {
1228 ret
= cpufreq_driver
->suspend(cpu_policy
, pmsg
);
1230 printk(KERN_ERR
"cpufreq: suspend failed in ->suspend "
1231 "step on CPU %u\n", cpu_policy
->cpu
);
1236 if (cpufreq_driver
->flags
& CPUFREQ_CONST_LOOPS
)
1239 if (cpufreq_driver
->get
)
1240 cur_freq
= cpufreq_driver
->get(cpu_policy
->cpu
);
1242 if (!cur_freq
|| !cpu_policy
->cur
) {
1243 printk(KERN_ERR
"cpufreq: suspend failed to assert current "
1244 "frequency is what timing core thinks it is.\n");
1248 if (unlikely(cur_freq
!= cpu_policy
->cur
)) {
1249 struct cpufreq_freqs freqs
;
1251 if (!(cpufreq_driver
->flags
& CPUFREQ_PM_NO_WARN
))
1252 dprintk("Warning: CPU frequency is %u, "
1253 "cpufreq assumed %u kHz.\n",
1254 cur_freq
, cpu_policy
->cur
);
1257 freqs
.old
= cpu_policy
->cur
;
1258 freqs
.new = cur_freq
;
1260 srcu_notifier_call_chain(&cpufreq_transition_notifier_list
,
1261 CPUFREQ_SUSPENDCHANGE
, &freqs
);
1262 adjust_jiffies(CPUFREQ_SUSPENDCHANGE
, &freqs
);
1264 cpu_policy
->cur
= cur_freq
;
1268 cpufreq_cpu_put(cpu_policy
);
1273 * cpufreq_resume - restore proper CPU frequency handling after resume
1275 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
1276 * 2.) if ->target and !CPUFREQ_CONST_LOOPS: verify we're in sync
1277 * 3.) schedule call cpufreq_update_policy() ASAP as interrupts are
1280 static int cpufreq_resume(struct sys_device
* sysdev
)
1282 int cpu
= sysdev
->id
;
1284 struct cpufreq_policy
*cpu_policy
;
1286 dprintk("resuming cpu %u\n", cpu
);
1288 if (!cpu_online(cpu
))
1291 /* we may be lax here as interrupts are off. Nonetheless
1292 * we need to grab the correct cpu policy, as to check
1293 * whether we really run on this CPU.
1296 cpu_policy
= cpufreq_cpu_get(cpu
);
1300 /* only handle each CPU group once */
1301 if (unlikely(cpu_policy
->cpu
!= cpu
))
1304 if (cpufreq_driver
->resume
) {
1305 ret
= cpufreq_driver
->resume(cpu_policy
);
1307 printk(KERN_ERR
"cpufreq: resume failed in ->resume "
1308 "step on CPU %u\n", cpu_policy
->cpu
);
1313 if (!(cpufreq_driver
->flags
& CPUFREQ_CONST_LOOPS
)) {
1314 unsigned int cur_freq
= 0;
1316 if (cpufreq_driver
->get
)
1317 cur_freq
= cpufreq_driver
->get(cpu_policy
->cpu
);
1319 if (!cur_freq
|| !cpu_policy
->cur
) {
1320 printk(KERN_ERR
"cpufreq: resume failed to assert "
1321 "current frequency is what timing core "
1326 if (unlikely(cur_freq
!= cpu_policy
->cur
)) {
1327 struct cpufreq_freqs freqs
;
1329 if (!(cpufreq_driver
->flags
& CPUFREQ_PM_NO_WARN
))
1330 dprintk("Warning: CPU frequency "
1331 "is %u, cpufreq assumed %u kHz.\n",
1332 cur_freq
, cpu_policy
->cur
);
1335 freqs
.old
= cpu_policy
->cur
;
1336 freqs
.new = cur_freq
;
1338 srcu_notifier_call_chain(
1339 &cpufreq_transition_notifier_list
,
1340 CPUFREQ_RESUMECHANGE
, &freqs
);
1341 adjust_jiffies(CPUFREQ_RESUMECHANGE
, &freqs
);
1343 cpu_policy
->cur
= cur_freq
;
1348 schedule_work(&cpu_policy
->update
);
1350 cpufreq_cpu_put(cpu_policy
);
1354 static struct sysdev_driver cpufreq_sysdev_driver
= {
1355 .add
= cpufreq_add_dev
,
1356 .remove
= cpufreq_remove_dev
,
1357 .suspend
= cpufreq_suspend
,
1358 .resume
= cpufreq_resume
,
1362 /*********************************************************************
1363 * NOTIFIER LISTS INTERFACE *
1364 *********************************************************************/
1367 * cpufreq_register_notifier - register a driver with cpufreq
1368 * @nb: notifier function to register
1369 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1371 * Add a driver to one of two lists: either a list of drivers that
1372 * are notified about clock rate changes (once before and once after
1373 * the transition), or a list of drivers that are notified about
1374 * changes in cpufreq policy.
1376 * This function may sleep, and has the same return conditions as
1377 * blocking_notifier_chain_register.
1379 int cpufreq_register_notifier(struct notifier_block
*nb
, unsigned int list
)
1384 case CPUFREQ_TRANSITION_NOTIFIER
:
1385 ret
= srcu_notifier_chain_register(
1386 &cpufreq_transition_notifier_list
, nb
);
1388 case CPUFREQ_POLICY_NOTIFIER
:
1389 ret
= blocking_notifier_chain_register(
1390 &cpufreq_policy_notifier_list
, nb
);
1398 EXPORT_SYMBOL(cpufreq_register_notifier
);
1402 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1403 * @nb: notifier block to be unregistered
1404 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1406 * Remove a driver from the CPU frequency notifier list.
1408 * This function may sleep, and has the same return conditions as
1409 * blocking_notifier_chain_unregister.
1411 int cpufreq_unregister_notifier(struct notifier_block
*nb
, unsigned int list
)
1416 case CPUFREQ_TRANSITION_NOTIFIER
:
1417 ret
= srcu_notifier_chain_unregister(
1418 &cpufreq_transition_notifier_list
, nb
);
1420 case CPUFREQ_POLICY_NOTIFIER
:
1421 ret
= blocking_notifier_chain_unregister(
1422 &cpufreq_policy_notifier_list
, nb
);
1430 EXPORT_SYMBOL(cpufreq_unregister_notifier
);
1433 /*********************************************************************
1435 *********************************************************************/
1438 int __cpufreq_driver_target(struct cpufreq_policy
*policy
,
1439 unsigned int target_freq
,
1440 unsigned int relation
)
1442 int retval
= -EINVAL
;
1444 dprintk("target for CPU %u: %u kHz, relation %u\n", policy
->cpu
,
1445 target_freq
, relation
);
1446 if (cpu_online(policy
->cpu
) && cpufreq_driver
->target
)
1447 retval
= cpufreq_driver
->target(policy
, target_freq
, relation
);
1451 EXPORT_SYMBOL_GPL(__cpufreq_driver_target
);
1453 int cpufreq_driver_target(struct cpufreq_policy
*policy
,
1454 unsigned int target_freq
,
1455 unsigned int relation
)
1459 policy
= cpufreq_cpu_get(policy
->cpu
);
1463 if (unlikely(lock_policy_rwsem_write(policy
->cpu
)))
1466 ret
= __cpufreq_driver_target(policy
, target_freq
, relation
);
1468 unlock_policy_rwsem_write(policy
->cpu
);
1470 cpufreq_cpu_put(policy
);
1473 EXPORT_SYMBOL_GPL(cpufreq_driver_target
);
1475 int __cpufreq_driver_getavg(struct cpufreq_policy
*policy
)
1479 policy
= cpufreq_cpu_get(policy
->cpu
);
1483 if (cpu_online(policy
->cpu
) && cpufreq_driver
->getavg
)
1484 ret
= cpufreq_driver
->getavg(policy
->cpu
);
1486 cpufreq_cpu_put(policy
);
1489 EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg
);
1492 * when "event" is CPUFREQ_GOV_LIMITS
1495 static int __cpufreq_governor(struct cpufreq_policy
*policy
,
1500 /* Only must be defined when default governor is known to have latency
1501 restrictions, like e.g. conservative or ondemand.
1502 That this is the case is already ensured in Kconfig
1504 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1505 struct cpufreq_governor
*gov
= &cpufreq_gov_performance
;
1507 struct cpufreq_governor
*gov
= NULL
;
1510 if (policy
->governor
->max_transition_latency
&&
1511 policy
->cpuinfo
.transition_latency
>
1512 policy
->governor
->max_transition_latency
) {
1516 printk(KERN_WARNING
"%s governor failed, too long"
1517 " transition latency of HW, fallback"
1518 " to %s governor\n",
1519 policy
->governor
->name
,
1521 policy
->governor
= gov
;
1525 if (!try_module_get(policy
->governor
->owner
))
1528 dprintk("__cpufreq_governor for CPU %u, event %u\n",
1529 policy
->cpu
, event
);
1530 ret
= policy
->governor
->governor(policy
, event
);
1532 /* we keep one module reference alive for
1533 each CPU governed by this CPU */
1534 if ((event
!= CPUFREQ_GOV_START
) || ret
)
1535 module_put(policy
->governor
->owner
);
1536 if ((event
== CPUFREQ_GOV_STOP
) && !ret
)
1537 module_put(policy
->governor
->owner
);
1543 int cpufreq_register_governor(struct cpufreq_governor
*governor
)
1550 mutex_lock(&cpufreq_governor_mutex
);
1553 if (__find_governor(governor
->name
) == NULL
) {
1555 list_add(&governor
->governor_list
, &cpufreq_governor_list
);
1558 mutex_unlock(&cpufreq_governor_mutex
);
1561 EXPORT_SYMBOL_GPL(cpufreq_register_governor
);
1564 void cpufreq_unregister_governor(struct cpufreq_governor
*governor
)
1569 mutex_lock(&cpufreq_governor_mutex
);
1570 list_del(&governor
->governor_list
);
1571 mutex_unlock(&cpufreq_governor_mutex
);
1574 EXPORT_SYMBOL_GPL(cpufreq_unregister_governor
);
1578 /*********************************************************************
1579 * POLICY INTERFACE *
1580 *********************************************************************/
1583 * cpufreq_get_policy - get the current cpufreq_policy
1584 * @policy: struct cpufreq_policy into which the current cpufreq_policy is written
1586 * Reads the current cpufreq policy.
1588 int cpufreq_get_policy(struct cpufreq_policy
*policy
, unsigned int cpu
)
1590 struct cpufreq_policy
*cpu_policy
;
1594 cpu_policy
= cpufreq_cpu_get(cpu
);
1598 memcpy(policy
, cpu_policy
, sizeof(struct cpufreq_policy
));
1600 cpufreq_cpu_put(cpu_policy
);
1603 EXPORT_SYMBOL(cpufreq_get_policy
);
1607 * data : current policy.
1608 * policy : policy to be set.
1610 static int __cpufreq_set_policy(struct cpufreq_policy
*data
,
1611 struct cpufreq_policy
*policy
)
1615 cpufreq_debug_disable_ratelimit();
1616 dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy
->cpu
,
1617 policy
->min
, policy
->max
);
1619 memcpy(&policy
->cpuinfo
, &data
->cpuinfo
,
1620 sizeof(struct cpufreq_cpuinfo
));
1622 if (policy
->min
> data
->max
|| policy
->max
< data
->min
) {
1627 /* verify the cpu speed can be set within this limit */
1628 ret
= cpufreq_driver
->verify(policy
);
1632 /* adjust if necessary - all reasons */
1633 blocking_notifier_call_chain(&cpufreq_policy_notifier_list
,
1634 CPUFREQ_ADJUST
, policy
);
1636 /* adjust if necessary - hardware incompatibility*/
1637 blocking_notifier_call_chain(&cpufreq_policy_notifier_list
,
1638 CPUFREQ_INCOMPATIBLE
, policy
);
1640 /* verify the cpu speed can be set within this limit,
1641 which might be different to the first one */
1642 ret
= cpufreq_driver
->verify(policy
);
1646 /* notification of the new policy */
1647 blocking_notifier_call_chain(&cpufreq_policy_notifier_list
,
1648 CPUFREQ_NOTIFY
, policy
);
1650 data
->min
= policy
->min
;
1651 data
->max
= policy
->max
;
1653 dprintk("new min and max freqs are %u - %u kHz\n",
1654 data
->min
, data
->max
);
1656 if (cpufreq_driver
->setpolicy
) {
1657 data
->policy
= policy
->policy
;
1658 dprintk("setting range\n");
1659 ret
= cpufreq_driver
->setpolicy(policy
);
1661 if (policy
->governor
!= data
->governor
) {
1662 /* save old, working values */
1663 struct cpufreq_governor
*old_gov
= data
->governor
;
1665 dprintk("governor switch\n");
1667 /* end old governor */
1669 __cpufreq_governor(data
, CPUFREQ_GOV_STOP
);
1671 /* start new governor */
1672 data
->governor
= policy
->governor
;
1673 if (__cpufreq_governor(data
, CPUFREQ_GOV_START
)) {
1674 /* new governor failed, so re-start old one */
1675 dprintk("starting governor %s failed\n",
1676 data
->governor
->name
);
1678 data
->governor
= old_gov
;
1679 __cpufreq_governor(data
,
1685 /* might be a policy change, too, so fall through */
1687 dprintk("governor: change or update limits\n");
1688 __cpufreq_governor(data
, CPUFREQ_GOV_LIMITS
);
1692 cpufreq_debug_enable_ratelimit();
1697 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1698 * @cpu: CPU which shall be re-evaluated
1700 * Usefull for policy notifiers which have different necessities
1701 * at different times.
1703 int cpufreq_update_policy(unsigned int cpu
)
1705 struct cpufreq_policy
*data
= cpufreq_cpu_get(cpu
);
1706 struct cpufreq_policy policy
;
1712 if (unlikely(lock_policy_rwsem_write(cpu
)))
1715 dprintk("updating policy for CPU %u\n", cpu
);
1716 memcpy(&policy
, data
, sizeof(struct cpufreq_policy
));
1717 policy
.min
= data
->user_policy
.min
;
1718 policy
.max
= data
->user_policy
.max
;
1719 policy
.policy
= data
->user_policy
.policy
;
1720 policy
.governor
= data
->user_policy
.governor
;
1722 /* BIOS might change freq behind our back
1723 -> ask driver for current freq and notify governors about a change */
1724 if (cpufreq_driver
->get
) {
1725 policy
.cur
= cpufreq_driver
->get(cpu
);
1727 dprintk("Driver did not initialize current freq");
1728 data
->cur
= policy
.cur
;
1730 if (data
->cur
!= policy
.cur
)
1731 cpufreq_out_of_sync(cpu
, data
->cur
,
1736 ret
= __cpufreq_set_policy(data
, &policy
);
1738 unlock_policy_rwsem_write(cpu
);
1740 cpufreq_cpu_put(data
);
1743 EXPORT_SYMBOL(cpufreq_update_policy
);
1745 static int __cpuinit
cpufreq_cpu_callback(struct notifier_block
*nfb
,
1746 unsigned long action
, void *hcpu
)
1748 unsigned int cpu
= (unsigned long)hcpu
;
1749 struct sys_device
*sys_dev
;
1751 sys_dev
= get_cpu_sysdev(cpu
);
1755 case CPU_ONLINE_FROZEN
:
1756 cpufreq_add_dev(sys_dev
);
1758 case CPU_DOWN_PREPARE
:
1759 case CPU_DOWN_PREPARE_FROZEN
:
1760 if (unlikely(lock_policy_rwsem_write(cpu
)))
1763 __cpufreq_remove_dev(sys_dev
);
1765 case CPU_DOWN_FAILED
:
1766 case CPU_DOWN_FAILED_FROZEN
:
1767 cpufreq_add_dev(sys_dev
);
1774 static struct notifier_block __refdata cpufreq_cpu_notifier
=
1776 .notifier_call
= cpufreq_cpu_callback
,
1779 /*********************************************************************
1780 * REGISTER / UNREGISTER CPUFREQ DRIVER *
1781 *********************************************************************/
1784 * cpufreq_register_driver - register a CPU Frequency driver
1785 * @driver_data: A struct cpufreq_driver containing the values#
1786 * submitted by the CPU Frequency driver.
1788 * Registers a CPU Frequency driver to this core code. This code
1789 * returns zero on success, -EBUSY when another driver got here first
1790 * (and isn't unregistered in the meantime).
1793 int cpufreq_register_driver(struct cpufreq_driver
*driver_data
)
1795 unsigned long flags
;
1798 if (!driver_data
|| !driver_data
->verify
|| !driver_data
->init
||
1799 ((!driver_data
->setpolicy
) && (!driver_data
->target
)))
1802 dprintk("trying to register driver %s\n", driver_data
->name
);
1804 if (driver_data
->setpolicy
)
1805 driver_data
->flags
|= CPUFREQ_CONST_LOOPS
;
1807 spin_lock_irqsave(&cpufreq_driver_lock
, flags
);
1808 if (cpufreq_driver
) {
1809 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
1812 cpufreq_driver
= driver_data
;
1813 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
1815 ret
= sysdev_driver_register(&cpu_sysdev_class
,&cpufreq_sysdev_driver
);
1817 if ((!ret
) && !(cpufreq_driver
->flags
& CPUFREQ_STICKY
)) {
1821 /* check for at least one working CPU */
1822 for (i
=0; i
<NR_CPUS
; i
++)
1823 if (cpufreq_cpu_data
[i
])
1826 /* if all ->init() calls failed, unregister */
1828 dprintk("no CPU initialized for driver %s\n",
1830 sysdev_driver_unregister(&cpu_sysdev_class
,
1831 &cpufreq_sysdev_driver
);
1833 spin_lock_irqsave(&cpufreq_driver_lock
, flags
);
1834 cpufreq_driver
= NULL
;
1835 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
1840 register_hotcpu_notifier(&cpufreq_cpu_notifier
);
1841 dprintk("driver %s up and running\n", driver_data
->name
);
1842 cpufreq_debug_enable_ratelimit();
1847 EXPORT_SYMBOL_GPL(cpufreq_register_driver
);
1851 * cpufreq_unregister_driver - unregister the current CPUFreq driver
1853 * Unregister the current CPUFreq driver. Only call this if you have
1854 * the right to do so, i.e. if you have succeeded in initialising before!
1855 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
1856 * currently not initialised.
1858 int cpufreq_unregister_driver(struct cpufreq_driver
*driver
)
1860 unsigned long flags
;
1862 cpufreq_debug_disable_ratelimit();
1864 if (!cpufreq_driver
|| (driver
!= cpufreq_driver
)) {
1865 cpufreq_debug_enable_ratelimit();
1869 dprintk("unregistering driver %s\n", driver
->name
);
1871 sysdev_driver_unregister(&cpu_sysdev_class
, &cpufreq_sysdev_driver
);
1872 unregister_hotcpu_notifier(&cpufreq_cpu_notifier
);
1874 spin_lock_irqsave(&cpufreq_driver_lock
, flags
);
1875 cpufreq_driver
= NULL
;
1876 spin_unlock_irqrestore(&cpufreq_driver_lock
, flags
);
1880 EXPORT_SYMBOL_GPL(cpufreq_unregister_driver
);
1882 static int __init
cpufreq_core_init(void)
1886 for_each_possible_cpu(cpu
) {
1887 per_cpu(policy_cpu
, cpu
) = -1;
1888 init_rwsem(&per_cpu(cpu_policy_rwsem
, cpu
));
1893 core_initcall(cpufreq_core_init
);