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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <asm/cputime.h>
21 #include <linux/kernel.h>
22 #include <linux/kernel_stat.h>
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/notifier.h>
26 #include <linux/cpufreq.h>
27 #include <linux/delay.h>
28 #include <linux/interrupt.h>
29 #include <linux/spinlock.h>
30 #include <linux/tick.h>
31 #include <linux/device.h>
32 #include <linux/slab.h>
33 #include <linux/cpu.h>
34 #include <linux/completion.h>
35 #include <linux/mutex.h>
36 #include <linux/syscore_ops.h>
38 #include <trace/events/power.h>
41 * The "cpufreq driver" - the arch- or hardware-dependent low
42 * level driver of CPUFreq support, and its spinlock. This lock
43 * also protects the cpufreq_cpu_data array.
45 static struct cpufreq_driver *cpufreq_driver;
46 static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
47 #ifdef CONFIG_HOTPLUG_CPU
48 /* This one keeps track of the previously set governor of a removed CPU */
49 static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], cpufreq_cpu_governor);
51 static DEFINE_RWLOCK(cpufreq_driver_lock);
54 * cpu_policy_rwsem is a per CPU reader-writer semaphore designed to cure
55 * all cpufreq/hotplug/workqueue/etc related lock issues.
57 * The rules for this semaphore:
58 * - Any routine that wants to read from the policy structure will
59 * do a down_read on this semaphore.
60 * - Any routine that will write to the policy structure and/or may take away
61 * the policy altogether (eg. CPU hotplug), will hold this lock in write
62 * mode before doing so.
65 * - Governor routines that can be called in cpufreq hotplug path should not
66 * take this sem as top level hotplug notifier handler takes this.
67 * - Lock should not be held across
68 * __cpufreq_governor(data, CPUFREQ_GOV_STOP);
70 static DEFINE_PER_CPU(int, cpufreq_policy_cpu);
71 static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
73 #define lock_policy_rwsem(mode, cpu) \
74 static int lock_policy_rwsem_##mode(int cpu) \
76 int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu); \
77 BUG_ON(policy_cpu == -1); \
78 down_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
83 lock_policy_rwsem(read, cpu);
84 lock_policy_rwsem(write, cpu);
86 #define unlock_policy_rwsem(mode, cpu) \
87 static void unlock_policy_rwsem_##mode(int cpu) \
89 int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu); \
90 BUG_ON(policy_cpu == -1); \
91 up_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
94 unlock_policy_rwsem(read, cpu);
95 unlock_policy_rwsem(write, cpu);
97 /* internal prototypes */
98 static int __cpufreq_governor(struct cpufreq_policy *policy,
100 static unsigned int __cpufreq_get(unsigned int cpu);
101 static void handle_update(struct work_struct *work);
104 * Two notifier lists: the "policy" list is involved in the
105 * validation process for a new CPU frequency policy; the
106 * "transition" list for kernel code that needs to handle
107 * changes to devices when the CPU clock speed changes.
108 * The mutex locks both lists.
110 static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
111 static struct srcu_notifier_head cpufreq_transition_notifier_list;
113 static bool init_cpufreq_transition_notifier_list_called;
114 static int __init init_cpufreq_transition_notifier_list(void)
116 srcu_init_notifier_head(&cpufreq_transition_notifier_list);
117 init_cpufreq_transition_notifier_list_called = true;
120 pure_initcall(init_cpufreq_transition_notifier_list);
122 static int off __read_mostly;
123 static int cpufreq_disabled(void)
127 void disable_cpufreq(void)
131 static LIST_HEAD(cpufreq_governor_list);
132 static DEFINE_MUTEX(cpufreq_governor_mutex);
134 bool have_governor_per_policy(void)
136 return cpufreq_driver->have_governor_per_policy;
138 EXPORT_SYMBOL_GPL(have_governor_per_policy);
140 struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)
142 if (have_governor_per_policy())
143 return &policy->kobj;
145 return cpufreq_global_kobject;
147 EXPORT_SYMBOL_GPL(get_governor_parent_kobj);
149 static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
155 cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
157 busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
158 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
159 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
160 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
161 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
162 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
164 idle_time = cur_wall_time - busy_time;
166 *wall = cputime_to_usecs(cur_wall_time);
168 return cputime_to_usecs(idle_time);
171 u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
173 u64 idle_time = get_cpu_idle_time_us(cpu, io_busy ? wall : NULL);
175 if (idle_time == -1ULL)
176 return get_cpu_idle_time_jiffy(cpu, wall);
178 idle_time += get_cpu_iowait_time_us(cpu, wall);
182 EXPORT_SYMBOL_GPL(get_cpu_idle_time);
184 static struct cpufreq_policy *__cpufreq_cpu_get(unsigned int cpu, bool sysfs)
186 struct cpufreq_policy *data;
189 if (cpu >= nr_cpu_ids)
192 /* get the cpufreq driver */
193 read_lock_irqsave(&cpufreq_driver_lock, flags);
198 if (!try_module_get(cpufreq_driver->owner))
203 data = per_cpu(cpufreq_cpu_data, cpu);
206 goto err_out_put_module;
208 if (!sysfs && !kobject_get(&data->kobj))
209 goto err_out_put_module;
211 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
215 module_put(cpufreq_driver->owner);
217 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
222 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
224 if (cpufreq_disabled())
227 return __cpufreq_cpu_get(cpu, false);
229 EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
231 static struct cpufreq_policy *cpufreq_cpu_get_sysfs(unsigned int cpu)
233 return __cpufreq_cpu_get(cpu, true);
236 static void __cpufreq_cpu_put(struct cpufreq_policy *data, bool sysfs)
239 kobject_put(&data->kobj);
240 module_put(cpufreq_driver->owner);
243 void cpufreq_cpu_put(struct cpufreq_policy *data)
245 if (cpufreq_disabled())
248 __cpufreq_cpu_put(data, false);
250 EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
252 static void cpufreq_cpu_put_sysfs(struct cpufreq_policy *data)
254 __cpufreq_cpu_put(data, true);
257 /*********************************************************************
258 * EXTERNALLY AFFECTING FREQUENCY CHANGES *
259 *********************************************************************/
262 * adjust_jiffies - adjust the system "loops_per_jiffy"
264 * This function alters the system "loops_per_jiffy" for the clock
265 * speed change. Note that loops_per_jiffy cannot be updated on SMP
266 * systems as each CPU might be scaled differently. So, use the arch
267 * per-CPU loops_per_jiffy value wherever possible.
270 static unsigned long l_p_j_ref;
271 static unsigned int l_p_j_ref_freq;
273 static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
275 if (ci->flags & CPUFREQ_CONST_LOOPS)
278 if (!l_p_j_ref_freq) {
279 l_p_j_ref = loops_per_jiffy;
280 l_p_j_ref_freq = ci->old;
281 pr_debug("saving %lu as reference value for loops_per_jiffy; "
282 "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
284 if ((val == CPUFREQ_POSTCHANGE && ci->old != ci->new) ||
285 (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
286 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
288 pr_debug("scaling loops_per_jiffy to %lu "
289 "for frequency %u kHz\n", loops_per_jiffy, ci->new);
293 static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
300 void __cpufreq_notify_transition(struct cpufreq_policy *policy,
301 struct cpufreq_freqs *freqs, unsigned int state)
303 BUG_ON(irqs_disabled());
305 if (cpufreq_disabled())
308 freqs->flags = cpufreq_driver->flags;
309 pr_debug("notification %u of frequency transition to %u kHz\n",
314 case CPUFREQ_PRECHANGE:
315 /* detect if the driver reported a value as "old frequency"
316 * which is not equal to what the cpufreq core thinks is
319 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
320 if ((policy) && (policy->cpu == freqs->cpu) &&
321 (policy->cur) && (policy->cur != freqs->old)) {
322 pr_debug("Warning: CPU frequency is"
323 " %u, cpufreq assumed %u kHz.\n",
324 freqs->old, policy->cur);
325 freqs->old = policy->cur;
328 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
329 CPUFREQ_PRECHANGE, freqs);
330 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
333 case CPUFREQ_POSTCHANGE:
334 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
335 pr_debug("FREQ: %lu - CPU: %lu", (unsigned long)freqs->new,
336 (unsigned long)freqs->cpu);
337 trace_cpu_frequency(freqs->new, freqs->cpu);
338 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
339 CPUFREQ_POSTCHANGE, freqs);
340 if (likely(policy) && likely(policy->cpu == freqs->cpu))
341 policy->cur = freqs->new;
346 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
347 * on frequency transition.
349 * This function calls the transition notifiers and the "adjust_jiffies"
350 * function. It is called twice on all CPU frequency changes that have
353 void cpufreq_notify_transition(struct cpufreq_policy *policy,
354 struct cpufreq_freqs *freqs, unsigned int state)
356 for_each_cpu(freqs->cpu, policy->cpus)
357 __cpufreq_notify_transition(policy, freqs, state);
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);
408 mutex_unlock(&cpufreq_governor_mutex);
409 ret = request_module("cpufreq_%s", str_governor);
410 mutex_lock(&cpufreq_governor_mutex);
413 t = __find_governor(str_governor);
421 mutex_unlock(&cpufreq_governor_mutex);
429 * cpufreq_per_cpu_attr_read() / show_##file_name() -
430 * print out cpufreq information
432 * Write out information from cpufreq_driver->policy[cpu]; object must be
436 #define show_one(file_name, object) \
437 static ssize_t show_##file_name \
438 (struct cpufreq_policy *policy, char *buf) \
440 return sprintf(buf, "%u\n", policy->object); \
443 show_one(cpuinfo_min_freq, cpuinfo.min_freq);
444 show_one(cpuinfo_max_freq, cpuinfo.max_freq);
445 show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
446 show_one(scaling_min_freq, min);
447 show_one(scaling_max_freq, max);
448 show_one(scaling_cur_freq, cur);
450 static int __cpufreq_set_policy(struct cpufreq_policy *data,
451 struct cpufreq_policy *policy);
454 * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
456 #define store_one(file_name, object) \
457 static ssize_t store_##file_name \
458 (struct cpufreq_policy *policy, const char *buf, size_t count) \
461 struct cpufreq_policy new_policy; \
463 ret = cpufreq_get_policy(&new_policy, policy->cpu); \
467 ret = sscanf(buf, "%u", &new_policy.object); \
471 ret = __cpufreq_set_policy(policy, &new_policy); \
472 policy->user_policy.object = policy->object; \
474 return ret ? ret : count; \
477 store_one(scaling_min_freq, min);
478 store_one(scaling_max_freq, max);
481 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
483 static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
486 unsigned int cur_freq = __cpufreq_get(policy->cpu);
488 return sprintf(buf, "<unknown>");
489 return sprintf(buf, "%u\n", cur_freq);
494 * show_scaling_governor - show the current policy for the specified CPU
496 static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
498 if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
499 return sprintf(buf, "powersave\n");
500 else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
501 return sprintf(buf, "performance\n");
502 else if (policy->governor)
503 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
504 policy->governor->name);
510 * store_scaling_governor - store policy for the specified CPU
512 static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
513 const char *buf, size_t count)
516 char str_governor[16];
517 struct cpufreq_policy new_policy;
519 ret = cpufreq_get_policy(&new_policy, policy->cpu);
523 ret = sscanf(buf, "%15s", str_governor);
527 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
528 &new_policy.governor))
531 /* Do not use cpufreq_set_policy here or the user_policy.max
532 will be wrongly overridden */
533 ret = __cpufreq_set_policy(policy, &new_policy);
535 policy->user_policy.policy = policy->policy;
536 policy->user_policy.governor = policy->governor;
545 * show_scaling_driver - show the cpufreq driver currently loaded
547 static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
549 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
553 * show_scaling_available_governors - show the available CPUfreq governors
555 static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
559 struct cpufreq_governor *t;
561 if (!cpufreq_driver->target) {
562 i += sprintf(buf, "performance powersave");
566 list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
567 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
568 - (CPUFREQ_NAME_LEN + 2)))
570 i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
573 i += sprintf(&buf[i], "\n");
577 static ssize_t show_cpus(const struct cpumask *mask, char *buf)
582 for_each_cpu(cpu, mask) {
584 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
585 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
586 if (i >= (PAGE_SIZE - 5))
589 i += sprintf(&buf[i], "\n");
594 * show_related_cpus - show the CPUs affected by each transition even if
595 * hw coordination is in use
597 static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
599 return show_cpus(policy->related_cpus, buf);
603 * show_affected_cpus - show the CPUs affected by each transition
605 static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
607 return show_cpus(policy->cpus, buf);
610 static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
611 const char *buf, size_t count)
613 unsigned int freq = 0;
616 if (!policy->governor || !policy->governor->store_setspeed)
619 ret = sscanf(buf, "%u", &freq);
623 policy->governor->store_setspeed(policy, freq);
628 static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
630 if (!policy->governor || !policy->governor->show_setspeed)
631 return sprintf(buf, "<unsupported>\n");
633 return policy->governor->show_setspeed(policy, buf);
637 * show_bios_limit - show the current cpufreq HW/BIOS limitation
639 static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
643 if (cpufreq_driver->bios_limit) {
644 ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
646 return sprintf(buf, "%u\n", limit);
648 return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
651 cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
652 cpufreq_freq_attr_ro(cpuinfo_min_freq);
653 cpufreq_freq_attr_ro(cpuinfo_max_freq);
654 cpufreq_freq_attr_ro(cpuinfo_transition_latency);
655 cpufreq_freq_attr_ro(scaling_available_governors);
656 cpufreq_freq_attr_ro(scaling_driver);
657 cpufreq_freq_attr_ro(scaling_cur_freq);
658 cpufreq_freq_attr_ro(bios_limit);
659 cpufreq_freq_attr_ro(related_cpus);
660 cpufreq_freq_attr_ro(affected_cpus);
661 cpufreq_freq_attr_rw(scaling_min_freq);
662 cpufreq_freq_attr_rw(scaling_max_freq);
663 cpufreq_freq_attr_rw(scaling_governor);
664 cpufreq_freq_attr_rw(scaling_setspeed);
666 static struct attribute *default_attrs[] = {
667 &cpuinfo_min_freq.attr,
668 &cpuinfo_max_freq.attr,
669 &cpuinfo_transition_latency.attr,
670 &scaling_min_freq.attr,
671 &scaling_max_freq.attr,
674 &scaling_governor.attr,
675 &scaling_driver.attr,
676 &scaling_available_governors.attr,
677 &scaling_setspeed.attr,
681 struct kobject *cpufreq_global_kobject;
682 EXPORT_SYMBOL(cpufreq_global_kobject);
684 #define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
685 #define to_attr(a) container_of(a, struct freq_attr, attr)
687 static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
689 struct cpufreq_policy *policy = to_policy(kobj);
690 struct freq_attr *fattr = to_attr(attr);
691 ssize_t ret = -EINVAL;
692 policy = cpufreq_cpu_get_sysfs(policy->cpu);
696 if (lock_policy_rwsem_read(policy->cpu) < 0)
700 ret = fattr->show(policy, buf);
704 unlock_policy_rwsem_read(policy->cpu);
706 cpufreq_cpu_put_sysfs(policy);
711 static ssize_t store(struct kobject *kobj, struct attribute *attr,
712 const char *buf, size_t count)
714 struct cpufreq_policy *policy = to_policy(kobj);
715 struct freq_attr *fattr = to_attr(attr);
716 ssize_t ret = -EINVAL;
717 policy = cpufreq_cpu_get_sysfs(policy->cpu);
721 if (lock_policy_rwsem_write(policy->cpu) < 0)
725 ret = fattr->store(policy, buf, count);
729 unlock_policy_rwsem_write(policy->cpu);
731 cpufreq_cpu_put_sysfs(policy);
736 static void cpufreq_sysfs_release(struct kobject *kobj)
738 struct cpufreq_policy *policy = to_policy(kobj);
739 pr_debug("last reference is dropped\n");
740 complete(&policy->kobj_unregister);
743 static const struct sysfs_ops sysfs_ops = {
748 static struct kobj_type ktype_cpufreq = {
749 .sysfs_ops = &sysfs_ops,
750 .default_attrs = default_attrs,
751 .release = cpufreq_sysfs_release,
754 /* symlink affected CPUs */
755 static int cpufreq_add_dev_symlink(unsigned int cpu,
756 struct cpufreq_policy *policy)
761 for_each_cpu(j, policy->cpus) {
762 struct cpufreq_policy *managed_policy;
763 struct device *cpu_dev;
768 pr_debug("CPU %u already managed, adding link\n", j);
769 managed_policy = cpufreq_cpu_get(cpu);
770 cpu_dev = get_cpu_device(j);
771 ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
774 cpufreq_cpu_put(managed_policy);
781 static int cpufreq_add_dev_interface(unsigned int cpu,
782 struct cpufreq_policy *policy,
785 struct cpufreq_policy new_policy;
786 struct freq_attr **drv_attr;
791 /* prepare interface data */
792 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
793 &dev->kobj, "cpufreq");
797 /* set up files for this cpu device */
798 drv_attr = cpufreq_driver->attr;
799 while ((drv_attr) && (*drv_attr)) {
800 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
802 goto err_out_kobj_put;
805 if (cpufreq_driver->get) {
806 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
808 goto err_out_kobj_put;
810 if (cpufreq_driver->target) {
811 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
813 goto err_out_kobj_put;
815 if (cpufreq_driver->bios_limit) {
816 ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
818 goto err_out_kobj_put;
821 write_lock_irqsave(&cpufreq_driver_lock, flags);
822 for_each_cpu(j, policy->cpus) {
823 per_cpu(cpufreq_cpu_data, j) = policy;
824 per_cpu(cpufreq_policy_cpu, j) = policy->cpu;
826 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
828 ret = cpufreq_add_dev_symlink(cpu, policy);
830 goto err_out_kobj_put;
832 memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
833 /* assure that the starting sequence is run in __cpufreq_set_policy */
834 policy->governor = NULL;
836 /* set default policy */
837 ret = __cpufreq_set_policy(policy, &new_policy);
838 policy->user_policy.policy = policy->policy;
839 policy->user_policy.governor = policy->governor;
842 pr_debug("setting policy failed\n");
843 if (cpufreq_driver->exit)
844 cpufreq_driver->exit(policy);
849 kobject_put(&policy->kobj);
850 wait_for_completion(&policy->kobj_unregister);
854 #ifdef CONFIG_HOTPLUG_CPU
855 static int cpufreq_add_policy_cpu(unsigned int cpu, unsigned int sibling,
858 struct cpufreq_policy *policy;
859 int ret = 0, has_target = !!cpufreq_driver->target;
862 policy = cpufreq_cpu_get(sibling);
866 __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
868 lock_policy_rwsem_write(sibling);
870 write_lock_irqsave(&cpufreq_driver_lock, flags);
872 cpumask_set_cpu(cpu, policy->cpus);
873 per_cpu(cpufreq_policy_cpu, cpu) = policy->cpu;
874 per_cpu(cpufreq_cpu_data, cpu) = policy;
875 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
877 unlock_policy_rwsem_write(sibling);
880 __cpufreq_governor(policy, CPUFREQ_GOV_START);
881 __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
884 ret = sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
886 cpufreq_cpu_put(policy);
895 * cpufreq_add_dev - add a CPU device
897 * Adds the cpufreq interface for a CPU device.
899 * The Oracle says: try running cpufreq registration/unregistration concurrently
900 * with with cpu hotplugging and all hell will break loose. Tried to clean this
901 * mess up, but more thorough testing is needed. - Mathieu
903 static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
905 unsigned int j, cpu = dev->id;
907 struct cpufreq_policy *policy;
909 #ifdef CONFIG_HOTPLUG_CPU
910 struct cpufreq_governor *gov;
914 if (cpu_is_offline(cpu))
917 pr_debug("adding CPU %u\n", cpu);
920 /* check whether a different CPU already registered this
921 * CPU because it is in the same boat. */
922 policy = cpufreq_cpu_get(cpu);
923 if (unlikely(policy)) {
924 cpufreq_cpu_put(policy);
928 #ifdef CONFIG_HOTPLUG_CPU
929 /* Check if this cpu was hot-unplugged earlier and has siblings */
930 read_lock_irqsave(&cpufreq_driver_lock, flags);
931 for_each_online_cpu(sibling) {
932 struct cpufreq_policy *cp = per_cpu(cpufreq_cpu_data, sibling);
933 if (cp && cpumask_test_cpu(cpu, cp->related_cpus)) {
934 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
935 return cpufreq_add_policy_cpu(cpu, sibling, dev);
938 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
942 if (!try_module_get(cpufreq_driver->owner)) {
947 policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
951 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
952 goto err_free_policy;
954 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
955 goto err_free_cpumask;
958 policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
959 cpumask_copy(policy->cpus, cpumask_of(cpu));
961 /* Initially set CPU itself as the policy_cpu */
962 per_cpu(cpufreq_policy_cpu, cpu) = cpu;
964 init_completion(&policy->kobj_unregister);
965 INIT_WORK(&policy->update, handle_update);
967 /* call driver. From then on the cpufreq must be able
968 * to accept all calls to ->verify and ->setpolicy for this CPU
970 ret = cpufreq_driver->init(policy);
972 pr_debug("initialization failed\n");
973 goto err_set_policy_cpu;
976 /* related cpus should atleast have policy->cpus */
977 cpumask_or(policy->related_cpus, policy->related_cpus, policy->cpus);
980 * affected cpus must always be the one, which are online. We aren't
981 * managing offline cpus here.
983 cpumask_and(policy->cpus, policy->cpus, cpu_online_mask);
985 policy->user_policy.min = policy->min;
986 policy->user_policy.max = policy->max;
988 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
989 CPUFREQ_START, policy);
991 #ifdef CONFIG_HOTPLUG_CPU
992 gov = __find_governor(per_cpu(cpufreq_cpu_governor, cpu));
994 policy->governor = gov;
995 pr_debug("Restoring governor %s for cpu %d\n",
996 policy->governor->name, cpu);
1000 ret = cpufreq_add_dev_interface(cpu, policy, dev);
1002 goto err_out_unregister;
1004 kobject_uevent(&policy->kobj, KOBJ_ADD);
1005 module_put(cpufreq_driver->owner);
1006 pr_debug("initialization complete\n");
1011 write_lock_irqsave(&cpufreq_driver_lock, flags);
1012 for_each_cpu(j, policy->cpus)
1013 per_cpu(cpufreq_cpu_data, j) = NULL;
1014 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1016 kobject_put(&policy->kobj);
1017 wait_for_completion(&policy->kobj_unregister);
1020 per_cpu(cpufreq_policy_cpu, cpu) = -1;
1021 free_cpumask_var(policy->related_cpus);
1023 free_cpumask_var(policy->cpus);
1027 module_put(cpufreq_driver->owner);
1032 static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
1036 policy->last_cpu = policy->cpu;
1039 for_each_cpu(j, policy->cpus)
1040 per_cpu(cpufreq_policy_cpu, j) = cpu;
1042 #ifdef CONFIG_CPU_FREQ_TABLE
1043 cpufreq_frequency_table_update_policy_cpu(policy);
1045 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1046 CPUFREQ_UPDATE_POLICY_CPU, policy);
1050 * __cpufreq_remove_dev - remove a CPU device
1052 * Removes the cpufreq interface for a CPU device.
1053 * Caller should already have policy_rwsem in write mode for this CPU.
1054 * This routine frees the rwsem before returning.
1056 static int __cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
1058 unsigned int cpu = dev->id, ret, cpus;
1059 unsigned long flags;
1060 struct cpufreq_policy *data;
1061 struct kobject *kobj;
1062 struct completion *cmp;
1063 struct device *cpu_dev;
1065 pr_debug("%s: unregistering CPU %u\n", __func__, cpu);
1067 write_lock_irqsave(&cpufreq_driver_lock, flags);
1069 data = per_cpu(cpufreq_cpu_data, cpu);
1070 per_cpu(cpufreq_cpu_data, cpu) = NULL;
1072 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1075 pr_debug("%s: No cpu_data found\n", __func__);
1079 if (cpufreq_driver->target)
1080 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1082 #ifdef CONFIG_HOTPLUG_CPU
1083 if (!cpufreq_driver->setpolicy)
1084 strncpy(per_cpu(cpufreq_cpu_governor, cpu),
1085 data->governor->name, CPUFREQ_NAME_LEN);
1088 WARN_ON(lock_policy_rwsem_write(cpu));
1089 cpus = cpumask_weight(data->cpus);
1092 cpumask_clear_cpu(cpu, data->cpus);
1093 unlock_policy_rwsem_write(cpu);
1095 if (cpu != data->cpu) {
1096 sysfs_remove_link(&dev->kobj, "cpufreq");
1097 } else if (cpus > 1) {
1098 /* first sibling now owns the new sysfs dir */
1099 cpu_dev = get_cpu_device(cpumask_first(data->cpus));
1100 sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
1101 ret = kobject_move(&data->kobj, &cpu_dev->kobj);
1103 pr_err("%s: Failed to move kobj: %d", __func__, ret);
1105 WARN_ON(lock_policy_rwsem_write(cpu));
1106 cpumask_set_cpu(cpu, data->cpus);
1108 write_lock_irqsave(&cpufreq_driver_lock, flags);
1109 per_cpu(cpufreq_cpu_data, cpu) = data;
1110 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1112 unlock_policy_rwsem_write(cpu);
1114 ret = sysfs_create_link(&cpu_dev->kobj, &data->kobj,
1119 WARN_ON(lock_policy_rwsem_write(cpu));
1120 update_policy_cpu(data, cpu_dev->id);
1121 unlock_policy_rwsem_write(cpu);
1122 pr_debug("%s: policy Kobject moved to cpu: %d from: %d\n",
1123 __func__, cpu_dev->id, cpu);
1126 if ((cpus == 1) && (cpufreq_driver->target))
1127 __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
1129 pr_debug("%s: removing link, cpu: %d\n", __func__, cpu);
1130 cpufreq_cpu_put(data);
1132 /* If cpu is last user of policy, free policy */
1134 lock_policy_rwsem_read(cpu);
1136 cmp = &data->kobj_unregister;
1137 unlock_policy_rwsem_read(cpu);
1140 /* we need to make sure that the underlying kobj is actually
1141 * not referenced anymore by anybody before we proceed with
1144 pr_debug("waiting for dropping of refcount\n");
1145 wait_for_completion(cmp);
1146 pr_debug("wait complete\n");
1148 if (cpufreq_driver->exit)
1149 cpufreq_driver->exit(data);
1151 free_cpumask_var(data->related_cpus);
1152 free_cpumask_var(data->cpus);
1154 } else if (cpufreq_driver->target) {
1155 __cpufreq_governor(data, CPUFREQ_GOV_START);
1156 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1159 per_cpu(cpufreq_policy_cpu, cpu) = -1;
1164 static int cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
1166 unsigned int cpu = dev->id;
1169 if (cpu_is_offline(cpu))
1172 retval = __cpufreq_remove_dev(dev, sif);
1177 static void handle_update(struct work_struct *work)
1179 struct cpufreq_policy *policy =
1180 container_of(work, struct cpufreq_policy, update);
1181 unsigned int cpu = policy->cpu;
1182 pr_debug("handle_update for cpu %u called\n", cpu);
1183 cpufreq_update_policy(cpu);
1187 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
1189 * @old_freq: CPU frequency the kernel thinks the CPU runs at
1190 * @new_freq: CPU frequency the CPU actually runs at
1192 * We adjust to current frequency first, and need to clean up later.
1193 * So either call to cpufreq_update_policy() or schedule handle_update()).
1195 static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1196 unsigned int new_freq)
1198 struct cpufreq_policy *policy;
1199 struct cpufreq_freqs freqs;
1200 unsigned long flags;
1203 pr_debug("Warning: CPU frequency out of sync: cpufreq and timing "
1204 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1206 freqs.old = old_freq;
1207 freqs.new = new_freq;
1209 read_lock_irqsave(&cpufreq_driver_lock, flags);
1210 policy = per_cpu(cpufreq_cpu_data, cpu);
1211 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1213 cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
1214 cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
1219 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
1222 * This is the last known freq, without actually getting it from the driver.
1223 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1225 unsigned int cpufreq_quick_get(unsigned int cpu)
1227 struct cpufreq_policy *policy;
1228 unsigned int ret_freq = 0;
1230 if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
1231 return cpufreq_driver->get(cpu);
1233 policy = cpufreq_cpu_get(cpu);
1235 ret_freq = policy->cur;
1236 cpufreq_cpu_put(policy);
1241 EXPORT_SYMBOL(cpufreq_quick_get);
1244 * cpufreq_quick_get_max - get the max reported CPU frequency for this CPU
1247 * Just return the max possible frequency for a given CPU.
1249 unsigned int cpufreq_quick_get_max(unsigned int cpu)
1251 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1252 unsigned int ret_freq = 0;
1255 ret_freq = policy->max;
1256 cpufreq_cpu_put(policy);
1261 EXPORT_SYMBOL(cpufreq_quick_get_max);
1264 static unsigned int __cpufreq_get(unsigned int cpu)
1266 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1267 unsigned int ret_freq = 0;
1269 if (!cpufreq_driver->get)
1272 ret_freq = cpufreq_driver->get(cpu);
1274 if (ret_freq && policy->cur &&
1275 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1276 /* verify no discrepancy between actual and
1277 saved value exists */
1278 if (unlikely(ret_freq != policy->cur)) {
1279 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
1280 schedule_work(&policy->update);
1288 * cpufreq_get - get the current CPU frequency (in kHz)
1291 * Get the CPU current (static) CPU frequency
1293 unsigned int cpufreq_get(unsigned int cpu)
1295 unsigned int ret_freq = 0;
1296 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1301 if (unlikely(lock_policy_rwsem_read(cpu)))
1304 ret_freq = __cpufreq_get(cpu);
1306 unlock_policy_rwsem_read(cpu);
1309 cpufreq_cpu_put(policy);
1313 EXPORT_SYMBOL(cpufreq_get);
1315 static struct subsys_interface cpufreq_interface = {
1317 .subsys = &cpu_subsys,
1318 .add_dev = cpufreq_add_dev,
1319 .remove_dev = cpufreq_remove_dev,
1324 * cpufreq_bp_suspend - Prepare the boot CPU for system suspend.
1326 * This function is only executed for the boot processor. The other CPUs
1327 * have been put offline by means of CPU hotplug.
1329 static int cpufreq_bp_suspend(void)
1333 int cpu = smp_processor_id();
1334 struct cpufreq_policy *cpu_policy;
1336 pr_debug("suspending cpu %u\n", cpu);
1338 /* If there's no policy for the boot CPU, we have nothing to do. */
1339 cpu_policy = cpufreq_cpu_get(cpu);
1343 if (cpufreq_driver->suspend) {
1344 ret = cpufreq_driver->suspend(cpu_policy);
1346 printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1347 "step on CPU %u\n", cpu_policy->cpu);
1350 cpufreq_cpu_put(cpu_policy);
1355 * cpufreq_bp_resume - Restore proper frequency handling of the boot CPU.
1357 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
1358 * 2.) schedule call cpufreq_update_policy() ASAP as interrupts are
1359 * restored. It will verify that the current freq is in sync with
1360 * what we believe it to be. This is a bit later than when it
1361 * should be, but nonethteless it's better than calling
1362 * cpufreq_driver->get() here which might re-enable interrupts...
1364 * This function is only executed for the boot CPU. The other CPUs have not
1365 * been turned on yet.
1367 static void cpufreq_bp_resume(void)
1371 int cpu = smp_processor_id();
1372 struct cpufreq_policy *cpu_policy;
1374 pr_debug("resuming cpu %u\n", cpu);
1376 /* If there's no policy for the boot CPU, we have nothing to do. */
1377 cpu_policy = cpufreq_cpu_get(cpu);
1381 if (cpufreq_driver->resume) {
1382 ret = cpufreq_driver->resume(cpu_policy);
1384 printk(KERN_ERR "cpufreq: resume failed in ->resume "
1385 "step on CPU %u\n", cpu_policy->cpu);
1390 schedule_work(&cpu_policy->update);
1393 cpufreq_cpu_put(cpu_policy);
1396 static struct syscore_ops cpufreq_syscore_ops = {
1397 .suspend = cpufreq_bp_suspend,
1398 .resume = cpufreq_bp_resume,
1402 * cpufreq_get_current_driver - return current driver's name
1404 * Return the name string of the currently loaded cpufreq driver
1407 const char *cpufreq_get_current_driver(void)
1410 return cpufreq_driver->name;
1414 EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
1416 /*********************************************************************
1417 * NOTIFIER LISTS INTERFACE *
1418 *********************************************************************/
1421 * cpufreq_register_notifier - register a driver with cpufreq
1422 * @nb: notifier function to register
1423 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1425 * Add a driver to one of two lists: either a list of drivers that
1426 * are notified about clock rate changes (once before and once after
1427 * the transition), or a list of drivers that are notified about
1428 * changes in cpufreq policy.
1430 * This function may sleep, and has the same return conditions as
1431 * blocking_notifier_chain_register.
1433 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1437 if (cpufreq_disabled())
1440 WARN_ON(!init_cpufreq_transition_notifier_list_called);
1443 case CPUFREQ_TRANSITION_NOTIFIER:
1444 ret = srcu_notifier_chain_register(
1445 &cpufreq_transition_notifier_list, nb);
1447 case CPUFREQ_POLICY_NOTIFIER:
1448 ret = blocking_notifier_chain_register(
1449 &cpufreq_policy_notifier_list, nb);
1457 EXPORT_SYMBOL(cpufreq_register_notifier);
1461 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1462 * @nb: notifier block to be unregistered
1463 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1465 * Remove a driver from the CPU frequency notifier list.
1467 * This function may sleep, and has the same return conditions as
1468 * blocking_notifier_chain_unregister.
1470 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1474 if (cpufreq_disabled())
1478 case CPUFREQ_TRANSITION_NOTIFIER:
1479 ret = srcu_notifier_chain_unregister(
1480 &cpufreq_transition_notifier_list, nb);
1482 case CPUFREQ_POLICY_NOTIFIER:
1483 ret = blocking_notifier_chain_unregister(
1484 &cpufreq_policy_notifier_list, nb);
1492 EXPORT_SYMBOL(cpufreq_unregister_notifier);
1495 /*********************************************************************
1497 *********************************************************************/
1500 int __cpufreq_driver_target(struct cpufreq_policy *policy,
1501 unsigned int target_freq,
1502 unsigned int relation)
1504 int retval = -EINVAL;
1505 unsigned int old_target_freq = target_freq;
1507 if (cpufreq_disabled())
1510 /* Make sure that target_freq is within supported range */
1511 if (target_freq > policy->max)
1512 target_freq = policy->max;
1513 if (target_freq < policy->min)
1514 target_freq = policy->min;
1516 pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
1517 policy->cpu, target_freq, relation, old_target_freq);
1519 if (target_freq == policy->cur)
1522 if (cpufreq_driver->target)
1523 retval = cpufreq_driver->target(policy, target_freq, relation);
1527 EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1529 int cpufreq_driver_target(struct cpufreq_policy *policy,
1530 unsigned int target_freq,
1531 unsigned int relation)
1535 policy = cpufreq_cpu_get(policy->cpu);
1539 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
1542 ret = __cpufreq_driver_target(policy, target_freq, relation);
1544 unlock_policy_rwsem_write(policy->cpu);
1547 cpufreq_cpu_put(policy);
1551 EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1553 int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
1557 if (cpufreq_disabled())
1560 if (!cpufreq_driver->getavg)
1563 policy = cpufreq_cpu_get(policy->cpu);
1567 ret = cpufreq_driver->getavg(policy, cpu);
1569 cpufreq_cpu_put(policy);
1572 EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
1575 * when "event" is CPUFREQ_GOV_LIMITS
1578 static int __cpufreq_governor(struct cpufreq_policy *policy,
1583 /* Only must be defined when default governor is known to have latency
1584 restrictions, like e.g. conservative or ondemand.
1585 That this is the case is already ensured in Kconfig
1587 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1588 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1590 struct cpufreq_governor *gov = NULL;
1593 if (policy->governor->max_transition_latency &&
1594 policy->cpuinfo.transition_latency >
1595 policy->governor->max_transition_latency) {
1599 printk(KERN_WARNING "%s governor failed, too long"
1600 " transition latency of HW, fallback"
1601 " to %s governor\n",
1602 policy->governor->name,
1604 policy->governor = gov;
1608 if (!try_module_get(policy->governor->owner))
1611 pr_debug("__cpufreq_governor for CPU %u, event %u\n",
1612 policy->cpu, event);
1613 ret = policy->governor->governor(policy, event);
1616 if (event == CPUFREQ_GOV_POLICY_INIT)
1617 policy->governor->initialized++;
1618 else if (event == CPUFREQ_GOV_POLICY_EXIT)
1619 policy->governor->initialized--;
1622 /* we keep one module reference alive for
1623 each CPU governed by this CPU */
1624 if ((event != CPUFREQ_GOV_START) || ret)
1625 module_put(policy->governor->owner);
1626 if ((event == CPUFREQ_GOV_STOP) && !ret)
1627 module_put(policy->governor->owner);
1633 int cpufreq_register_governor(struct cpufreq_governor *governor)
1640 if (cpufreq_disabled())
1643 mutex_lock(&cpufreq_governor_mutex);
1645 governor->initialized = 0;
1647 if (__find_governor(governor->name) == NULL) {
1649 list_add(&governor->governor_list, &cpufreq_governor_list);
1652 mutex_unlock(&cpufreq_governor_mutex);
1655 EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1658 void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1660 #ifdef CONFIG_HOTPLUG_CPU
1667 if (cpufreq_disabled())
1670 #ifdef CONFIG_HOTPLUG_CPU
1671 for_each_present_cpu(cpu) {
1672 if (cpu_online(cpu))
1674 if (!strcmp(per_cpu(cpufreq_cpu_governor, cpu), governor->name))
1675 strcpy(per_cpu(cpufreq_cpu_governor, cpu), "\0");
1679 mutex_lock(&cpufreq_governor_mutex);
1680 list_del(&governor->governor_list);
1681 mutex_unlock(&cpufreq_governor_mutex);
1684 EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1688 /*********************************************************************
1689 * POLICY INTERFACE *
1690 *********************************************************************/
1693 * cpufreq_get_policy - get the current cpufreq_policy
1694 * @policy: struct cpufreq_policy into which the current cpufreq_policy
1697 * Reads the current cpufreq policy.
1699 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1701 struct cpufreq_policy *cpu_policy;
1705 cpu_policy = cpufreq_cpu_get(cpu);
1709 memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
1711 cpufreq_cpu_put(cpu_policy);
1714 EXPORT_SYMBOL(cpufreq_get_policy);
1718 * data : current policy.
1719 * policy : policy to be set.
1721 static int __cpufreq_set_policy(struct cpufreq_policy *data,
1722 struct cpufreq_policy *policy)
1724 int ret = 0, failed = 1;
1726 pr_debug("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
1727 policy->min, policy->max);
1729 memcpy(&policy->cpuinfo, &data->cpuinfo,
1730 sizeof(struct cpufreq_cpuinfo));
1732 if (policy->min > data->max || policy->max < data->min) {
1737 /* verify the cpu speed can be set within this limit */
1738 ret = cpufreq_driver->verify(policy);
1742 /* adjust if necessary - all reasons */
1743 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1744 CPUFREQ_ADJUST, policy);
1746 /* adjust if necessary - hardware incompatibility*/
1747 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1748 CPUFREQ_INCOMPATIBLE, policy);
1750 /* verify the cpu speed can be set within this limit,
1751 which might be different to the first one */
1752 ret = cpufreq_driver->verify(policy);
1756 /* notification of the new policy */
1757 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1758 CPUFREQ_NOTIFY, policy);
1760 data->min = policy->min;
1761 data->max = policy->max;
1763 pr_debug("new min and max freqs are %u - %u kHz\n",
1764 data->min, data->max);
1766 if (cpufreq_driver->setpolicy) {
1767 data->policy = policy->policy;
1768 pr_debug("setting range\n");
1769 ret = cpufreq_driver->setpolicy(policy);
1771 if (policy->governor != data->governor) {
1772 /* save old, working values */
1773 struct cpufreq_governor *old_gov = data->governor;
1775 pr_debug("governor switch\n");
1777 /* end old governor */
1778 if (data->governor) {
1779 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1780 unlock_policy_rwsem_write(policy->cpu);
1781 __cpufreq_governor(data,
1782 CPUFREQ_GOV_POLICY_EXIT);
1783 lock_policy_rwsem_write(policy->cpu);
1786 /* start new governor */
1787 data->governor = policy->governor;
1788 if (!__cpufreq_governor(data, CPUFREQ_GOV_POLICY_INIT)) {
1789 if (!__cpufreq_governor(data, CPUFREQ_GOV_START)) {
1792 unlock_policy_rwsem_write(policy->cpu);
1793 __cpufreq_governor(data,
1794 CPUFREQ_GOV_POLICY_EXIT);
1795 lock_policy_rwsem_write(policy->cpu);
1800 /* new governor failed, so re-start old one */
1801 pr_debug("starting governor %s failed\n",
1802 data->governor->name);
1804 data->governor = old_gov;
1805 __cpufreq_governor(data,
1806 CPUFREQ_GOV_POLICY_INIT);
1807 __cpufreq_governor(data,
1813 /* might be a policy change, too, so fall through */
1815 pr_debug("governor: change or update limits\n");
1816 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1824 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1825 * @cpu: CPU which shall be re-evaluated
1827 * Useful for policy notifiers which have different necessities
1828 * at different times.
1830 int cpufreq_update_policy(unsigned int cpu)
1832 struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
1833 struct cpufreq_policy policy;
1841 if (unlikely(lock_policy_rwsem_write(cpu))) {
1846 pr_debug("updating policy for CPU %u\n", cpu);
1847 memcpy(&policy, data, sizeof(struct cpufreq_policy));
1848 policy.min = data->user_policy.min;
1849 policy.max = data->user_policy.max;
1850 policy.policy = data->user_policy.policy;
1851 policy.governor = data->user_policy.governor;
1853 /* BIOS might change freq behind our back
1854 -> ask driver for current freq and notify governors about a change */
1855 if (cpufreq_driver->get) {
1856 policy.cur = cpufreq_driver->get(cpu);
1858 pr_debug("Driver did not initialize current freq");
1859 data->cur = policy.cur;
1861 if (data->cur != policy.cur && cpufreq_driver->target)
1862 cpufreq_out_of_sync(cpu, data->cur,
1867 ret = __cpufreq_set_policy(data, &policy);
1869 unlock_policy_rwsem_write(cpu);
1872 cpufreq_cpu_put(data);
1876 EXPORT_SYMBOL(cpufreq_update_policy);
1878 static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
1879 unsigned long action, void *hcpu)
1881 unsigned int cpu = (unsigned long)hcpu;
1884 dev = get_cpu_device(cpu);
1888 case CPU_ONLINE_FROZEN:
1889 cpufreq_add_dev(dev, NULL);
1891 case CPU_DOWN_PREPARE:
1892 case CPU_DOWN_PREPARE_FROZEN:
1893 __cpufreq_remove_dev(dev, NULL);
1895 case CPU_DOWN_FAILED:
1896 case CPU_DOWN_FAILED_FROZEN:
1897 cpufreq_add_dev(dev, NULL);
1904 static struct notifier_block __refdata cpufreq_cpu_notifier = {
1905 .notifier_call = cpufreq_cpu_callback,
1908 /*********************************************************************
1909 * REGISTER / UNREGISTER CPUFREQ DRIVER *
1910 *********************************************************************/
1913 * cpufreq_register_driver - register a CPU Frequency driver
1914 * @driver_data: A struct cpufreq_driver containing the values#
1915 * submitted by the CPU Frequency driver.
1917 * Registers a CPU Frequency driver to this core code. This code
1918 * returns zero on success, -EBUSY when another driver got here first
1919 * (and isn't unregistered in the meantime).
1922 int cpufreq_register_driver(struct cpufreq_driver *driver_data)
1924 unsigned long flags;
1927 if (cpufreq_disabled())
1930 if (!driver_data || !driver_data->verify || !driver_data->init ||
1931 ((!driver_data->setpolicy) && (!driver_data->target)))
1934 pr_debug("trying to register driver %s\n", driver_data->name);
1936 if (driver_data->setpolicy)
1937 driver_data->flags |= CPUFREQ_CONST_LOOPS;
1939 write_lock_irqsave(&cpufreq_driver_lock, flags);
1940 if (cpufreq_driver) {
1941 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1944 cpufreq_driver = driver_data;
1945 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1947 ret = subsys_interface_register(&cpufreq_interface);
1949 goto err_null_driver;
1951 if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) {
1955 /* check for at least one working CPU */
1956 for (i = 0; i < nr_cpu_ids; i++)
1957 if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
1962 /* if all ->init() calls failed, unregister */
1964 pr_debug("no CPU initialized for driver %s\n",
1970 register_hotcpu_notifier(&cpufreq_cpu_notifier);
1971 pr_debug("driver %s up and running\n", driver_data->name);
1975 subsys_interface_unregister(&cpufreq_interface);
1977 write_lock_irqsave(&cpufreq_driver_lock, flags);
1978 cpufreq_driver = NULL;
1979 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1982 EXPORT_SYMBOL_GPL(cpufreq_register_driver);
1986 * cpufreq_unregister_driver - unregister the current CPUFreq driver
1988 * Unregister the current CPUFreq driver. Only call this if you have
1989 * the right to do so, i.e. if you have succeeded in initialising before!
1990 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
1991 * currently not initialised.
1993 int cpufreq_unregister_driver(struct cpufreq_driver *driver)
1995 unsigned long flags;
1997 if (!cpufreq_driver || (driver != cpufreq_driver))
2000 pr_debug("unregistering driver %s\n", driver->name);
2002 subsys_interface_unregister(&cpufreq_interface);
2003 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
2005 write_lock_irqsave(&cpufreq_driver_lock, flags);
2006 cpufreq_driver = NULL;
2007 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2011 EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
2013 static int __init cpufreq_core_init(void)
2017 if (cpufreq_disabled())
2020 for_each_possible_cpu(cpu) {
2021 per_cpu(cpufreq_policy_cpu, cpu) = -1;
2022 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
2025 cpufreq_global_kobject = kobject_create_and_add("cpufreq", &cpu_subsys.dev_root->kobj);
2026 BUG_ON(!cpufreq_global_kobject);
2027 register_syscore_ops(&cpufreq_syscore_ops);
2031 core_initcall(cpufreq_core_init);