1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
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>
37
38#include <trace/events/power.h>
39
40
41
42
43
44
45static struct cpufreq_driver *cpufreq_driver;
46static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
47static DEFINE_RWLOCK(cpufreq_driver_lock);
48static DEFINE_MUTEX(cpufreq_governor_lock);
49
50#ifdef CONFIG_HOTPLUG_CPU
51
52static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], cpufreq_cpu_governor);
53#endif
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72static DEFINE_PER_CPU(int, cpufreq_policy_cpu);
73static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
74
75#define lock_policy_rwsem(mode, cpu) \
76static int lock_policy_rwsem_##mode(int cpu) \
77{ \
78 int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu); \
79 BUG_ON(policy_cpu == -1); \
80 down_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
81 \
82 return 0; \
83}
84
85lock_policy_rwsem(read, cpu);
86lock_policy_rwsem(write, cpu);
87
88#define unlock_policy_rwsem(mode, cpu) \
89static void unlock_policy_rwsem_##mode(int cpu) \
90{ \
91 int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu); \
92 BUG_ON(policy_cpu == -1); \
93 up_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
94}
95
96unlock_policy_rwsem(read, cpu);
97unlock_policy_rwsem(write, cpu);
98
99
100static int __cpufreq_governor(struct cpufreq_policy *policy,
101 unsigned int event);
102static unsigned int __cpufreq_get(unsigned int cpu);
103static void handle_update(struct work_struct *work);
104
105
106
107
108
109
110
111
112static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
113static struct srcu_notifier_head cpufreq_transition_notifier_list;
114
115static bool init_cpufreq_transition_notifier_list_called;
116static int __init init_cpufreq_transition_notifier_list(void)
117{
118 srcu_init_notifier_head(&cpufreq_transition_notifier_list);
119 init_cpufreq_transition_notifier_list_called = true;
120 return 0;
121}
122pure_initcall(init_cpufreq_transition_notifier_list);
123
124static int off __read_mostly;
125static int cpufreq_disabled(void)
126{
127 return off;
128}
129void disable_cpufreq(void)
130{
131 off = 1;
132}
133static LIST_HEAD(cpufreq_governor_list);
134static DEFINE_MUTEX(cpufreq_governor_mutex);
135
136bool have_governor_per_policy(void)
137{
138 return cpufreq_driver->have_governor_per_policy;
139}
140EXPORT_SYMBOL_GPL(have_governor_per_policy);
141
142struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)
143{
144 if (have_governor_per_policy())
145 return &policy->kobj;
146 else
147 return cpufreq_global_kobject;
148}
149EXPORT_SYMBOL_GPL(get_governor_parent_kobj);
150
151static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
152{
153 u64 idle_time;
154 u64 cur_wall_time;
155 u64 busy_time;
156
157 cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
158
159 busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
160 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
161 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
162 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
163 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
164 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
165
166 idle_time = cur_wall_time - busy_time;
167 if (wall)
168 *wall = cputime_to_usecs(cur_wall_time);
169
170 return cputime_to_usecs(idle_time);
171}
172
173u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
174{
175 u64 idle_time = get_cpu_idle_time_us(cpu, io_busy ? wall : NULL);
176
177 if (idle_time == -1ULL)
178 return get_cpu_idle_time_jiffy(cpu, wall);
179 else if (!io_busy)
180 idle_time += get_cpu_iowait_time_us(cpu, wall);
181
182 return idle_time;
183}
184EXPORT_SYMBOL_GPL(get_cpu_idle_time);
185
186static struct cpufreq_policy *__cpufreq_cpu_get(unsigned int cpu, bool sysfs)
187{
188 struct cpufreq_policy *data;
189 unsigned long flags;
190
191 if (cpu >= nr_cpu_ids)
192 goto err_out;
193
194
195 read_lock_irqsave(&cpufreq_driver_lock, flags);
196
197 if (!cpufreq_driver)
198 goto err_out_unlock;
199
200 if (!try_module_get(cpufreq_driver->owner))
201 goto err_out_unlock;
202
203
204 data = per_cpu(cpufreq_cpu_data, cpu);
205
206 if (!data)
207 goto err_out_put_module;
208
209 if (!sysfs && !kobject_get(&data->kobj))
210 goto err_out_put_module;
211
212 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
213 return data;
214
215err_out_put_module:
216 module_put(cpufreq_driver->owner);
217err_out_unlock:
218 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
219err_out:
220 return NULL;
221}
222
223struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
224{
225 if (cpufreq_disabled())
226 return NULL;
227
228 return __cpufreq_cpu_get(cpu, false);
229}
230EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
231
232static struct cpufreq_policy *cpufreq_cpu_get_sysfs(unsigned int cpu)
233{
234 return __cpufreq_cpu_get(cpu, true);
235}
236
237static void __cpufreq_cpu_put(struct cpufreq_policy *data, bool sysfs)
238{
239 if (!sysfs)
240 kobject_put(&data->kobj);
241 module_put(cpufreq_driver->owner);
242}
243
244void cpufreq_cpu_put(struct cpufreq_policy *data)
245{
246 if (cpufreq_disabled())
247 return;
248
249 __cpufreq_cpu_put(data, false);
250}
251EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
252
253static void cpufreq_cpu_put_sysfs(struct cpufreq_policy *data)
254{
255 __cpufreq_cpu_put(data, true);
256}
257
258
259
260
261
262
263
264
265
266
267
268
269
270#ifndef CONFIG_SMP
271static unsigned long l_p_j_ref;
272static unsigned int l_p_j_ref_freq;
273
274static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
275{
276 if (ci->flags & CPUFREQ_CONST_LOOPS)
277 return;
278
279 if (!l_p_j_ref_freq) {
280 l_p_j_ref = loops_per_jiffy;
281 l_p_j_ref_freq = ci->old;
282 pr_debug("saving %lu as reference value for loops_per_jiffy; "
283 "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
284 }
285 if ((val == CPUFREQ_POSTCHANGE && ci->old != ci->new) ||
286 (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
287 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
288 ci->new);
289 pr_debug("scaling loops_per_jiffy to %lu "
290 "for frequency %u kHz\n", loops_per_jiffy, ci->new);
291 }
292}
293#else
294static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
295{
296 return;
297}
298#endif
299
300static void __cpufreq_notify_transition(struct cpufreq_policy *policy,
301 struct cpufreq_freqs *freqs, unsigned int state)
302{
303 BUG_ON(irqs_disabled());
304
305 if (cpufreq_disabled())
306 return;
307
308 freqs->flags = cpufreq_driver->flags;
309 pr_debug("notification %u of frequency transition to %u kHz\n",
310 state, freqs->new);
311
312 switch (state) {
313
314 case CPUFREQ_PRECHANGE:
315 if (WARN(policy->transition_ongoing ==
316 cpumask_weight(policy->cpus),
317 "In middle of another frequency transition\n"))
318 return;
319
320 policy->transition_ongoing++;
321
322
323
324
325
326 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
327 if ((policy) && (policy->cpu == freqs->cpu) &&
328 (policy->cur) && (policy->cur != freqs->old)) {
329 pr_debug("Warning: CPU frequency is"
330 " %u, cpufreq assumed %u kHz.\n",
331 freqs->old, policy->cur);
332 freqs->old = policy->cur;
333 }
334 }
335 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
336 CPUFREQ_PRECHANGE, freqs);
337 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
338 break;
339
340 case CPUFREQ_POSTCHANGE:
341 if (WARN(!policy->transition_ongoing,
342 "No frequency transition in progress\n"))
343 return;
344
345 policy->transition_ongoing--;
346
347 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
348 pr_debug("FREQ: %lu - CPU: %lu", (unsigned long)freqs->new,
349 (unsigned long)freqs->cpu);
350 trace_cpu_frequency(freqs->new, freqs->cpu);
351 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
352 CPUFREQ_POSTCHANGE, freqs);
353 if (likely(policy) && likely(policy->cpu == freqs->cpu))
354 policy->cur = freqs->new;
355 break;
356 }
357}
358
359
360
361
362
363
364
365
366
367void cpufreq_notify_transition(struct cpufreq_policy *policy,
368 struct cpufreq_freqs *freqs, unsigned int state)
369{
370 for_each_cpu(freqs->cpu, policy->cpus)
371 __cpufreq_notify_transition(policy, freqs, state);
372}
373EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
374
375
376
377
378
379
380static struct cpufreq_governor *__find_governor(const char *str_governor)
381{
382 struct cpufreq_governor *t;
383
384 list_for_each_entry(t, &cpufreq_governor_list, governor_list)
385 if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
386 return t;
387
388 return NULL;
389}
390
391
392
393
394static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
395 struct cpufreq_governor **governor)
396{
397 int err = -EINVAL;
398
399 if (!cpufreq_driver)
400 goto out;
401
402 if (cpufreq_driver->setpolicy) {
403 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
404 *policy = CPUFREQ_POLICY_PERFORMANCE;
405 err = 0;
406 } else if (!strnicmp(str_governor, "powersave",
407 CPUFREQ_NAME_LEN)) {
408 *policy = CPUFREQ_POLICY_POWERSAVE;
409 err = 0;
410 }
411 } else if (cpufreq_driver->target) {
412 struct cpufreq_governor *t;
413
414 mutex_lock(&cpufreq_governor_mutex);
415
416 t = __find_governor(str_governor);
417
418 if (t == NULL) {
419 int ret;
420
421 mutex_unlock(&cpufreq_governor_mutex);
422 ret = request_module("cpufreq_%s", str_governor);
423 mutex_lock(&cpufreq_governor_mutex);
424
425 if (ret == 0)
426 t = __find_governor(str_governor);
427 }
428
429 if (t != NULL) {
430 *governor = t;
431 err = 0;
432 }
433
434 mutex_unlock(&cpufreq_governor_mutex);
435 }
436out:
437 return err;
438}
439
440
441
442
443
444
445
446
447
448#define show_one(file_name, object) \
449static ssize_t show_##file_name \
450(struct cpufreq_policy *policy, char *buf) \
451{ \
452 return sprintf(buf, "%u\n", policy->object); \
453}
454
455show_one(cpuinfo_min_freq, cpuinfo.min_freq);
456show_one(cpuinfo_max_freq, cpuinfo.max_freq);
457show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
458show_one(scaling_min_freq, min);
459show_one(scaling_max_freq, max);
460show_one(scaling_cur_freq, cur);
461
462static int __cpufreq_set_policy(struct cpufreq_policy *data,
463 struct cpufreq_policy *policy);
464
465
466
467
468#define store_one(file_name, object) \
469static ssize_t store_##file_name \
470(struct cpufreq_policy *policy, const char *buf, size_t count) \
471{ \
472 unsigned int ret; \
473 struct cpufreq_policy new_policy; \
474 \
475 ret = cpufreq_get_policy(&new_policy, policy->cpu); \
476 if (ret) \
477 return -EINVAL; \
478 \
479 ret = sscanf(buf, "%u", &new_policy.object); \
480 if (ret != 1) \
481 return -EINVAL; \
482 \
483 ret = __cpufreq_set_policy(policy, &new_policy); \
484 policy->user_policy.object = policy->object; \
485 \
486 return ret ? ret : count; \
487}
488
489store_one(scaling_min_freq, min);
490store_one(scaling_max_freq, max);
491
492
493
494
495static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
496 char *buf)
497{
498 unsigned int cur_freq = __cpufreq_get(policy->cpu);
499 if (!cur_freq)
500 return sprintf(buf, "<unknown>");
501 return sprintf(buf, "%u\n", cur_freq);
502}
503
504
505
506
507static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
508{
509 if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
510 return sprintf(buf, "powersave\n");
511 else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
512 return sprintf(buf, "performance\n");
513 else if (policy->governor)
514 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
515 policy->governor->name);
516 return -EINVAL;
517}
518
519
520
521
522static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
523 const char *buf, size_t count)
524{
525 unsigned int ret;
526 char str_governor[16];
527 struct cpufreq_policy new_policy;
528
529 ret = cpufreq_get_policy(&new_policy, policy->cpu);
530 if (ret)
531 return ret;
532
533 ret = sscanf(buf, "%15s", str_governor);
534 if (ret != 1)
535 return -EINVAL;
536
537 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
538 &new_policy.governor))
539 return -EINVAL;
540
541
542
543
544
545 ret = __cpufreq_set_policy(policy, &new_policy);
546
547 policy->user_policy.policy = policy->policy;
548 policy->user_policy.governor = policy->governor;
549
550 if (ret)
551 return ret;
552 else
553 return count;
554}
555
556
557
558
559static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
560{
561 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
562}
563
564
565
566
567static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
568 char *buf)
569{
570 ssize_t i = 0;
571 struct cpufreq_governor *t;
572
573 if (!cpufreq_driver->target) {
574 i += sprintf(buf, "performance powersave");
575 goto out;
576 }
577
578 list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
579 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
580 - (CPUFREQ_NAME_LEN + 2)))
581 goto out;
582 i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
583 }
584out:
585 i += sprintf(&buf[i], "\n");
586 return i;
587}
588
589ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf)
590{
591 ssize_t i = 0;
592 unsigned int cpu;
593
594 for_each_cpu(cpu, mask) {
595 if (i)
596 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
597 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
598 if (i >= (PAGE_SIZE - 5))
599 break;
600 }
601 i += sprintf(&buf[i], "\n");
602 return i;
603}
604EXPORT_SYMBOL_GPL(cpufreq_show_cpus);
605
606
607
608
609
610static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
611{
612 return cpufreq_show_cpus(policy->related_cpus, buf);
613}
614
615
616
617
618static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
619{
620 return cpufreq_show_cpus(policy->cpus, buf);
621}
622
623static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
624 const char *buf, size_t count)
625{
626 unsigned int freq = 0;
627 unsigned int ret;
628
629 if (!policy->governor || !policy->governor->store_setspeed)
630 return -EINVAL;
631
632 ret = sscanf(buf, "%u", &freq);
633 if (ret != 1)
634 return -EINVAL;
635
636 policy->governor->store_setspeed(policy, freq);
637
638 return count;
639}
640
641static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
642{
643 if (!policy->governor || !policy->governor->show_setspeed)
644 return sprintf(buf, "<unsupported>\n");
645
646 return policy->governor->show_setspeed(policy, buf);
647}
648
649
650
651
652static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
653{
654 unsigned int limit;
655 int ret;
656 if (cpufreq_driver->bios_limit) {
657 ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
658 if (!ret)
659 return sprintf(buf, "%u\n", limit);
660 }
661 return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
662}
663
664cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
665cpufreq_freq_attr_ro(cpuinfo_min_freq);
666cpufreq_freq_attr_ro(cpuinfo_max_freq);
667cpufreq_freq_attr_ro(cpuinfo_transition_latency);
668cpufreq_freq_attr_ro(scaling_available_governors);
669cpufreq_freq_attr_ro(scaling_driver);
670cpufreq_freq_attr_ro(scaling_cur_freq);
671cpufreq_freq_attr_ro(bios_limit);
672cpufreq_freq_attr_ro(related_cpus);
673cpufreq_freq_attr_ro(affected_cpus);
674cpufreq_freq_attr_rw(scaling_min_freq);
675cpufreq_freq_attr_rw(scaling_max_freq);
676cpufreq_freq_attr_rw(scaling_governor);
677cpufreq_freq_attr_rw(scaling_setspeed);
678
679static struct attribute *default_attrs[] = {
680 &cpuinfo_min_freq.attr,
681 &cpuinfo_max_freq.attr,
682 &cpuinfo_transition_latency.attr,
683 &scaling_min_freq.attr,
684 &scaling_max_freq.attr,
685 &affected_cpus.attr,
686 &related_cpus.attr,
687 &scaling_governor.attr,
688 &scaling_driver.attr,
689 &scaling_available_governors.attr,
690 &scaling_setspeed.attr,
691 NULL
692};
693
694#define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
695#define to_attr(a) container_of(a, struct freq_attr, attr)
696
697static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
698{
699 struct cpufreq_policy *policy = to_policy(kobj);
700 struct freq_attr *fattr = to_attr(attr);
701 ssize_t ret = -EINVAL;
702 policy = cpufreq_cpu_get_sysfs(policy->cpu);
703 if (!policy)
704 goto no_policy;
705
706 if (lock_policy_rwsem_read(policy->cpu) < 0)
707 goto fail;
708
709 if (fattr->show)
710 ret = fattr->show(policy, buf);
711 else
712 ret = -EIO;
713
714 unlock_policy_rwsem_read(policy->cpu);
715fail:
716 cpufreq_cpu_put_sysfs(policy);
717no_policy:
718 return ret;
719}
720
721static ssize_t store(struct kobject *kobj, struct attribute *attr,
722 const char *buf, size_t count)
723{
724 struct cpufreq_policy *policy = to_policy(kobj);
725 struct freq_attr *fattr = to_attr(attr);
726 ssize_t ret = -EINVAL;
727 policy = cpufreq_cpu_get_sysfs(policy->cpu);
728 if (!policy)
729 goto no_policy;
730
731 if (lock_policy_rwsem_write(policy->cpu) < 0)
732 goto fail;
733
734 if (fattr->store)
735 ret = fattr->store(policy, buf, count);
736 else
737 ret = -EIO;
738
739 unlock_policy_rwsem_write(policy->cpu);
740fail:
741 cpufreq_cpu_put_sysfs(policy);
742no_policy:
743 return ret;
744}
745
746static void cpufreq_sysfs_release(struct kobject *kobj)
747{
748 struct cpufreq_policy *policy = to_policy(kobj);
749 pr_debug("last reference is dropped\n");
750 complete(&policy->kobj_unregister);
751}
752
753static const struct sysfs_ops sysfs_ops = {
754 .show = show,
755 .store = store,
756};
757
758static struct kobj_type ktype_cpufreq = {
759 .sysfs_ops = &sysfs_ops,
760 .default_attrs = default_attrs,
761 .release = cpufreq_sysfs_release,
762};
763
764struct kobject *cpufreq_global_kobject;
765EXPORT_SYMBOL(cpufreq_global_kobject);
766
767static int cpufreq_global_kobject_usage;
768
769int cpufreq_get_global_kobject(void)
770{
771 if (!cpufreq_global_kobject_usage++)
772 return kobject_add(cpufreq_global_kobject,
773 &cpu_subsys.dev_root->kobj, "%s", "cpufreq");
774
775 return 0;
776}
777EXPORT_SYMBOL(cpufreq_get_global_kobject);
778
779void cpufreq_put_global_kobject(void)
780{
781 if (!--cpufreq_global_kobject_usage)
782 kobject_del(cpufreq_global_kobject);
783}
784EXPORT_SYMBOL(cpufreq_put_global_kobject);
785
786int cpufreq_sysfs_create_file(const struct attribute *attr)
787{
788 int ret = cpufreq_get_global_kobject();
789
790 if (!ret) {
791 ret = sysfs_create_file(cpufreq_global_kobject, attr);
792 if (ret)
793 cpufreq_put_global_kobject();
794 }
795
796 return ret;
797}
798EXPORT_SYMBOL(cpufreq_sysfs_create_file);
799
800void cpufreq_sysfs_remove_file(const struct attribute *attr)
801{
802 sysfs_remove_file(cpufreq_global_kobject, attr);
803 cpufreq_put_global_kobject();
804}
805EXPORT_SYMBOL(cpufreq_sysfs_remove_file);
806
807
808static int cpufreq_add_dev_symlink(unsigned int cpu,
809 struct cpufreq_policy *policy)
810{
811 unsigned int j;
812 int ret = 0;
813
814 for_each_cpu(j, policy->cpus) {
815 struct cpufreq_policy *managed_policy;
816 struct device *cpu_dev;
817
818 if (j == cpu)
819 continue;
820
821 pr_debug("CPU %u already managed, adding link\n", j);
822 managed_policy = cpufreq_cpu_get(cpu);
823 cpu_dev = get_cpu_device(j);
824 ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
825 "cpufreq");
826 if (ret) {
827 cpufreq_cpu_put(managed_policy);
828 return ret;
829 }
830 }
831 return ret;
832}
833
834static int cpufreq_add_dev_interface(unsigned int cpu,
835 struct cpufreq_policy *policy,
836 struct device *dev)
837{
838 struct cpufreq_policy new_policy;
839 struct freq_attr **drv_attr;
840 unsigned long flags;
841 int ret = 0;
842 unsigned int j;
843
844
845 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
846 &dev->kobj, "cpufreq");
847 if (ret)
848 return ret;
849
850
851 drv_attr = cpufreq_driver->attr;
852 while ((drv_attr) && (*drv_attr)) {
853 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
854 if (ret)
855 goto err_out_kobj_put;
856 drv_attr++;
857 }
858 if (cpufreq_driver->get) {
859 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
860 if (ret)
861 goto err_out_kobj_put;
862 }
863 if (cpufreq_driver->target) {
864 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
865 if (ret)
866 goto err_out_kobj_put;
867 }
868 if (cpufreq_driver->bios_limit) {
869 ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
870 if (ret)
871 goto err_out_kobj_put;
872 }
873
874 write_lock_irqsave(&cpufreq_driver_lock, flags);
875 for_each_cpu(j, policy->cpus) {
876 per_cpu(cpufreq_cpu_data, j) = policy;
877 per_cpu(cpufreq_policy_cpu, j) = policy->cpu;
878 }
879 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
880
881 ret = cpufreq_add_dev_symlink(cpu, policy);
882 if (ret)
883 goto err_out_kobj_put;
884
885 memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
886
887 policy->governor = NULL;
888
889
890 ret = __cpufreq_set_policy(policy, &new_policy);
891 policy->user_policy.policy = policy->policy;
892 policy->user_policy.governor = policy->governor;
893
894 if (ret) {
895 pr_debug("setting policy failed\n");
896 if (cpufreq_driver->exit)
897 cpufreq_driver->exit(policy);
898 }
899 return ret;
900
901err_out_kobj_put:
902 kobject_put(&policy->kobj);
903 wait_for_completion(&policy->kobj_unregister);
904 return ret;
905}
906
907#ifdef CONFIG_HOTPLUG_CPU
908static int cpufreq_add_policy_cpu(unsigned int cpu, unsigned int sibling,
909 struct device *dev)
910{
911 struct cpufreq_policy *policy;
912 int ret = 0, has_target = !!cpufreq_driver->target;
913 unsigned long flags;
914
915 policy = cpufreq_cpu_get(sibling);
916 WARN_ON(!policy);
917
918 if (has_target)
919 __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
920
921 lock_policy_rwsem_write(sibling);
922
923 write_lock_irqsave(&cpufreq_driver_lock, flags);
924
925 cpumask_set_cpu(cpu, policy->cpus);
926 per_cpu(cpufreq_policy_cpu, cpu) = policy->cpu;
927 per_cpu(cpufreq_cpu_data, cpu) = policy;
928 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
929
930 unlock_policy_rwsem_write(sibling);
931
932 if (has_target) {
933 __cpufreq_governor(policy, CPUFREQ_GOV_START);
934 __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
935 }
936
937 ret = sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
938 if (ret) {
939 cpufreq_cpu_put(policy);
940 return ret;
941 }
942
943 return 0;
944}
945#endif
946
947
948
949
950
951
952
953
954
955
956static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
957{
958 unsigned int j, cpu = dev->id;
959 int ret = -ENOMEM;
960 struct cpufreq_policy *policy;
961 unsigned long flags;
962#ifdef CONFIG_HOTPLUG_CPU
963 struct cpufreq_governor *gov;
964 int sibling;
965#endif
966
967 if (cpu_is_offline(cpu))
968 return 0;
969
970 pr_debug("adding CPU %u\n", cpu);
971
972#ifdef CONFIG_SMP
973
974
975 policy = cpufreq_cpu_get(cpu);
976 if (unlikely(policy)) {
977 cpufreq_cpu_put(policy);
978 return 0;
979 }
980
981#ifdef CONFIG_HOTPLUG_CPU
982
983 read_lock_irqsave(&cpufreq_driver_lock, flags);
984 for_each_online_cpu(sibling) {
985 struct cpufreq_policy *cp = per_cpu(cpufreq_cpu_data, sibling);
986 if (cp && cpumask_test_cpu(cpu, cp->related_cpus)) {
987 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
988 return cpufreq_add_policy_cpu(cpu, sibling, dev);
989 }
990 }
991 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
992#endif
993#endif
994
995 if (!try_module_get(cpufreq_driver->owner)) {
996 ret = -EINVAL;
997 goto module_out;
998 }
999
1000 policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
1001 if (!policy)
1002 goto nomem_out;
1003
1004 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
1005 goto err_free_policy;
1006
1007 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
1008 goto err_free_cpumask;
1009
1010 policy->cpu = cpu;
1011 policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
1012 cpumask_copy(policy->cpus, cpumask_of(cpu));
1013
1014
1015 per_cpu(cpufreq_policy_cpu, cpu) = cpu;
1016
1017 init_completion(&policy->kobj_unregister);
1018 INIT_WORK(&policy->update, handle_update);
1019
1020
1021
1022
1023 ret = cpufreq_driver->init(policy);
1024 if (ret) {
1025 pr_debug("initialization failed\n");
1026 goto err_set_policy_cpu;
1027 }
1028
1029
1030 cpumask_or(policy->related_cpus, policy->related_cpus, policy->cpus);
1031
1032
1033
1034
1035
1036 cpumask_and(policy->cpus, policy->cpus, cpu_online_mask);
1037
1038 policy->user_policy.min = policy->min;
1039 policy->user_policy.max = policy->max;
1040
1041 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1042 CPUFREQ_START, policy);
1043
1044#ifdef CONFIG_HOTPLUG_CPU
1045 gov = __find_governor(per_cpu(cpufreq_cpu_governor, cpu));
1046 if (gov) {
1047 policy->governor = gov;
1048 pr_debug("Restoring governor %s for cpu %d\n",
1049 policy->governor->name, cpu);
1050 }
1051#endif
1052
1053 ret = cpufreq_add_dev_interface(cpu, policy, dev);
1054 if (ret)
1055 goto err_out_unregister;
1056
1057 kobject_uevent(&policy->kobj, KOBJ_ADD);
1058 module_put(cpufreq_driver->owner);
1059 pr_debug("initialization complete\n");
1060
1061 return 0;
1062
1063err_out_unregister:
1064 write_lock_irqsave(&cpufreq_driver_lock, flags);
1065 for_each_cpu(j, policy->cpus)
1066 per_cpu(cpufreq_cpu_data, j) = NULL;
1067 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1068
1069 kobject_put(&policy->kobj);
1070 wait_for_completion(&policy->kobj_unregister);
1071
1072err_set_policy_cpu:
1073 per_cpu(cpufreq_policy_cpu, cpu) = -1;
1074 free_cpumask_var(policy->related_cpus);
1075err_free_cpumask:
1076 free_cpumask_var(policy->cpus);
1077err_free_policy:
1078 kfree(policy);
1079nomem_out:
1080 module_put(cpufreq_driver->owner);
1081module_out:
1082 return ret;
1083}
1084
1085static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
1086{
1087 int j;
1088
1089 policy->last_cpu = policy->cpu;
1090 policy->cpu = cpu;
1091
1092 for_each_cpu(j, policy->cpus)
1093 per_cpu(cpufreq_policy_cpu, j) = cpu;
1094
1095#ifdef CONFIG_CPU_FREQ_TABLE
1096 cpufreq_frequency_table_update_policy_cpu(policy);
1097#endif
1098 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1099 CPUFREQ_UPDATE_POLICY_CPU, policy);
1100}
1101
1102
1103
1104
1105
1106
1107
1108
1109static int __cpufreq_remove_dev(struct device *dev,
1110 struct subsys_interface *sif)
1111{
1112 unsigned int cpu = dev->id, ret, cpus;
1113 unsigned long flags;
1114 struct cpufreq_policy *data;
1115 struct kobject *kobj;
1116 struct completion *cmp;
1117 struct device *cpu_dev;
1118
1119 pr_debug("%s: unregistering CPU %u\n", __func__, cpu);
1120
1121 write_lock_irqsave(&cpufreq_driver_lock, flags);
1122
1123 data = per_cpu(cpufreq_cpu_data, cpu);
1124 per_cpu(cpufreq_cpu_data, cpu) = NULL;
1125
1126 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1127
1128 if (!data) {
1129 pr_debug("%s: No cpu_data found\n", __func__);
1130 return -EINVAL;
1131 }
1132
1133 if (cpufreq_driver->target)
1134 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1135
1136#ifdef CONFIG_HOTPLUG_CPU
1137 if (!cpufreq_driver->setpolicy)
1138 strncpy(per_cpu(cpufreq_cpu_governor, cpu),
1139 data->governor->name, CPUFREQ_NAME_LEN);
1140#endif
1141
1142 WARN_ON(lock_policy_rwsem_write(cpu));
1143 cpus = cpumask_weight(data->cpus);
1144
1145 if (cpus > 1)
1146 cpumask_clear_cpu(cpu, data->cpus);
1147 unlock_policy_rwsem_write(cpu);
1148
1149 if (cpu != data->cpu) {
1150 sysfs_remove_link(&dev->kobj, "cpufreq");
1151 } else if (cpus > 1) {
1152
1153 cpu_dev = get_cpu_device(cpumask_first(data->cpus));
1154 sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
1155 ret = kobject_move(&data->kobj, &cpu_dev->kobj);
1156 if (ret) {
1157 pr_err("%s: Failed to move kobj: %d", __func__, ret);
1158
1159 WARN_ON(lock_policy_rwsem_write(cpu));
1160 cpumask_set_cpu(cpu, data->cpus);
1161
1162 write_lock_irqsave(&cpufreq_driver_lock, flags);
1163 per_cpu(cpufreq_cpu_data, cpu) = data;
1164 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1165
1166 unlock_policy_rwsem_write(cpu);
1167
1168 ret = sysfs_create_link(&cpu_dev->kobj, &data->kobj,
1169 "cpufreq");
1170 return -EINVAL;
1171 }
1172
1173 WARN_ON(lock_policy_rwsem_write(cpu));
1174 update_policy_cpu(data, cpu_dev->id);
1175 unlock_policy_rwsem_write(cpu);
1176 pr_debug("%s: policy Kobject moved to cpu: %d from: %d\n",
1177 __func__, cpu_dev->id, cpu);
1178 }
1179
1180
1181 if (cpus == 1) {
1182 if (cpufreq_driver->target)
1183 __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
1184
1185 lock_policy_rwsem_read(cpu);
1186 kobj = &data->kobj;
1187 cmp = &data->kobj_unregister;
1188 unlock_policy_rwsem_read(cpu);
1189 kobject_put(kobj);
1190
1191
1192
1193
1194
1195 pr_debug("waiting for dropping of refcount\n");
1196 wait_for_completion(cmp);
1197 pr_debug("wait complete\n");
1198
1199 if (cpufreq_driver->exit)
1200 cpufreq_driver->exit(data);
1201
1202 free_cpumask_var(data->related_cpus);
1203 free_cpumask_var(data->cpus);
1204 kfree(data);
1205 } else {
1206 pr_debug("%s: removing link, cpu: %d\n", __func__, cpu);
1207 cpufreq_cpu_put(data);
1208 if (cpufreq_driver->target) {
1209 __cpufreq_governor(data, CPUFREQ_GOV_START);
1210 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1211 }
1212 }
1213
1214 per_cpu(cpufreq_policy_cpu, cpu) = -1;
1215 return 0;
1216}
1217
1218static int cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
1219{
1220 unsigned int cpu = dev->id;
1221 int retval;
1222
1223 if (cpu_is_offline(cpu))
1224 return 0;
1225
1226 retval = __cpufreq_remove_dev(dev, sif);
1227 return retval;
1228}
1229
1230static void handle_update(struct work_struct *work)
1231{
1232 struct cpufreq_policy *policy =
1233 container_of(work, struct cpufreq_policy, update);
1234 unsigned int cpu = policy->cpu;
1235 pr_debug("handle_update for cpu %u called\n", cpu);
1236 cpufreq_update_policy(cpu);
1237}
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1250 unsigned int new_freq)
1251{
1252 struct cpufreq_policy *policy;
1253 struct cpufreq_freqs freqs;
1254 unsigned long flags;
1255
1256 pr_debug("Warning: CPU frequency out of sync: cpufreq and timing "
1257 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1258
1259 freqs.old = old_freq;
1260 freqs.new = new_freq;
1261
1262 read_lock_irqsave(&cpufreq_driver_lock, flags);
1263 policy = per_cpu(cpufreq_cpu_data, cpu);
1264 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1265
1266 cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
1267 cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
1268}
1269
1270
1271
1272
1273
1274
1275
1276
1277unsigned int cpufreq_quick_get(unsigned int cpu)
1278{
1279 struct cpufreq_policy *policy;
1280 unsigned int ret_freq = 0;
1281
1282 if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
1283 return cpufreq_driver->get(cpu);
1284
1285 policy = cpufreq_cpu_get(cpu);
1286 if (policy) {
1287 ret_freq = policy->cur;
1288 cpufreq_cpu_put(policy);
1289 }
1290
1291 return ret_freq;
1292}
1293EXPORT_SYMBOL(cpufreq_quick_get);
1294
1295
1296
1297
1298
1299
1300
1301unsigned int cpufreq_quick_get_max(unsigned int cpu)
1302{
1303 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1304 unsigned int ret_freq = 0;
1305
1306 if (policy) {
1307 ret_freq = policy->max;
1308 cpufreq_cpu_put(policy);
1309 }
1310
1311 return ret_freq;
1312}
1313EXPORT_SYMBOL(cpufreq_quick_get_max);
1314
1315static unsigned int __cpufreq_get(unsigned int cpu)
1316{
1317 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1318 unsigned int ret_freq = 0;
1319
1320 if (!cpufreq_driver->get)
1321 return ret_freq;
1322
1323 ret_freq = cpufreq_driver->get(cpu);
1324
1325 if (ret_freq && policy->cur &&
1326 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1327
1328
1329 if (unlikely(ret_freq != policy->cur)) {
1330 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
1331 schedule_work(&policy->update);
1332 }
1333 }
1334
1335 return ret_freq;
1336}
1337
1338
1339
1340
1341
1342
1343
1344unsigned int cpufreq_get(unsigned int cpu)
1345{
1346 unsigned int ret_freq = 0;
1347 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1348
1349 if (!policy)
1350 goto out;
1351
1352 if (unlikely(lock_policy_rwsem_read(cpu)))
1353 goto out_policy;
1354
1355 ret_freq = __cpufreq_get(cpu);
1356
1357 unlock_policy_rwsem_read(cpu);
1358
1359out_policy:
1360 cpufreq_cpu_put(policy);
1361out:
1362 return ret_freq;
1363}
1364EXPORT_SYMBOL(cpufreq_get);
1365
1366static struct subsys_interface cpufreq_interface = {
1367 .name = "cpufreq",
1368 .subsys = &cpu_subsys,
1369 .add_dev = cpufreq_add_dev,
1370 .remove_dev = cpufreq_remove_dev,
1371};
1372
1373
1374
1375
1376
1377
1378
1379static int cpufreq_bp_suspend(void)
1380{
1381 int ret = 0;
1382
1383 int cpu = smp_processor_id();
1384 struct cpufreq_policy *cpu_policy;
1385
1386 pr_debug("suspending cpu %u\n", cpu);
1387
1388
1389 cpu_policy = cpufreq_cpu_get(cpu);
1390 if (!cpu_policy)
1391 return 0;
1392
1393 if (cpufreq_driver->suspend) {
1394 ret = cpufreq_driver->suspend(cpu_policy);
1395 if (ret)
1396 printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1397 "step on CPU %u\n", cpu_policy->cpu);
1398 }
1399
1400 cpufreq_cpu_put(cpu_policy);
1401 return ret;
1402}
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417static void cpufreq_bp_resume(void)
1418{
1419 int ret = 0;
1420
1421 int cpu = smp_processor_id();
1422 struct cpufreq_policy *cpu_policy;
1423
1424 pr_debug("resuming cpu %u\n", cpu);
1425
1426
1427 cpu_policy = cpufreq_cpu_get(cpu);
1428 if (!cpu_policy)
1429 return;
1430
1431 if (cpufreq_driver->resume) {
1432 ret = cpufreq_driver->resume(cpu_policy);
1433 if (ret) {
1434 printk(KERN_ERR "cpufreq: resume failed in ->resume "
1435 "step on CPU %u\n", cpu_policy->cpu);
1436 goto fail;
1437 }
1438 }
1439
1440 schedule_work(&cpu_policy->update);
1441
1442fail:
1443 cpufreq_cpu_put(cpu_policy);
1444}
1445
1446static struct syscore_ops cpufreq_syscore_ops = {
1447 .suspend = cpufreq_bp_suspend,
1448 .resume = cpufreq_bp_resume,
1449};
1450
1451
1452
1453
1454
1455
1456
1457const char *cpufreq_get_current_driver(void)
1458{
1459 if (cpufreq_driver)
1460 return cpufreq_driver->name;
1461
1462 return NULL;
1463}
1464EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1484{
1485 int ret;
1486
1487 if (cpufreq_disabled())
1488 return -EINVAL;
1489
1490 WARN_ON(!init_cpufreq_transition_notifier_list_called);
1491
1492 switch (list) {
1493 case CPUFREQ_TRANSITION_NOTIFIER:
1494 ret = srcu_notifier_chain_register(
1495 &cpufreq_transition_notifier_list, nb);
1496 break;
1497 case CPUFREQ_POLICY_NOTIFIER:
1498 ret = blocking_notifier_chain_register(
1499 &cpufreq_policy_notifier_list, nb);
1500 break;
1501 default:
1502 ret = -EINVAL;
1503 }
1504
1505 return ret;
1506}
1507EXPORT_SYMBOL(cpufreq_register_notifier);
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1520{
1521 int ret;
1522
1523 if (cpufreq_disabled())
1524 return -EINVAL;
1525
1526 switch (list) {
1527 case CPUFREQ_TRANSITION_NOTIFIER:
1528 ret = srcu_notifier_chain_unregister(
1529 &cpufreq_transition_notifier_list, nb);
1530 break;
1531 case CPUFREQ_POLICY_NOTIFIER:
1532 ret = blocking_notifier_chain_unregister(
1533 &cpufreq_policy_notifier_list, nb);
1534 break;
1535 default:
1536 ret = -EINVAL;
1537 }
1538
1539 return ret;
1540}
1541EXPORT_SYMBOL(cpufreq_unregister_notifier);
1542
1543
1544
1545
1546
1547
1548int __cpufreq_driver_target(struct cpufreq_policy *policy,
1549 unsigned int target_freq,
1550 unsigned int relation)
1551{
1552 int retval = -EINVAL;
1553 unsigned int old_target_freq = target_freq;
1554
1555 if (cpufreq_disabled())
1556 return -ENODEV;
1557 if (policy->transition_ongoing)
1558 return -EBUSY;
1559
1560
1561 if (target_freq > policy->max)
1562 target_freq = policy->max;
1563 if (target_freq < policy->min)
1564 target_freq = policy->min;
1565
1566 pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
1567 policy->cpu, target_freq, relation, old_target_freq);
1568
1569 if (target_freq == policy->cur)
1570 return 0;
1571
1572 if (cpufreq_driver->target)
1573 retval = cpufreq_driver->target(policy, target_freq, relation);
1574
1575 return retval;
1576}
1577EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1578
1579int cpufreq_driver_target(struct cpufreq_policy *policy,
1580 unsigned int target_freq,
1581 unsigned int relation)
1582{
1583 int ret = -EINVAL;
1584
1585 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
1586 goto fail;
1587
1588 ret = __cpufreq_driver_target(policy, target_freq, relation);
1589
1590 unlock_policy_rwsem_write(policy->cpu);
1591
1592fail:
1593 return ret;
1594}
1595EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1596
1597int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
1598{
1599 if (cpufreq_disabled())
1600 return 0;
1601
1602 if (!cpufreq_driver->getavg)
1603 return 0;
1604
1605 return cpufreq_driver->getavg(policy, cpu);
1606}
1607EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
1608
1609
1610
1611
1612
1613static int __cpufreq_governor(struct cpufreq_policy *policy,
1614 unsigned int event)
1615{
1616 int ret;
1617
1618
1619
1620
1621
1622#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1623 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1624#else
1625 struct cpufreq_governor *gov = NULL;
1626#endif
1627
1628 if (policy->governor->max_transition_latency &&
1629 policy->cpuinfo.transition_latency >
1630 policy->governor->max_transition_latency) {
1631 if (!gov)
1632 return -EINVAL;
1633 else {
1634 printk(KERN_WARNING "%s governor failed, too long"
1635 " transition latency of HW, fallback"
1636 " to %s governor\n",
1637 policy->governor->name,
1638 gov->name);
1639 policy->governor = gov;
1640 }
1641 }
1642
1643 if (!try_module_get(policy->governor->owner))
1644 return -EINVAL;
1645
1646 pr_debug("__cpufreq_governor for CPU %u, event %u\n",
1647 policy->cpu, event);
1648
1649 mutex_lock(&cpufreq_governor_lock);
1650 if ((!policy->governor_enabled && (event == CPUFREQ_GOV_STOP)) ||
1651 (policy->governor_enabled && (event == CPUFREQ_GOV_START))) {
1652 mutex_unlock(&cpufreq_governor_lock);
1653 return -EBUSY;
1654 }
1655
1656 if (event == CPUFREQ_GOV_STOP)
1657 policy->governor_enabled = false;
1658 else if (event == CPUFREQ_GOV_START)
1659 policy->governor_enabled = true;
1660
1661 mutex_unlock(&cpufreq_governor_lock);
1662
1663 ret = policy->governor->governor(policy, event);
1664
1665 if (!ret) {
1666 if (event == CPUFREQ_GOV_POLICY_INIT)
1667 policy->governor->initialized++;
1668 else if (event == CPUFREQ_GOV_POLICY_EXIT)
1669 policy->governor->initialized--;
1670 } else {
1671
1672 mutex_lock(&cpufreq_governor_lock);
1673 if (event == CPUFREQ_GOV_STOP)
1674 policy->governor_enabled = true;
1675 else if (event == CPUFREQ_GOV_START)
1676 policy->governor_enabled = false;
1677 mutex_unlock(&cpufreq_governor_lock);
1678 }
1679
1680
1681
1682 if ((event != CPUFREQ_GOV_START) || ret)
1683 module_put(policy->governor->owner);
1684 if ((event == CPUFREQ_GOV_STOP) && !ret)
1685 module_put(policy->governor->owner);
1686
1687 return ret;
1688}
1689
1690int cpufreq_register_governor(struct cpufreq_governor *governor)
1691{
1692 int err;
1693
1694 if (!governor)
1695 return -EINVAL;
1696
1697 if (cpufreq_disabled())
1698 return -ENODEV;
1699
1700 mutex_lock(&cpufreq_governor_mutex);
1701
1702 governor->initialized = 0;
1703 err = -EBUSY;
1704 if (__find_governor(governor->name) == NULL) {
1705 err = 0;
1706 list_add(&governor->governor_list, &cpufreq_governor_list);
1707 }
1708
1709 mutex_unlock(&cpufreq_governor_mutex);
1710 return err;
1711}
1712EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1713
1714void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1715{
1716#ifdef CONFIG_HOTPLUG_CPU
1717 int cpu;
1718#endif
1719
1720 if (!governor)
1721 return;
1722
1723 if (cpufreq_disabled())
1724 return;
1725
1726#ifdef CONFIG_HOTPLUG_CPU
1727 for_each_present_cpu(cpu) {
1728 if (cpu_online(cpu))
1729 continue;
1730 if (!strcmp(per_cpu(cpufreq_cpu_governor, cpu), governor->name))
1731 strcpy(per_cpu(cpufreq_cpu_governor, cpu), "\0");
1732 }
1733#endif
1734
1735 mutex_lock(&cpufreq_governor_mutex);
1736 list_del(&governor->governor_list);
1737 mutex_unlock(&cpufreq_governor_mutex);
1738 return;
1739}
1740EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1755{
1756 struct cpufreq_policy *cpu_policy;
1757 if (!policy)
1758 return -EINVAL;
1759
1760 cpu_policy = cpufreq_cpu_get(cpu);
1761 if (!cpu_policy)
1762 return -EINVAL;
1763
1764 memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
1765
1766 cpufreq_cpu_put(cpu_policy);
1767 return 0;
1768}
1769EXPORT_SYMBOL(cpufreq_get_policy);
1770
1771
1772
1773
1774
1775static int __cpufreq_set_policy(struct cpufreq_policy *data,
1776 struct cpufreq_policy *policy)
1777{
1778 int ret = 0, failed = 1;
1779
1780 pr_debug("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
1781 policy->min, policy->max);
1782
1783 memcpy(&policy->cpuinfo, &data->cpuinfo,
1784 sizeof(struct cpufreq_cpuinfo));
1785
1786 if (policy->min > data->max || policy->max < data->min) {
1787 ret = -EINVAL;
1788 goto error_out;
1789 }
1790
1791
1792 ret = cpufreq_driver->verify(policy);
1793 if (ret)
1794 goto error_out;
1795
1796
1797 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1798 CPUFREQ_ADJUST, policy);
1799
1800
1801 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1802 CPUFREQ_INCOMPATIBLE, policy);
1803
1804
1805
1806
1807
1808 ret = cpufreq_driver->verify(policy);
1809 if (ret)
1810 goto error_out;
1811
1812
1813 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1814 CPUFREQ_NOTIFY, policy);
1815
1816 data->min = policy->min;
1817 data->max = policy->max;
1818
1819 pr_debug("new min and max freqs are %u - %u kHz\n",
1820 data->min, data->max);
1821
1822 if (cpufreq_driver->setpolicy) {
1823 data->policy = policy->policy;
1824 pr_debug("setting range\n");
1825 ret = cpufreq_driver->setpolicy(policy);
1826 } else {
1827 if (policy->governor != data->governor) {
1828
1829 struct cpufreq_governor *old_gov = data->governor;
1830
1831 pr_debug("governor switch\n");
1832
1833
1834 if (data->governor) {
1835 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1836 unlock_policy_rwsem_write(policy->cpu);
1837 __cpufreq_governor(data,
1838 CPUFREQ_GOV_POLICY_EXIT);
1839 lock_policy_rwsem_write(policy->cpu);
1840 }
1841
1842
1843 data->governor = policy->governor;
1844 if (!__cpufreq_governor(data, CPUFREQ_GOV_POLICY_INIT)) {
1845 if (!__cpufreq_governor(data, CPUFREQ_GOV_START)) {
1846 failed = 0;
1847 } else {
1848 unlock_policy_rwsem_write(policy->cpu);
1849 __cpufreq_governor(data,
1850 CPUFREQ_GOV_POLICY_EXIT);
1851 lock_policy_rwsem_write(policy->cpu);
1852 }
1853 }
1854
1855 if (failed) {
1856
1857 pr_debug("starting governor %s failed\n",
1858 data->governor->name);
1859 if (old_gov) {
1860 data->governor = old_gov;
1861 __cpufreq_governor(data,
1862 CPUFREQ_GOV_POLICY_INIT);
1863 __cpufreq_governor(data,
1864 CPUFREQ_GOV_START);
1865 }
1866 ret = -EINVAL;
1867 goto error_out;
1868 }
1869
1870 }
1871 pr_debug("governor: change or update limits\n");
1872 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1873 }
1874
1875error_out:
1876 return ret;
1877}
1878
1879
1880
1881
1882
1883
1884
1885
1886int cpufreq_update_policy(unsigned int cpu)
1887{
1888 struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
1889 struct cpufreq_policy policy;
1890 int ret;
1891
1892 if (!data) {
1893 ret = -ENODEV;
1894 goto no_policy;
1895 }
1896
1897 if (unlikely(lock_policy_rwsem_write(cpu))) {
1898 ret = -EINVAL;
1899 goto fail;
1900 }
1901
1902 pr_debug("updating policy for CPU %u\n", cpu);
1903 memcpy(&policy, data, sizeof(struct cpufreq_policy));
1904 policy.min = data->user_policy.min;
1905 policy.max = data->user_policy.max;
1906 policy.policy = data->user_policy.policy;
1907 policy.governor = data->user_policy.governor;
1908
1909
1910
1911
1912
1913 if (cpufreq_driver->get) {
1914 policy.cur = cpufreq_driver->get(cpu);
1915 if (!data->cur) {
1916 pr_debug("Driver did not initialize current freq");
1917 data->cur = policy.cur;
1918 } else {
1919 if (data->cur != policy.cur && cpufreq_driver->target)
1920 cpufreq_out_of_sync(cpu, data->cur,
1921 policy.cur);
1922 }
1923 }
1924
1925 ret = __cpufreq_set_policy(data, &policy);
1926
1927 unlock_policy_rwsem_write(cpu);
1928
1929fail:
1930 cpufreq_cpu_put(data);
1931no_policy:
1932 return ret;
1933}
1934EXPORT_SYMBOL(cpufreq_update_policy);
1935
1936static int cpufreq_cpu_callback(struct notifier_block *nfb,
1937 unsigned long action, void *hcpu)
1938{
1939 unsigned int cpu = (unsigned long)hcpu;
1940 struct device *dev;
1941
1942 dev = get_cpu_device(cpu);
1943 if (dev) {
1944 switch (action) {
1945 case CPU_ONLINE:
1946 case CPU_ONLINE_FROZEN:
1947 cpufreq_add_dev(dev, NULL);
1948 break;
1949 case CPU_DOWN_PREPARE:
1950 case CPU_DOWN_PREPARE_FROZEN:
1951 __cpufreq_remove_dev(dev, NULL);
1952 break;
1953 case CPU_DOWN_FAILED:
1954 case CPU_DOWN_FAILED_FROZEN:
1955 cpufreq_add_dev(dev, NULL);
1956 break;
1957 }
1958 }
1959 return NOTIFY_OK;
1960}
1961
1962static struct notifier_block __refdata cpufreq_cpu_notifier = {
1963 .notifier_call = cpufreq_cpu_callback,
1964};
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980int cpufreq_register_driver(struct cpufreq_driver *driver_data)
1981{
1982 unsigned long flags;
1983 int ret;
1984
1985 if (cpufreq_disabled())
1986 return -ENODEV;
1987
1988 if (!driver_data || !driver_data->verify || !driver_data->init ||
1989 ((!driver_data->setpolicy) && (!driver_data->target)))
1990 return -EINVAL;
1991
1992 pr_debug("trying to register driver %s\n", driver_data->name);
1993
1994 if (driver_data->setpolicy)
1995 driver_data->flags |= CPUFREQ_CONST_LOOPS;
1996
1997 write_lock_irqsave(&cpufreq_driver_lock, flags);
1998 if (cpufreq_driver) {
1999 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2000 return -EBUSY;
2001 }
2002 cpufreq_driver = driver_data;
2003 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2004
2005 ret = subsys_interface_register(&cpufreq_interface);
2006 if (ret)
2007 goto err_null_driver;
2008
2009 if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) {
2010 int i;
2011 ret = -ENODEV;
2012
2013
2014 for (i = 0; i < nr_cpu_ids; i++)
2015 if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
2016 ret = 0;
2017 break;
2018 }
2019
2020
2021 if (ret) {
2022 pr_debug("no CPU initialized for driver %s\n",
2023 driver_data->name);
2024 goto err_if_unreg;
2025 }
2026 }
2027
2028 register_hotcpu_notifier(&cpufreq_cpu_notifier);
2029 pr_debug("driver %s up and running\n", driver_data->name);
2030
2031 return 0;
2032err_if_unreg:
2033 subsys_interface_unregister(&cpufreq_interface);
2034err_null_driver:
2035 write_lock_irqsave(&cpufreq_driver_lock, flags);
2036 cpufreq_driver = NULL;
2037 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2038 return ret;
2039}
2040EXPORT_SYMBOL_GPL(cpufreq_register_driver);
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050int cpufreq_unregister_driver(struct cpufreq_driver *driver)
2051{
2052 unsigned long flags;
2053
2054 if (!cpufreq_driver || (driver != cpufreq_driver))
2055 return -EINVAL;
2056
2057 pr_debug("unregistering driver %s\n", driver->name);
2058
2059 subsys_interface_unregister(&cpufreq_interface);
2060 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
2061
2062 write_lock_irqsave(&cpufreq_driver_lock, flags);
2063 cpufreq_driver = NULL;
2064 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2065
2066 return 0;
2067}
2068EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
2069
2070static int __init cpufreq_core_init(void)
2071{
2072 int cpu;
2073
2074 if (cpufreq_disabled())
2075 return -ENODEV;
2076
2077 for_each_possible_cpu(cpu) {
2078 per_cpu(cpufreq_policy_cpu, cpu) = -1;
2079 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
2080 }
2081
2082 cpufreq_global_kobject = kobject_create();
2083 BUG_ON(!cpufreq_global_kobject);
2084 register_syscore_ops(&cpufreq_syscore_ops);
2085
2086 return 0;
2087}
2088core_initcall(cpufreq_core_init);
2089