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 cpu is last user of policy, free policy */
1128 if (cpufreq_driver->target)
1129 __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
1131 lock_policy_rwsem_read(cpu);
1133 cmp = &data->kobj_unregister;
1134 unlock_policy_rwsem_read(cpu);
1137 /* we need to make sure that the underlying kobj is actually
1138 * not referenced anymore by anybody before we proceed with
1141 pr_debug("waiting for dropping of refcount\n");
1142 wait_for_completion(cmp);
1143 pr_debug("wait complete\n");
1145 if (cpufreq_driver->exit)
1146 cpufreq_driver->exit(data);
1148 free_cpumask_var(data->related_cpus);
1149 free_cpumask_var(data->cpus);
1152 pr_debug("%s: removing link, cpu: %d\n", __func__, cpu);
1153 cpufreq_cpu_put(data);
1154 if (cpufreq_driver->target) {
1155 __cpufreq_governor(data, CPUFREQ_GOV_START);
1156 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1160 per_cpu(cpufreq_policy_cpu, cpu) = -1;
1165 static int cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
1167 unsigned int cpu = dev->id;
1170 if (cpu_is_offline(cpu))
1173 retval = __cpufreq_remove_dev(dev, sif);
1178 static void handle_update(struct work_struct *work)
1180 struct cpufreq_policy *policy =
1181 container_of(work, struct cpufreq_policy, update);
1182 unsigned int cpu = policy->cpu;
1183 pr_debug("handle_update for cpu %u called\n", cpu);
1184 cpufreq_update_policy(cpu);
1188 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
1190 * @old_freq: CPU frequency the kernel thinks the CPU runs at
1191 * @new_freq: CPU frequency the CPU actually runs at
1193 * We adjust to current frequency first, and need to clean up later.
1194 * So either call to cpufreq_update_policy() or schedule handle_update()).
1196 static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1197 unsigned int new_freq)
1199 struct cpufreq_policy *policy;
1200 struct cpufreq_freqs freqs;
1201 unsigned long flags;
1204 pr_debug("Warning: CPU frequency out of sync: cpufreq and timing "
1205 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1207 freqs.old = old_freq;
1208 freqs.new = new_freq;
1210 read_lock_irqsave(&cpufreq_driver_lock, flags);
1211 policy = per_cpu(cpufreq_cpu_data, cpu);
1212 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1214 cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
1215 cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
1220 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
1223 * This is the last known freq, without actually getting it from the driver.
1224 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1226 unsigned int cpufreq_quick_get(unsigned int cpu)
1228 struct cpufreq_policy *policy;
1229 unsigned int ret_freq = 0;
1231 if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
1232 return cpufreq_driver->get(cpu);
1234 policy = cpufreq_cpu_get(cpu);
1236 ret_freq = policy->cur;
1237 cpufreq_cpu_put(policy);
1242 EXPORT_SYMBOL(cpufreq_quick_get);
1245 * cpufreq_quick_get_max - get the max reported CPU frequency for this CPU
1248 * Just return the max possible frequency for a given CPU.
1250 unsigned int cpufreq_quick_get_max(unsigned int cpu)
1252 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1253 unsigned int ret_freq = 0;
1256 ret_freq = policy->max;
1257 cpufreq_cpu_put(policy);
1262 EXPORT_SYMBOL(cpufreq_quick_get_max);
1265 static unsigned int __cpufreq_get(unsigned int cpu)
1267 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1268 unsigned int ret_freq = 0;
1270 if (!cpufreq_driver->get)
1273 ret_freq = cpufreq_driver->get(cpu);
1275 if (ret_freq && policy->cur &&
1276 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1277 /* verify no discrepancy between actual and
1278 saved value exists */
1279 if (unlikely(ret_freq != policy->cur)) {
1280 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
1281 schedule_work(&policy->update);
1289 * cpufreq_get - get the current CPU frequency (in kHz)
1292 * Get the CPU current (static) CPU frequency
1294 unsigned int cpufreq_get(unsigned int cpu)
1296 unsigned int ret_freq = 0;
1297 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1302 if (unlikely(lock_policy_rwsem_read(cpu)))
1305 ret_freq = __cpufreq_get(cpu);
1307 unlock_policy_rwsem_read(cpu);
1310 cpufreq_cpu_put(policy);
1314 EXPORT_SYMBOL(cpufreq_get);
1316 static struct subsys_interface cpufreq_interface = {
1318 .subsys = &cpu_subsys,
1319 .add_dev = cpufreq_add_dev,
1320 .remove_dev = cpufreq_remove_dev,
1325 * cpufreq_bp_suspend - Prepare the boot CPU for system suspend.
1327 * This function is only executed for the boot processor. The other CPUs
1328 * have been put offline by means of CPU hotplug.
1330 static int cpufreq_bp_suspend(void)
1334 int cpu = smp_processor_id();
1335 struct cpufreq_policy *cpu_policy;
1337 pr_debug("suspending cpu %u\n", cpu);
1339 /* If there's no policy for the boot CPU, we have nothing to do. */
1340 cpu_policy = cpufreq_cpu_get(cpu);
1344 if (cpufreq_driver->suspend) {
1345 ret = cpufreq_driver->suspend(cpu_policy);
1347 printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1348 "step on CPU %u\n", cpu_policy->cpu);
1351 cpufreq_cpu_put(cpu_policy);
1356 * cpufreq_bp_resume - Restore proper frequency handling of the boot CPU.
1358 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
1359 * 2.) schedule call cpufreq_update_policy() ASAP as interrupts are
1360 * restored. It will verify that the current freq is in sync with
1361 * what we believe it to be. This is a bit later than when it
1362 * should be, but nonethteless it's better than calling
1363 * cpufreq_driver->get() here which might re-enable interrupts...
1365 * This function is only executed for the boot CPU. The other CPUs have not
1366 * been turned on yet.
1368 static void cpufreq_bp_resume(void)
1372 int cpu = smp_processor_id();
1373 struct cpufreq_policy *cpu_policy;
1375 pr_debug("resuming cpu %u\n", cpu);
1377 /* If there's no policy for the boot CPU, we have nothing to do. */
1378 cpu_policy = cpufreq_cpu_get(cpu);
1382 if (cpufreq_driver->resume) {
1383 ret = cpufreq_driver->resume(cpu_policy);
1385 printk(KERN_ERR "cpufreq: resume failed in ->resume "
1386 "step on CPU %u\n", cpu_policy->cpu);
1391 schedule_work(&cpu_policy->update);
1394 cpufreq_cpu_put(cpu_policy);
1397 static struct syscore_ops cpufreq_syscore_ops = {
1398 .suspend = cpufreq_bp_suspend,
1399 .resume = cpufreq_bp_resume,
1403 * cpufreq_get_current_driver - return current driver's name
1405 * Return the name string of the currently loaded cpufreq driver
1408 const char *cpufreq_get_current_driver(void)
1411 return cpufreq_driver->name;
1415 EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
1417 /*********************************************************************
1418 * NOTIFIER LISTS INTERFACE *
1419 *********************************************************************/
1422 * cpufreq_register_notifier - register a driver with cpufreq
1423 * @nb: notifier function to register
1424 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1426 * Add a driver to one of two lists: either a list of drivers that
1427 * are notified about clock rate changes (once before and once after
1428 * the transition), or a list of drivers that are notified about
1429 * changes in cpufreq policy.
1431 * This function may sleep, and has the same return conditions as
1432 * blocking_notifier_chain_register.
1434 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1438 if (cpufreq_disabled())
1441 WARN_ON(!init_cpufreq_transition_notifier_list_called);
1444 case CPUFREQ_TRANSITION_NOTIFIER:
1445 ret = srcu_notifier_chain_register(
1446 &cpufreq_transition_notifier_list, nb);
1448 case CPUFREQ_POLICY_NOTIFIER:
1449 ret = blocking_notifier_chain_register(
1450 &cpufreq_policy_notifier_list, nb);
1458 EXPORT_SYMBOL(cpufreq_register_notifier);
1462 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1463 * @nb: notifier block to be unregistered
1464 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1466 * Remove a driver from the CPU frequency notifier list.
1468 * This function may sleep, and has the same return conditions as
1469 * blocking_notifier_chain_unregister.
1471 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1475 if (cpufreq_disabled())
1479 case CPUFREQ_TRANSITION_NOTIFIER:
1480 ret = srcu_notifier_chain_unregister(
1481 &cpufreq_transition_notifier_list, nb);
1483 case CPUFREQ_POLICY_NOTIFIER:
1484 ret = blocking_notifier_chain_unregister(
1485 &cpufreq_policy_notifier_list, nb);
1493 EXPORT_SYMBOL(cpufreq_unregister_notifier);
1496 /*********************************************************************
1498 *********************************************************************/
1501 int __cpufreq_driver_target(struct cpufreq_policy *policy,
1502 unsigned int target_freq,
1503 unsigned int relation)
1505 int retval = -EINVAL;
1506 unsigned int old_target_freq = target_freq;
1508 if (cpufreq_disabled())
1511 /* Make sure that target_freq is within supported range */
1512 if (target_freq > policy->max)
1513 target_freq = policy->max;
1514 if (target_freq < policy->min)
1515 target_freq = policy->min;
1517 pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
1518 policy->cpu, target_freq, relation, old_target_freq);
1520 if (target_freq == policy->cur)
1523 if (cpufreq_driver->target)
1524 retval = cpufreq_driver->target(policy, target_freq, relation);
1528 EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1530 int cpufreq_driver_target(struct cpufreq_policy *policy,
1531 unsigned int target_freq,
1532 unsigned int relation)
1536 policy = cpufreq_cpu_get(policy->cpu);
1540 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
1543 ret = __cpufreq_driver_target(policy, target_freq, relation);
1545 unlock_policy_rwsem_write(policy->cpu);
1548 cpufreq_cpu_put(policy);
1552 EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1554 int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
1558 if (cpufreq_disabled())
1561 if (!cpufreq_driver->getavg)
1564 policy = cpufreq_cpu_get(policy->cpu);
1568 ret = cpufreq_driver->getavg(policy, cpu);
1570 cpufreq_cpu_put(policy);
1573 EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
1576 * when "event" is CPUFREQ_GOV_LIMITS
1579 static int __cpufreq_governor(struct cpufreq_policy *policy,
1584 /* Only must be defined when default governor is known to have latency
1585 restrictions, like e.g. conservative or ondemand.
1586 That this is the case is already ensured in Kconfig
1588 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1589 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1591 struct cpufreq_governor *gov = NULL;
1594 if (policy->governor->max_transition_latency &&
1595 policy->cpuinfo.transition_latency >
1596 policy->governor->max_transition_latency) {
1600 printk(KERN_WARNING "%s governor failed, too long"
1601 " transition latency of HW, fallback"
1602 " to %s governor\n",
1603 policy->governor->name,
1605 policy->governor = gov;
1609 if (!try_module_get(policy->governor->owner))
1612 pr_debug("__cpufreq_governor for CPU %u, event %u\n",
1613 policy->cpu, event);
1614 ret = policy->governor->governor(policy, event);
1617 if (event == CPUFREQ_GOV_POLICY_INIT)
1618 policy->governor->initialized++;
1619 else if (event == CPUFREQ_GOV_POLICY_EXIT)
1620 policy->governor->initialized--;
1623 /* we keep one module reference alive for
1624 each CPU governed by this CPU */
1625 if ((event != CPUFREQ_GOV_START) || ret)
1626 module_put(policy->governor->owner);
1627 if ((event == CPUFREQ_GOV_STOP) && !ret)
1628 module_put(policy->governor->owner);
1634 int cpufreq_register_governor(struct cpufreq_governor *governor)
1641 if (cpufreq_disabled())
1644 mutex_lock(&cpufreq_governor_mutex);
1646 governor->initialized = 0;
1648 if (__find_governor(governor->name) == NULL) {
1650 list_add(&governor->governor_list, &cpufreq_governor_list);
1653 mutex_unlock(&cpufreq_governor_mutex);
1656 EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1659 void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1661 #ifdef CONFIG_HOTPLUG_CPU
1668 if (cpufreq_disabled())
1671 #ifdef CONFIG_HOTPLUG_CPU
1672 for_each_present_cpu(cpu) {
1673 if (cpu_online(cpu))
1675 if (!strcmp(per_cpu(cpufreq_cpu_governor, cpu), governor->name))
1676 strcpy(per_cpu(cpufreq_cpu_governor, cpu), "\0");
1680 mutex_lock(&cpufreq_governor_mutex);
1681 list_del(&governor->governor_list);
1682 mutex_unlock(&cpufreq_governor_mutex);
1685 EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1689 /*********************************************************************
1690 * POLICY INTERFACE *
1691 *********************************************************************/
1694 * cpufreq_get_policy - get the current cpufreq_policy
1695 * @policy: struct cpufreq_policy into which the current cpufreq_policy
1698 * Reads the current cpufreq policy.
1700 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1702 struct cpufreq_policy *cpu_policy;
1706 cpu_policy = cpufreq_cpu_get(cpu);
1710 memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
1712 cpufreq_cpu_put(cpu_policy);
1715 EXPORT_SYMBOL(cpufreq_get_policy);
1719 * data : current policy.
1720 * policy : policy to be set.
1722 static int __cpufreq_set_policy(struct cpufreq_policy *data,
1723 struct cpufreq_policy *policy)
1725 int ret = 0, failed = 1;
1727 pr_debug("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
1728 policy->min, policy->max);
1730 memcpy(&policy->cpuinfo, &data->cpuinfo,
1731 sizeof(struct cpufreq_cpuinfo));
1733 if (policy->min > data->max || policy->max < data->min) {
1738 /* verify the cpu speed can be set within this limit */
1739 ret = cpufreq_driver->verify(policy);
1743 /* adjust if necessary - all reasons */
1744 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1745 CPUFREQ_ADJUST, policy);
1747 /* adjust if necessary - hardware incompatibility*/
1748 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1749 CPUFREQ_INCOMPATIBLE, policy);
1751 /* verify the cpu speed can be set within this limit,
1752 which might be different to the first one */
1753 ret = cpufreq_driver->verify(policy);
1757 /* notification of the new policy */
1758 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1759 CPUFREQ_NOTIFY, policy);
1761 data->min = policy->min;
1762 data->max = policy->max;
1764 pr_debug("new min and max freqs are %u - %u kHz\n",
1765 data->min, data->max);
1767 if (cpufreq_driver->setpolicy) {
1768 data->policy = policy->policy;
1769 pr_debug("setting range\n");
1770 ret = cpufreq_driver->setpolicy(policy);
1772 if (policy->governor != data->governor) {
1773 /* save old, working values */
1774 struct cpufreq_governor *old_gov = data->governor;
1776 pr_debug("governor switch\n");
1778 /* end old governor */
1779 if (data->governor) {
1780 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1781 unlock_policy_rwsem_write(policy->cpu);
1782 __cpufreq_governor(data,
1783 CPUFREQ_GOV_POLICY_EXIT);
1784 lock_policy_rwsem_write(policy->cpu);
1787 /* start new governor */
1788 data->governor = policy->governor;
1789 if (!__cpufreq_governor(data, CPUFREQ_GOV_POLICY_INIT)) {
1790 if (!__cpufreq_governor(data, CPUFREQ_GOV_START)) {
1793 unlock_policy_rwsem_write(policy->cpu);
1794 __cpufreq_governor(data,
1795 CPUFREQ_GOV_POLICY_EXIT);
1796 lock_policy_rwsem_write(policy->cpu);
1801 /* new governor failed, so re-start old one */
1802 pr_debug("starting governor %s failed\n",
1803 data->governor->name);
1805 data->governor = old_gov;
1806 __cpufreq_governor(data,
1807 CPUFREQ_GOV_POLICY_INIT);
1808 __cpufreq_governor(data,
1814 /* might be a policy change, too, so fall through */
1816 pr_debug("governor: change or update limits\n");
1817 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1825 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1826 * @cpu: CPU which shall be re-evaluated
1828 * Useful for policy notifiers which have different necessities
1829 * at different times.
1831 int cpufreq_update_policy(unsigned int cpu)
1833 struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
1834 struct cpufreq_policy policy;
1842 if (unlikely(lock_policy_rwsem_write(cpu))) {
1847 pr_debug("updating policy for CPU %u\n", cpu);
1848 memcpy(&policy, data, sizeof(struct cpufreq_policy));
1849 policy.min = data->user_policy.min;
1850 policy.max = data->user_policy.max;
1851 policy.policy = data->user_policy.policy;
1852 policy.governor = data->user_policy.governor;
1854 /* BIOS might change freq behind our back
1855 -> ask driver for current freq and notify governors about a change */
1856 if (cpufreq_driver->get) {
1857 policy.cur = cpufreq_driver->get(cpu);
1859 pr_debug("Driver did not initialize current freq");
1860 data->cur = policy.cur;
1862 if (data->cur != policy.cur && cpufreq_driver->target)
1863 cpufreq_out_of_sync(cpu, data->cur,
1868 ret = __cpufreq_set_policy(data, &policy);
1870 unlock_policy_rwsem_write(cpu);
1873 cpufreq_cpu_put(data);
1877 EXPORT_SYMBOL(cpufreq_update_policy);
1879 static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
1880 unsigned long action, void *hcpu)
1882 unsigned int cpu = (unsigned long)hcpu;
1885 dev = get_cpu_device(cpu);
1889 case CPU_ONLINE_FROZEN:
1890 cpufreq_add_dev(dev, NULL);
1892 case CPU_DOWN_PREPARE:
1893 case CPU_DOWN_PREPARE_FROZEN:
1894 __cpufreq_remove_dev(dev, NULL);
1896 case CPU_DOWN_FAILED:
1897 case CPU_DOWN_FAILED_FROZEN:
1898 cpufreq_add_dev(dev, NULL);
1905 static struct notifier_block __refdata cpufreq_cpu_notifier = {
1906 .notifier_call = cpufreq_cpu_callback,
1909 /*********************************************************************
1910 * REGISTER / UNREGISTER CPUFREQ DRIVER *
1911 *********************************************************************/
1914 * cpufreq_register_driver - register a CPU Frequency driver
1915 * @driver_data: A struct cpufreq_driver containing the values#
1916 * submitted by the CPU Frequency driver.
1918 * Registers a CPU Frequency driver to this core code. This code
1919 * returns zero on success, -EBUSY when another driver got here first
1920 * (and isn't unregistered in the meantime).
1923 int cpufreq_register_driver(struct cpufreq_driver *driver_data)
1925 unsigned long flags;
1928 if (cpufreq_disabled())
1931 if (!driver_data || !driver_data->verify || !driver_data->init ||
1932 ((!driver_data->setpolicy) && (!driver_data->target)))
1935 pr_debug("trying to register driver %s\n", driver_data->name);
1937 if (driver_data->setpolicy)
1938 driver_data->flags |= CPUFREQ_CONST_LOOPS;
1940 write_lock_irqsave(&cpufreq_driver_lock, flags);
1941 if (cpufreq_driver) {
1942 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1945 cpufreq_driver = driver_data;
1946 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1948 ret = subsys_interface_register(&cpufreq_interface);
1950 goto err_null_driver;
1952 if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) {
1956 /* check for at least one working CPU */
1957 for (i = 0; i < nr_cpu_ids; i++)
1958 if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
1963 /* if all ->init() calls failed, unregister */
1965 pr_debug("no CPU initialized for driver %s\n",
1971 register_hotcpu_notifier(&cpufreq_cpu_notifier);
1972 pr_debug("driver %s up and running\n", driver_data->name);
1976 subsys_interface_unregister(&cpufreq_interface);
1978 write_lock_irqsave(&cpufreq_driver_lock, flags);
1979 cpufreq_driver = NULL;
1980 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1983 EXPORT_SYMBOL_GPL(cpufreq_register_driver);
1987 * cpufreq_unregister_driver - unregister the current CPUFreq driver
1989 * Unregister the current CPUFreq driver. Only call this if you have
1990 * the right to do so, i.e. if you have succeeded in initialising before!
1991 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
1992 * currently not initialised.
1994 int cpufreq_unregister_driver(struct cpufreq_driver *driver)
1996 unsigned long flags;
1998 if (!cpufreq_driver || (driver != cpufreq_driver))
2001 pr_debug("unregistering driver %s\n", driver->name);
2003 subsys_interface_unregister(&cpufreq_interface);
2004 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
2006 write_lock_irqsave(&cpufreq_driver_lock, flags);
2007 cpufreq_driver = NULL;
2008 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2012 EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
2014 static int __init cpufreq_core_init(void)
2018 if (cpufreq_disabled())
2021 for_each_possible_cpu(cpu) {
2022 per_cpu(cpufreq_policy_cpu, cpu) = -1;
2023 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
2026 cpufreq_global_kobject = kobject_create_and_add("cpufreq", &cpu_subsys.dev_root->kobj);
2027 BUG_ON(!cpufreq_global_kobject);
2028 register_syscore_ops(&cpufreq_syscore_ops);
2032 core_initcall(cpufreq_core_init);