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 <linux/cpu.h>
21#include <linux/cpufreq.h>
22#include <linux/delay.h>
23#include <linux/device.h>
24#include <linux/init.h>
25#include <linux/kernel_stat.h>
26#include <linux/module.h>
27#include <linux/mutex.h>
28#include <linux/slab.h>
29#include <linux/suspend.h>
30#include <linux/tick.h>
31#include <trace/events/power.h>
32
33
34
35
36
37
38static struct cpufreq_driver *cpufreq_driver;
39static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
40static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data_fallback);
41static DEFINE_RWLOCK(cpufreq_driver_lock);
42DEFINE_MUTEX(cpufreq_governor_lock);
43static LIST_HEAD(cpufreq_policy_list);
44
45
46static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], cpufreq_cpu_governor);
47
48
49static bool cpufreq_suspended;
50
51static inline bool has_target(void)
52{
53 return cpufreq_driver->target_index || cpufreq_driver->target;
54}
55
56
57
58
59
60static DECLARE_RWSEM(cpufreq_rwsem);
61
62
63static int __cpufreq_governor(struct cpufreq_policy *policy,
64 unsigned int event);
65static unsigned int __cpufreq_get(unsigned int cpu);
66static void handle_update(struct work_struct *work);
67
68
69
70
71
72
73
74
75static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
76static struct srcu_notifier_head cpufreq_transition_notifier_list;
77
78static bool init_cpufreq_transition_notifier_list_called;
79static int __init init_cpufreq_transition_notifier_list(void)
80{
81 srcu_init_notifier_head(&cpufreq_transition_notifier_list);
82 init_cpufreq_transition_notifier_list_called = true;
83 return 0;
84}
85pure_initcall(init_cpufreq_transition_notifier_list);
86
87static int off __read_mostly;
88static int cpufreq_disabled(void)
89{
90 return off;
91}
92void disable_cpufreq(void)
93{
94 off = 1;
95}
96static LIST_HEAD(cpufreq_governor_list);
97static DEFINE_MUTEX(cpufreq_governor_mutex);
98
99bool have_governor_per_policy(void)
100{
101 return !!(cpufreq_driver->flags & CPUFREQ_HAVE_GOVERNOR_PER_POLICY);
102}
103EXPORT_SYMBOL_GPL(have_governor_per_policy);
104
105struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)
106{
107 if (have_governor_per_policy())
108 return &policy->kobj;
109 else
110 return cpufreq_global_kobject;
111}
112EXPORT_SYMBOL_GPL(get_governor_parent_kobj);
113
114static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
115{
116 u64 idle_time;
117 u64 cur_wall_time;
118 u64 busy_time;
119
120 cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
121
122 busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
123 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
124 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
125 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
126 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
127 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
128
129 idle_time = cur_wall_time - busy_time;
130 if (wall)
131 *wall = cputime_to_usecs(cur_wall_time);
132
133 return cputime_to_usecs(idle_time);
134}
135
136u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
137{
138 u64 idle_time = get_cpu_idle_time_us(cpu, io_busy ? wall : NULL);
139
140 if (idle_time == -1ULL)
141 return get_cpu_idle_time_jiffy(cpu, wall);
142 else if (!io_busy)
143 idle_time += get_cpu_iowait_time_us(cpu, wall);
144
145 return idle_time;
146}
147EXPORT_SYMBOL_GPL(get_cpu_idle_time);
148
149
150
151
152
153
154
155
156int cpufreq_generic_init(struct cpufreq_policy *policy,
157 struct cpufreq_frequency_table *table,
158 unsigned int transition_latency)
159{
160 int ret;
161
162 ret = cpufreq_table_validate_and_show(policy, table);
163 if (ret) {
164 pr_err("%s: invalid frequency table: %d\n", __func__, ret);
165 return ret;
166 }
167
168 policy->cpuinfo.transition_latency = transition_latency;
169
170
171
172
173
174 cpumask_setall(policy->cpus);
175
176 return 0;
177}
178EXPORT_SYMBOL_GPL(cpufreq_generic_init);
179
180unsigned int cpufreq_generic_get(unsigned int cpu)
181{
182 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
183
184 if (!policy || IS_ERR(policy->clk)) {
185 pr_err("%s: No %s associated to cpu: %d\n",
186 __func__, policy ? "clk" : "policy", cpu);
187 return 0;
188 }
189
190 return clk_get_rate(policy->clk) / 1000;
191}
192EXPORT_SYMBOL_GPL(cpufreq_generic_get);
193
194
195struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)
196{
197 return per_cpu(cpufreq_cpu_data, cpu);
198}
199
200struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
201{
202 struct cpufreq_policy *policy = NULL;
203 unsigned long flags;
204
205 if (cpufreq_disabled() || (cpu >= nr_cpu_ids))
206 return NULL;
207
208 if (!down_read_trylock(&cpufreq_rwsem))
209 return NULL;
210
211
212 read_lock_irqsave(&cpufreq_driver_lock, flags);
213
214 if (cpufreq_driver) {
215
216 policy = per_cpu(cpufreq_cpu_data, cpu);
217 if (policy)
218 kobject_get(&policy->kobj);
219 }
220
221 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
222
223 if (!policy)
224 up_read(&cpufreq_rwsem);
225
226 return policy;
227}
228EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
229
230void cpufreq_cpu_put(struct cpufreq_policy *policy)
231{
232 if (cpufreq_disabled())
233 return;
234
235 kobject_put(&policy->kobj);
236 up_read(&cpufreq_rwsem);
237}
238EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
239
240
241
242
243
244
245
246
247
248
249
250
251
252#ifndef CONFIG_SMP
253static unsigned long l_p_j_ref;
254static unsigned int l_p_j_ref_freq;
255
256static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
257{
258 if (ci->flags & CPUFREQ_CONST_LOOPS)
259 return;
260
261 if (!l_p_j_ref_freq) {
262 l_p_j_ref = loops_per_jiffy;
263 l_p_j_ref_freq = ci->old;
264 pr_debug("saving %lu as reference value for loops_per_jiffy; freq is %u kHz\n",
265 l_p_j_ref, l_p_j_ref_freq);
266 }
267 if (val == CPUFREQ_POSTCHANGE && ci->old != ci->new) {
268 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
269 ci->new);
270 pr_debug("scaling loops_per_jiffy to %lu for frequency %u kHz\n",
271 loops_per_jiffy, ci->new);
272 }
273}
274#else
275static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
276{
277 return;
278}
279#endif
280
281static void __cpufreq_notify_transition(struct cpufreq_policy *policy,
282 struct cpufreq_freqs *freqs, unsigned int state)
283{
284 BUG_ON(irqs_disabled());
285
286 if (cpufreq_disabled())
287 return;
288
289 freqs->flags = cpufreq_driver->flags;
290 pr_debug("notification %u of frequency transition to %u kHz\n",
291 state, freqs->new);
292
293 switch (state) {
294
295 case CPUFREQ_PRECHANGE:
296
297
298
299
300 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
301 if ((policy) && (policy->cpu == freqs->cpu) &&
302 (policy->cur) && (policy->cur != freqs->old)) {
303 pr_debug("Warning: CPU frequency is %u, cpufreq assumed %u kHz\n",
304 freqs->old, policy->cur);
305 freqs->old = policy->cur;
306 }
307 }
308 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
309 CPUFREQ_PRECHANGE, freqs);
310 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
311 break;
312
313 case CPUFREQ_POSTCHANGE:
314 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
315 pr_debug("FREQ: %lu - CPU: %lu\n",
316 (unsigned long)freqs->new, (unsigned long)freqs->cpu);
317 trace_cpu_frequency(freqs->new, freqs->cpu);
318 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
319 CPUFREQ_POSTCHANGE, freqs);
320 if (likely(policy) && likely(policy->cpu == freqs->cpu))
321 policy->cur = freqs->new;
322 break;
323 }
324}
325
326
327
328
329
330
331
332
333
334static void cpufreq_notify_transition(struct cpufreq_policy *policy,
335 struct cpufreq_freqs *freqs, unsigned int state)
336{
337 for_each_cpu(freqs->cpu, policy->cpus)
338 __cpufreq_notify_transition(policy, freqs, state);
339}
340
341
342static void cpufreq_notify_post_transition(struct cpufreq_policy *policy,
343 struct cpufreq_freqs *freqs, int transition_failed)
344{
345 cpufreq_notify_transition(policy, freqs, CPUFREQ_POSTCHANGE);
346 if (!transition_failed)
347 return;
348
349 swap(freqs->old, freqs->new);
350 cpufreq_notify_transition(policy, freqs, CPUFREQ_PRECHANGE);
351 cpufreq_notify_transition(policy, freqs, CPUFREQ_POSTCHANGE);
352}
353
354void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
355 struct cpufreq_freqs *freqs)
356{
357
358
359
360
361
362
363
364
365
366 WARN_ON(!(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION)
367 && current == policy->transition_task);
368
369wait:
370 wait_event(policy->transition_wait, !policy->transition_ongoing);
371
372 spin_lock(&policy->transition_lock);
373
374 if (unlikely(policy->transition_ongoing)) {
375 spin_unlock(&policy->transition_lock);
376 goto wait;
377 }
378
379 policy->transition_ongoing = true;
380 policy->transition_task = current;
381
382 spin_unlock(&policy->transition_lock);
383
384 cpufreq_notify_transition(policy, freqs, CPUFREQ_PRECHANGE);
385}
386EXPORT_SYMBOL_GPL(cpufreq_freq_transition_begin);
387
388void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
389 struct cpufreq_freqs *freqs, int transition_failed)
390{
391 if (unlikely(WARN_ON(!policy->transition_ongoing)))
392 return;
393
394 cpufreq_notify_post_transition(policy, freqs, transition_failed);
395
396 policy->transition_ongoing = false;
397 policy->transition_task = NULL;
398
399 wake_up(&policy->transition_wait);
400}
401EXPORT_SYMBOL_GPL(cpufreq_freq_transition_end);
402
403
404
405
406
407static ssize_t show_boost(struct kobject *kobj,
408 struct attribute *attr, char *buf)
409{
410 return sprintf(buf, "%d\n", cpufreq_driver->boost_enabled);
411}
412
413static ssize_t store_boost(struct kobject *kobj, struct attribute *attr,
414 const char *buf, size_t count)
415{
416 int ret, enable;
417
418 ret = sscanf(buf, "%d", &enable);
419 if (ret != 1 || enable < 0 || enable > 1)
420 return -EINVAL;
421
422 if (cpufreq_boost_trigger_state(enable)) {
423 pr_err("%s: Cannot %s BOOST!\n",
424 __func__, enable ? "enable" : "disable");
425 return -EINVAL;
426 }
427
428 pr_debug("%s: cpufreq BOOST %s\n",
429 __func__, enable ? "enabled" : "disabled");
430
431 return count;
432}
433define_one_global_rw(boost);
434
435static struct cpufreq_governor *__find_governor(const char *str_governor)
436{
437 struct cpufreq_governor *t;
438
439 list_for_each_entry(t, &cpufreq_governor_list, governor_list)
440 if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
441 return t;
442
443 return NULL;
444}
445
446
447
448
449static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
450 struct cpufreq_governor **governor)
451{
452 int err = -EINVAL;
453
454 if (!cpufreq_driver)
455 goto out;
456
457 if (cpufreq_driver->setpolicy) {
458 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
459 *policy = CPUFREQ_POLICY_PERFORMANCE;
460 err = 0;
461 } else if (!strnicmp(str_governor, "powersave",
462 CPUFREQ_NAME_LEN)) {
463 *policy = CPUFREQ_POLICY_POWERSAVE;
464 err = 0;
465 }
466 } else if (has_target()) {
467 struct cpufreq_governor *t;
468
469 mutex_lock(&cpufreq_governor_mutex);
470
471 t = __find_governor(str_governor);
472
473 if (t == NULL) {
474 int ret;
475
476 mutex_unlock(&cpufreq_governor_mutex);
477 ret = request_module("cpufreq_%s", str_governor);
478 mutex_lock(&cpufreq_governor_mutex);
479
480 if (ret == 0)
481 t = __find_governor(str_governor);
482 }
483
484 if (t != NULL) {
485 *governor = t;
486 err = 0;
487 }
488
489 mutex_unlock(&cpufreq_governor_mutex);
490 }
491out:
492 return err;
493}
494
495
496
497
498
499
500
501
502
503#define show_one(file_name, object) \
504static ssize_t show_##file_name \
505(struct cpufreq_policy *policy, char *buf) \
506{ \
507 return sprintf(buf, "%u\n", policy->object); \
508}
509
510show_one(cpuinfo_min_freq, cpuinfo.min_freq);
511show_one(cpuinfo_max_freq, cpuinfo.max_freq);
512show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
513show_one(scaling_min_freq, min);
514show_one(scaling_max_freq, max);
515show_one(scaling_cur_freq, cur);
516
517static int cpufreq_set_policy(struct cpufreq_policy *policy,
518 struct cpufreq_policy *new_policy);
519
520
521
522
523#define store_one(file_name, object) \
524static ssize_t store_##file_name \
525(struct cpufreq_policy *policy, const char *buf, size_t count) \
526{ \
527 int ret; \
528 struct cpufreq_policy new_policy; \
529 \
530 ret = cpufreq_get_policy(&new_policy, policy->cpu); \
531 if (ret) \
532 return -EINVAL; \
533 \
534 ret = sscanf(buf, "%u", &new_policy.object); \
535 if (ret != 1) \
536 return -EINVAL; \
537 \
538 ret = cpufreq_set_policy(policy, &new_policy); \
539 policy->user_policy.object = policy->object; \
540 \
541 return ret ? ret : count; \
542}
543
544store_one(scaling_min_freq, min);
545store_one(scaling_max_freq, max);
546
547
548
549
550static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
551 char *buf)
552{
553 unsigned int cur_freq = __cpufreq_get(policy->cpu);
554 if (!cur_freq)
555 return sprintf(buf, "<unknown>");
556 return sprintf(buf, "%u\n", cur_freq);
557}
558
559
560
561
562static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
563{
564 if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
565 return sprintf(buf, "powersave\n");
566 else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
567 return sprintf(buf, "performance\n");
568 else if (policy->governor)
569 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
570 policy->governor->name);
571 return -EINVAL;
572}
573
574
575
576
577static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
578 const char *buf, size_t count)
579{
580 int ret;
581 char str_governor[16];
582 struct cpufreq_policy new_policy;
583
584 ret = cpufreq_get_policy(&new_policy, policy->cpu);
585 if (ret)
586 return ret;
587
588 ret = sscanf(buf, "%15s", str_governor);
589 if (ret != 1)
590 return -EINVAL;
591
592 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
593 &new_policy.governor))
594 return -EINVAL;
595
596 ret = cpufreq_set_policy(policy, &new_policy);
597
598 policy->user_policy.policy = policy->policy;
599 policy->user_policy.governor = policy->governor;
600
601 if (ret)
602 return ret;
603 else
604 return count;
605}
606
607
608
609
610static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
611{
612 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
613}
614
615
616
617
618static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
619 char *buf)
620{
621 ssize_t i = 0;
622 struct cpufreq_governor *t;
623
624 if (!has_target()) {
625 i += sprintf(buf, "performance powersave");
626 goto out;
627 }
628
629 list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
630 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
631 - (CPUFREQ_NAME_LEN + 2)))
632 goto out;
633 i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
634 }
635out:
636 i += sprintf(&buf[i], "\n");
637 return i;
638}
639
640ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf)
641{
642 ssize_t i = 0;
643 unsigned int cpu;
644
645 for_each_cpu(cpu, mask) {
646 if (i)
647 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
648 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
649 if (i >= (PAGE_SIZE - 5))
650 break;
651 }
652 i += sprintf(&buf[i], "\n");
653 return i;
654}
655EXPORT_SYMBOL_GPL(cpufreq_show_cpus);
656
657
658
659
660
661static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
662{
663 return cpufreq_show_cpus(policy->related_cpus, buf);
664}
665
666
667
668
669static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
670{
671 return cpufreq_show_cpus(policy->cpus, buf);
672}
673
674static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
675 const char *buf, size_t count)
676{
677 unsigned int freq = 0;
678 unsigned int ret;
679
680 if (!policy->governor || !policy->governor->store_setspeed)
681 return -EINVAL;
682
683 ret = sscanf(buf, "%u", &freq);
684 if (ret != 1)
685 return -EINVAL;
686
687 policy->governor->store_setspeed(policy, freq);
688
689 return count;
690}
691
692static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
693{
694 if (!policy->governor || !policy->governor->show_setspeed)
695 return sprintf(buf, "<unsupported>\n");
696
697 return policy->governor->show_setspeed(policy, buf);
698}
699
700
701
702
703static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
704{
705 unsigned int limit;
706 int ret;
707 if (cpufreq_driver->bios_limit) {
708 ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
709 if (!ret)
710 return sprintf(buf, "%u\n", limit);
711 }
712 return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
713}
714
715cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
716cpufreq_freq_attr_ro(cpuinfo_min_freq);
717cpufreq_freq_attr_ro(cpuinfo_max_freq);
718cpufreq_freq_attr_ro(cpuinfo_transition_latency);
719cpufreq_freq_attr_ro(scaling_available_governors);
720cpufreq_freq_attr_ro(scaling_driver);
721cpufreq_freq_attr_ro(scaling_cur_freq);
722cpufreq_freq_attr_ro(bios_limit);
723cpufreq_freq_attr_ro(related_cpus);
724cpufreq_freq_attr_ro(affected_cpus);
725cpufreq_freq_attr_rw(scaling_min_freq);
726cpufreq_freq_attr_rw(scaling_max_freq);
727cpufreq_freq_attr_rw(scaling_governor);
728cpufreq_freq_attr_rw(scaling_setspeed);
729
730static struct attribute *default_attrs[] = {
731 &cpuinfo_min_freq.attr,
732 &cpuinfo_max_freq.attr,
733 &cpuinfo_transition_latency.attr,
734 &scaling_min_freq.attr,
735 &scaling_max_freq.attr,
736 &affected_cpus.attr,
737 &related_cpus.attr,
738 &scaling_governor.attr,
739 &scaling_driver.attr,
740 &scaling_available_governors.attr,
741 &scaling_setspeed.attr,
742 NULL
743};
744
745#define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
746#define to_attr(a) container_of(a, struct freq_attr, attr)
747
748static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
749{
750 struct cpufreq_policy *policy = to_policy(kobj);
751 struct freq_attr *fattr = to_attr(attr);
752 ssize_t ret;
753
754 if (!down_read_trylock(&cpufreq_rwsem))
755 return -EINVAL;
756
757 down_read(&policy->rwsem);
758
759 if (fattr->show)
760 ret = fattr->show(policy, buf);
761 else
762 ret = -EIO;
763
764 up_read(&policy->rwsem);
765 up_read(&cpufreq_rwsem);
766
767 return ret;
768}
769
770static ssize_t store(struct kobject *kobj, struct attribute *attr,
771 const char *buf, size_t count)
772{
773 struct cpufreq_policy *policy = to_policy(kobj);
774 struct freq_attr *fattr = to_attr(attr);
775 ssize_t ret = -EINVAL;
776
777 get_online_cpus();
778
779 if (!cpu_online(policy->cpu))
780 goto unlock;
781
782 if (!down_read_trylock(&cpufreq_rwsem))
783 goto unlock;
784
785 down_write(&policy->rwsem);
786
787 if (fattr->store)
788 ret = fattr->store(policy, buf, count);
789 else
790 ret = -EIO;
791
792 up_write(&policy->rwsem);
793
794 up_read(&cpufreq_rwsem);
795unlock:
796 put_online_cpus();
797
798 return ret;
799}
800
801static void cpufreq_sysfs_release(struct kobject *kobj)
802{
803 struct cpufreq_policy *policy = to_policy(kobj);
804 pr_debug("last reference is dropped\n");
805 complete(&policy->kobj_unregister);
806}
807
808static const struct sysfs_ops sysfs_ops = {
809 .show = show,
810 .store = store,
811};
812
813static struct kobj_type ktype_cpufreq = {
814 .sysfs_ops = &sysfs_ops,
815 .default_attrs = default_attrs,
816 .release = cpufreq_sysfs_release,
817};
818
819struct kobject *cpufreq_global_kobject;
820EXPORT_SYMBOL(cpufreq_global_kobject);
821
822static int cpufreq_global_kobject_usage;
823
824int cpufreq_get_global_kobject(void)
825{
826 if (!cpufreq_global_kobject_usage++)
827 return kobject_add(cpufreq_global_kobject,
828 &cpu_subsys.dev_root->kobj, "%s", "cpufreq");
829
830 return 0;
831}
832EXPORT_SYMBOL(cpufreq_get_global_kobject);
833
834void cpufreq_put_global_kobject(void)
835{
836 if (!--cpufreq_global_kobject_usage)
837 kobject_del(cpufreq_global_kobject);
838}
839EXPORT_SYMBOL(cpufreq_put_global_kobject);
840
841int cpufreq_sysfs_create_file(const struct attribute *attr)
842{
843 int ret = cpufreq_get_global_kobject();
844
845 if (!ret) {
846 ret = sysfs_create_file(cpufreq_global_kobject, attr);
847 if (ret)
848 cpufreq_put_global_kobject();
849 }
850
851 return ret;
852}
853EXPORT_SYMBOL(cpufreq_sysfs_create_file);
854
855void cpufreq_sysfs_remove_file(const struct attribute *attr)
856{
857 sysfs_remove_file(cpufreq_global_kobject, attr);
858 cpufreq_put_global_kobject();
859}
860EXPORT_SYMBOL(cpufreq_sysfs_remove_file);
861
862
863static int cpufreq_add_dev_symlink(struct cpufreq_policy *policy)
864{
865 unsigned int j;
866 int ret = 0;
867
868 for_each_cpu(j, policy->cpus) {
869 struct device *cpu_dev;
870
871 if (j == policy->cpu)
872 continue;
873
874 pr_debug("Adding link for CPU: %u\n", j);
875 cpu_dev = get_cpu_device(j);
876 ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
877 "cpufreq");
878 if (ret)
879 break;
880 }
881 return ret;
882}
883
884static int cpufreq_add_dev_interface(struct cpufreq_policy *policy,
885 struct device *dev)
886{
887 struct freq_attr **drv_attr;
888 int ret = 0;
889
890
891 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
892 &dev->kobj, "cpufreq");
893 if (ret)
894 return ret;
895
896
897 drv_attr = cpufreq_driver->attr;
898 while ((drv_attr) && (*drv_attr)) {
899 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
900 if (ret)
901 goto err_out_kobj_put;
902 drv_attr++;
903 }
904 if (cpufreq_driver->get) {
905 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
906 if (ret)
907 goto err_out_kobj_put;
908 }
909 if (has_target()) {
910 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
911 if (ret)
912 goto err_out_kobj_put;
913 }
914 if (cpufreq_driver->bios_limit) {
915 ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
916 if (ret)
917 goto err_out_kobj_put;
918 }
919
920 ret = cpufreq_add_dev_symlink(policy);
921 if (ret)
922 goto err_out_kobj_put;
923
924 return ret;
925
926err_out_kobj_put:
927 kobject_put(&policy->kobj);
928 wait_for_completion(&policy->kobj_unregister);
929 return ret;
930}
931
932static void cpufreq_init_policy(struct cpufreq_policy *policy)
933{
934 struct cpufreq_governor *gov = NULL;
935 struct cpufreq_policy new_policy;
936 int ret = 0;
937
938 memcpy(&new_policy, policy, sizeof(*policy));
939
940
941 gov = __find_governor(per_cpu(cpufreq_cpu_governor, policy->cpu));
942 if (gov)
943 pr_debug("Restoring governor %s for cpu %d\n",
944 policy->governor->name, policy->cpu);
945 else
946 gov = CPUFREQ_DEFAULT_GOVERNOR;
947
948 new_policy.governor = gov;
949
950
951 if (cpufreq_driver->setpolicy)
952 cpufreq_parse_governor(gov->name, &new_policy.policy, NULL);
953
954
955 ret = cpufreq_set_policy(policy, &new_policy);
956 if (ret) {
957 pr_debug("setting policy failed\n");
958 if (cpufreq_driver->exit)
959 cpufreq_driver->exit(policy);
960 }
961}
962
963#ifdef CONFIG_HOTPLUG_CPU
964static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy,
965 unsigned int cpu, struct device *dev)
966{
967 int ret = 0;
968 unsigned long flags;
969
970 if (has_target()) {
971 ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
972 if (ret) {
973 pr_err("%s: Failed to stop governor\n", __func__);
974 return ret;
975 }
976 }
977
978 down_write(&policy->rwsem);
979
980 write_lock_irqsave(&cpufreq_driver_lock, flags);
981
982 cpumask_set_cpu(cpu, policy->cpus);
983 per_cpu(cpufreq_cpu_data, cpu) = policy;
984 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
985
986 up_write(&policy->rwsem);
987
988 if (has_target()) {
989 ret = __cpufreq_governor(policy, CPUFREQ_GOV_START);
990 if (!ret)
991 ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
992
993 if (ret) {
994 pr_err("%s: Failed to start governor\n", __func__);
995 return ret;
996 }
997 }
998
999 return sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
1000}
1001#endif
1002
1003static struct cpufreq_policy *cpufreq_policy_restore(unsigned int cpu)
1004{
1005 struct cpufreq_policy *policy;
1006 unsigned long flags;
1007
1008 read_lock_irqsave(&cpufreq_driver_lock, flags);
1009
1010 policy = per_cpu(cpufreq_cpu_data_fallback, cpu);
1011
1012 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1013
1014 policy->governor = NULL;
1015
1016 return policy;
1017}
1018
1019static struct cpufreq_policy *cpufreq_policy_alloc(void)
1020{
1021 struct cpufreq_policy *policy;
1022
1023 policy = kzalloc(sizeof(*policy), GFP_KERNEL);
1024 if (!policy)
1025 return NULL;
1026
1027 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
1028 goto err_free_policy;
1029
1030 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
1031 goto err_free_cpumask;
1032
1033 INIT_LIST_HEAD(&policy->policy_list);
1034 init_rwsem(&policy->rwsem);
1035 spin_lock_init(&policy->transition_lock);
1036 init_waitqueue_head(&policy->transition_wait);
1037
1038 return policy;
1039
1040err_free_cpumask:
1041 free_cpumask_var(policy->cpus);
1042err_free_policy:
1043 kfree(policy);
1044
1045 return NULL;
1046}
1047
1048static void cpufreq_policy_put_kobj(struct cpufreq_policy *policy)
1049{
1050 struct kobject *kobj;
1051 struct completion *cmp;
1052
1053 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1054 CPUFREQ_REMOVE_POLICY, policy);
1055
1056 down_read(&policy->rwsem);
1057 kobj = &policy->kobj;
1058 cmp = &policy->kobj_unregister;
1059 up_read(&policy->rwsem);
1060 kobject_put(kobj);
1061
1062
1063
1064
1065
1066
1067 pr_debug("waiting for dropping of refcount\n");
1068 wait_for_completion(cmp);
1069 pr_debug("wait complete\n");
1070}
1071
1072static void cpufreq_policy_free(struct cpufreq_policy *policy)
1073{
1074 free_cpumask_var(policy->related_cpus);
1075 free_cpumask_var(policy->cpus);
1076 kfree(policy);
1077}
1078
1079static int update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu,
1080 struct device *cpu_dev)
1081{
1082 int ret;
1083
1084 if (WARN_ON(cpu == policy->cpu))
1085 return 0;
1086
1087
1088 ret = kobject_move(&policy->kobj, &cpu_dev->kobj);
1089 if (ret) {
1090 pr_err("%s: Failed to move kobj: %d\n", __func__, ret);
1091 return ret;
1092 }
1093
1094 down_write(&policy->rwsem);
1095
1096 policy->last_cpu = policy->cpu;
1097 policy->cpu = cpu;
1098
1099 up_write(&policy->rwsem);
1100
1101 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1102 CPUFREQ_UPDATE_POLICY_CPU, policy);
1103
1104 return 0;
1105}
1106
1107static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
1108{
1109 unsigned int j, cpu = dev->id;
1110 int ret = -ENOMEM;
1111 struct cpufreq_policy *policy;
1112 unsigned long flags;
1113 bool recover_policy = cpufreq_suspended;
1114#ifdef CONFIG_HOTPLUG_CPU
1115 struct cpufreq_policy *tpolicy;
1116#endif
1117
1118 if (cpu_is_offline(cpu))
1119 return 0;
1120
1121 pr_debug("adding CPU %u\n", cpu);
1122
1123#ifdef CONFIG_SMP
1124
1125
1126 policy = cpufreq_cpu_get(cpu);
1127 if (unlikely(policy)) {
1128 cpufreq_cpu_put(policy);
1129 return 0;
1130 }
1131#endif
1132
1133 if (!down_read_trylock(&cpufreq_rwsem))
1134 return 0;
1135
1136#ifdef CONFIG_HOTPLUG_CPU
1137
1138 read_lock_irqsave(&cpufreq_driver_lock, flags);
1139 list_for_each_entry(tpolicy, &cpufreq_policy_list, policy_list) {
1140 if (cpumask_test_cpu(cpu, tpolicy->related_cpus)) {
1141 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1142 ret = cpufreq_add_policy_cpu(tpolicy, cpu, dev);
1143 up_read(&cpufreq_rwsem);
1144 return ret;
1145 }
1146 }
1147 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1148#endif
1149
1150
1151
1152
1153
1154 policy = recover_policy ? cpufreq_policy_restore(cpu) : NULL;
1155 if (!policy) {
1156 recover_policy = false;
1157 policy = cpufreq_policy_alloc();
1158 if (!policy)
1159 goto nomem_out;
1160 }
1161
1162
1163
1164
1165
1166
1167
1168 if (recover_policy && cpu != policy->cpu)
1169 WARN_ON(update_policy_cpu(policy, cpu, dev));
1170 else
1171 policy->cpu = cpu;
1172
1173 cpumask_copy(policy->cpus, cpumask_of(cpu));
1174
1175 init_completion(&policy->kobj_unregister);
1176 INIT_WORK(&policy->update, handle_update);
1177
1178
1179
1180
1181 ret = cpufreq_driver->init(policy);
1182 if (ret) {
1183 pr_debug("initialization failed\n");
1184 goto err_set_policy_cpu;
1185 }
1186
1187
1188 cpumask_or(policy->related_cpus, policy->related_cpus, policy->cpus);
1189
1190
1191
1192
1193
1194 cpumask_and(policy->cpus, policy->cpus, cpu_online_mask);
1195
1196 if (!recover_policy) {
1197 policy->user_policy.min = policy->min;
1198 policy->user_policy.max = policy->max;
1199 }
1200
1201 down_write(&policy->rwsem);
1202 write_lock_irqsave(&cpufreq_driver_lock, flags);
1203 for_each_cpu(j, policy->cpus)
1204 per_cpu(cpufreq_cpu_data, j) = policy;
1205 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1206
1207 if (cpufreq_driver->get && !cpufreq_driver->setpolicy) {
1208 policy->cur = cpufreq_driver->get(policy->cpu);
1209 if (!policy->cur) {
1210 pr_err("%s: ->get() failed\n", __func__);
1211 goto err_get_freq;
1212 }
1213 }
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233 if ((cpufreq_driver->flags & CPUFREQ_NEED_INITIAL_FREQ_CHECK)
1234 && has_target()) {
1235
1236 ret = cpufreq_frequency_table_get_index(policy, policy->cur);
1237 if (ret == -EINVAL) {
1238
1239 pr_warn("%s: CPU%d: Running at unlisted freq: %u KHz\n",
1240 __func__, policy->cpu, policy->cur);
1241 ret = __cpufreq_driver_target(policy, policy->cur - 1,
1242 CPUFREQ_RELATION_L);
1243
1244
1245
1246
1247
1248
1249 BUG_ON(ret);
1250 pr_warn("%s: CPU%d: Unlisted initial frequency changed to: %u KHz\n",
1251 __func__, policy->cpu, policy->cur);
1252 }
1253 }
1254
1255 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1256 CPUFREQ_START, policy);
1257
1258 if (!recover_policy) {
1259 ret = cpufreq_add_dev_interface(policy, dev);
1260 if (ret)
1261 goto err_out_unregister;
1262 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1263 CPUFREQ_CREATE_POLICY, policy);
1264 }
1265
1266 write_lock_irqsave(&cpufreq_driver_lock, flags);
1267 list_add(&policy->policy_list, &cpufreq_policy_list);
1268 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1269
1270 cpufreq_init_policy(policy);
1271
1272 if (!recover_policy) {
1273 policy->user_policy.policy = policy->policy;
1274 policy->user_policy.governor = policy->governor;
1275 }
1276 up_write(&policy->rwsem);
1277
1278 kobject_uevent(&policy->kobj, KOBJ_ADD);
1279 up_read(&cpufreq_rwsem);
1280
1281 pr_debug("initialization complete\n");
1282
1283 return 0;
1284
1285err_out_unregister:
1286err_get_freq:
1287 write_lock_irqsave(&cpufreq_driver_lock, flags);
1288 for_each_cpu(j, policy->cpus)
1289 per_cpu(cpufreq_cpu_data, j) = NULL;
1290 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1291
1292 up_write(&policy->rwsem);
1293
1294 if (cpufreq_driver->exit)
1295 cpufreq_driver->exit(policy);
1296err_set_policy_cpu:
1297 if (recover_policy) {
1298
1299 per_cpu(cpufreq_cpu_data_fallback, cpu) = NULL;
1300 cpufreq_policy_put_kobj(policy);
1301 }
1302 cpufreq_policy_free(policy);
1303
1304nomem_out:
1305 up_read(&cpufreq_rwsem);
1306
1307 return ret;
1308}
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
1320{
1321 return __cpufreq_add_dev(dev, sif);
1322}
1323
1324static int __cpufreq_remove_dev_prepare(struct device *dev,
1325 struct subsys_interface *sif)
1326{
1327 unsigned int cpu = dev->id, cpus;
1328 int ret;
1329 unsigned long flags;
1330 struct cpufreq_policy *policy;
1331
1332 pr_debug("%s: unregistering CPU %u\n", __func__, cpu);
1333
1334 write_lock_irqsave(&cpufreq_driver_lock, flags);
1335
1336 policy = per_cpu(cpufreq_cpu_data, cpu);
1337
1338
1339 if (cpufreq_suspended)
1340 per_cpu(cpufreq_cpu_data_fallback, cpu) = policy;
1341
1342 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1343
1344 if (!policy) {
1345 pr_debug("%s: No cpu_data found\n", __func__);
1346 return -EINVAL;
1347 }
1348
1349 if (has_target()) {
1350 ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
1351 if (ret) {
1352 pr_err("%s: Failed to stop governor\n", __func__);
1353 return ret;
1354 }
1355 }
1356
1357 if (!cpufreq_driver->setpolicy)
1358 strncpy(per_cpu(cpufreq_cpu_governor, cpu),
1359 policy->governor->name, CPUFREQ_NAME_LEN);
1360
1361 down_read(&policy->rwsem);
1362 cpus = cpumask_weight(policy->cpus);
1363 up_read(&policy->rwsem);
1364
1365 if (cpu != policy->cpu) {
1366 sysfs_remove_link(&dev->kobj, "cpufreq");
1367 } else if (cpus > 1) {
1368
1369 int new_cpu = cpumask_any_but(policy->cpus, cpu);
1370 struct device *cpu_dev = get_cpu_device(new_cpu);
1371
1372 sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
1373 ret = update_policy_cpu(policy, new_cpu, cpu_dev);
1374 if (ret) {
1375 if (sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
1376 "cpufreq"))
1377 pr_err("%s: Failed to restore kobj link to cpu:%d\n",
1378 __func__, cpu_dev->id);
1379 return ret;
1380 }
1381
1382 if (!cpufreq_suspended)
1383 pr_debug("%s: policy Kobject moved to cpu: %d from: %d\n",
1384 __func__, new_cpu, cpu);
1385 } else if (cpufreq_driver->stop_cpu && cpufreq_driver->setpolicy) {
1386 cpufreq_driver->stop_cpu(policy);
1387 }
1388
1389 return 0;
1390}
1391
1392static int __cpufreq_remove_dev_finish(struct device *dev,
1393 struct subsys_interface *sif)
1394{
1395 unsigned int cpu = dev->id, cpus;
1396 int ret;
1397 unsigned long flags;
1398 struct cpufreq_policy *policy;
1399
1400 read_lock_irqsave(&cpufreq_driver_lock, flags);
1401 policy = per_cpu(cpufreq_cpu_data, cpu);
1402 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1403
1404 if (!policy) {
1405 pr_debug("%s: No cpu_data found\n", __func__);
1406 return -EINVAL;
1407 }
1408
1409 down_write(&policy->rwsem);
1410 cpus = cpumask_weight(policy->cpus);
1411
1412 if (cpus > 1)
1413 cpumask_clear_cpu(cpu, policy->cpus);
1414 up_write(&policy->rwsem);
1415
1416
1417 if (cpus == 1) {
1418 if (has_target()) {
1419 ret = __cpufreq_governor(policy,
1420 CPUFREQ_GOV_POLICY_EXIT);
1421 if (ret) {
1422 pr_err("%s: Failed to exit governor\n",
1423 __func__);
1424 return ret;
1425 }
1426 }
1427
1428 if (!cpufreq_suspended)
1429 cpufreq_policy_put_kobj(policy);
1430
1431
1432
1433
1434
1435
1436 if (cpufreq_driver->exit)
1437 cpufreq_driver->exit(policy);
1438
1439
1440 write_lock_irqsave(&cpufreq_driver_lock, flags);
1441 list_del(&policy->policy_list);
1442 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1443
1444 if (!cpufreq_suspended)
1445 cpufreq_policy_free(policy);
1446 } else if (has_target()) {
1447 ret = __cpufreq_governor(policy, CPUFREQ_GOV_START);
1448 if (!ret)
1449 ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
1450
1451 if (ret) {
1452 pr_err("%s: Failed to start governor\n", __func__);
1453 return ret;
1454 }
1455 }
1456
1457 per_cpu(cpufreq_cpu_data, cpu) = NULL;
1458 return 0;
1459}
1460
1461
1462
1463
1464
1465
1466static int cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
1467{
1468 unsigned int cpu = dev->id;
1469 int ret;
1470
1471 if (cpu_is_offline(cpu))
1472 return 0;
1473
1474 ret = __cpufreq_remove_dev_prepare(dev, sif);
1475
1476 if (!ret)
1477 ret = __cpufreq_remove_dev_finish(dev, sif);
1478
1479 return ret;
1480}
1481
1482static void handle_update(struct work_struct *work)
1483{
1484 struct cpufreq_policy *policy =
1485 container_of(work, struct cpufreq_policy, update);
1486 unsigned int cpu = policy->cpu;
1487 pr_debug("handle_update for cpu %u called\n", cpu);
1488 cpufreq_update_policy(cpu);
1489}
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1502 unsigned int new_freq)
1503{
1504 struct cpufreq_policy *policy;
1505 struct cpufreq_freqs freqs;
1506 unsigned long flags;
1507
1508 pr_debug("Warning: CPU frequency out of sync: cpufreq and timing core thinks of %u, is %u kHz\n",
1509 old_freq, new_freq);
1510
1511 freqs.old = old_freq;
1512 freqs.new = new_freq;
1513
1514 read_lock_irqsave(&cpufreq_driver_lock, flags);
1515 policy = per_cpu(cpufreq_cpu_data, cpu);
1516 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1517
1518 cpufreq_freq_transition_begin(policy, &freqs);
1519 cpufreq_freq_transition_end(policy, &freqs, 0);
1520}
1521
1522
1523
1524
1525
1526
1527
1528
1529unsigned int cpufreq_quick_get(unsigned int cpu)
1530{
1531 struct cpufreq_policy *policy;
1532 unsigned int ret_freq = 0;
1533
1534 if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
1535 return cpufreq_driver->get(cpu);
1536
1537 policy = cpufreq_cpu_get(cpu);
1538 if (policy) {
1539 ret_freq = policy->cur;
1540 cpufreq_cpu_put(policy);
1541 }
1542
1543 return ret_freq;
1544}
1545EXPORT_SYMBOL(cpufreq_quick_get);
1546
1547
1548
1549
1550
1551
1552
1553unsigned int cpufreq_quick_get_max(unsigned int cpu)
1554{
1555 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1556 unsigned int ret_freq = 0;
1557
1558 if (policy) {
1559 ret_freq = policy->max;
1560 cpufreq_cpu_put(policy);
1561 }
1562
1563 return ret_freq;
1564}
1565EXPORT_SYMBOL(cpufreq_quick_get_max);
1566
1567static unsigned int __cpufreq_get(unsigned int cpu)
1568{
1569 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1570 unsigned int ret_freq = 0;
1571
1572 if (!cpufreq_driver->get)
1573 return ret_freq;
1574
1575 ret_freq = cpufreq_driver->get(cpu);
1576
1577 if (ret_freq && policy->cur &&
1578 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1579
1580
1581 if (unlikely(ret_freq != policy->cur)) {
1582 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
1583 schedule_work(&policy->update);
1584 }
1585 }
1586
1587 return ret_freq;
1588}
1589
1590
1591
1592
1593
1594
1595
1596unsigned int cpufreq_get(unsigned int cpu)
1597{
1598 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1599 unsigned int ret_freq = 0;
1600
1601 if (policy) {
1602 down_read(&policy->rwsem);
1603 ret_freq = __cpufreq_get(cpu);
1604 up_read(&policy->rwsem);
1605
1606 cpufreq_cpu_put(policy);
1607 }
1608
1609 return ret_freq;
1610}
1611EXPORT_SYMBOL(cpufreq_get);
1612
1613static struct subsys_interface cpufreq_interface = {
1614 .name = "cpufreq",
1615 .subsys = &cpu_subsys,
1616 .add_dev = cpufreq_add_dev,
1617 .remove_dev = cpufreq_remove_dev,
1618};
1619
1620
1621
1622
1623
1624int cpufreq_generic_suspend(struct cpufreq_policy *policy)
1625{
1626 int ret;
1627
1628 if (!policy->suspend_freq) {
1629 pr_err("%s: suspend_freq can't be zero\n", __func__);
1630 return -EINVAL;
1631 }
1632
1633 pr_debug("%s: Setting suspend-freq: %u\n", __func__,
1634 policy->suspend_freq);
1635
1636 ret = __cpufreq_driver_target(policy, policy->suspend_freq,
1637 CPUFREQ_RELATION_H);
1638 if (ret)
1639 pr_err("%s: unable to set suspend-freq: %u. err: %d\n",
1640 __func__, policy->suspend_freq, ret);
1641
1642 return ret;
1643}
1644EXPORT_SYMBOL(cpufreq_generic_suspend);
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654void cpufreq_suspend(void)
1655{
1656 struct cpufreq_policy *policy;
1657
1658 if (!cpufreq_driver)
1659 return;
1660
1661 if (!has_target())
1662 goto suspend;
1663
1664 pr_debug("%s: Suspending Governors\n", __func__);
1665
1666 list_for_each_entry(policy, &cpufreq_policy_list, policy_list) {
1667 if (__cpufreq_governor(policy, CPUFREQ_GOV_STOP))
1668 pr_err("%s: Failed to stop governor for policy: %p\n",
1669 __func__, policy);
1670 else if (cpufreq_driver->suspend
1671 && cpufreq_driver->suspend(policy))
1672 pr_err("%s: Failed to suspend driver: %p\n", __func__,
1673 policy);
1674 }
1675
1676suspend:
1677 cpufreq_suspended = true;
1678}
1679
1680
1681
1682
1683
1684
1685
1686void cpufreq_resume(void)
1687{
1688 struct cpufreq_policy *policy;
1689
1690 if (!cpufreq_driver)
1691 return;
1692
1693 cpufreq_suspended = false;
1694
1695 if (!has_target())
1696 return;
1697
1698 pr_debug("%s: Resuming Governors\n", __func__);
1699
1700 list_for_each_entry(policy, &cpufreq_policy_list, policy_list) {
1701 if (cpufreq_driver->resume && cpufreq_driver->resume(policy))
1702 pr_err("%s: Failed to resume driver: %p\n", __func__,
1703 policy);
1704 else if (__cpufreq_governor(policy, CPUFREQ_GOV_START)
1705 || __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))
1706 pr_err("%s: Failed to start governor for policy: %p\n",
1707 __func__, policy);
1708
1709
1710
1711
1712
1713
1714 if (list_is_last(&policy->policy_list, &cpufreq_policy_list))
1715 schedule_work(&policy->update);
1716 }
1717}
1718
1719
1720
1721
1722
1723
1724
1725const char *cpufreq_get_current_driver(void)
1726{
1727 if (cpufreq_driver)
1728 return cpufreq_driver->name;
1729
1730 return NULL;
1731}
1732EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1752{
1753 int ret;
1754
1755 if (cpufreq_disabled())
1756 return -EINVAL;
1757
1758 WARN_ON(!init_cpufreq_transition_notifier_list_called);
1759
1760 switch (list) {
1761 case CPUFREQ_TRANSITION_NOTIFIER:
1762 ret = srcu_notifier_chain_register(
1763 &cpufreq_transition_notifier_list, nb);
1764 break;
1765 case CPUFREQ_POLICY_NOTIFIER:
1766 ret = blocking_notifier_chain_register(
1767 &cpufreq_policy_notifier_list, nb);
1768 break;
1769 default:
1770 ret = -EINVAL;
1771 }
1772
1773 return ret;
1774}
1775EXPORT_SYMBOL(cpufreq_register_notifier);
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1788{
1789 int ret;
1790
1791 if (cpufreq_disabled())
1792 return -EINVAL;
1793
1794 switch (list) {
1795 case CPUFREQ_TRANSITION_NOTIFIER:
1796 ret = srcu_notifier_chain_unregister(
1797 &cpufreq_transition_notifier_list, nb);
1798 break;
1799 case CPUFREQ_POLICY_NOTIFIER:
1800 ret = blocking_notifier_chain_unregister(
1801 &cpufreq_policy_notifier_list, nb);
1802 break;
1803 default:
1804 ret = -EINVAL;
1805 }
1806
1807 return ret;
1808}
1809EXPORT_SYMBOL(cpufreq_unregister_notifier);
1810
1811
1812
1813
1814
1815
1816
1817static int __target_intermediate(struct cpufreq_policy *policy,
1818 struct cpufreq_freqs *freqs, int index)
1819{
1820 int ret;
1821
1822 freqs->new = cpufreq_driver->get_intermediate(policy, index);
1823
1824
1825 if (!freqs->new)
1826 return 0;
1827
1828 pr_debug("%s: cpu: %d, switching to intermediate freq: oldfreq: %u, intermediate freq: %u\n",
1829 __func__, policy->cpu, freqs->old, freqs->new);
1830
1831 cpufreq_freq_transition_begin(policy, freqs);
1832 ret = cpufreq_driver->target_intermediate(policy, index);
1833 cpufreq_freq_transition_end(policy, freqs, ret);
1834
1835 if (ret)
1836 pr_err("%s: Failed to change to intermediate frequency: %d\n",
1837 __func__, ret);
1838
1839 return ret;
1840}
1841
1842static int __target_index(struct cpufreq_policy *policy,
1843 struct cpufreq_frequency_table *freq_table, int index)
1844{
1845 struct cpufreq_freqs freqs = {.old = policy->cur, .flags = 0};
1846 unsigned int intermediate_freq = 0;
1847 int retval = -EINVAL;
1848 bool notify;
1849
1850 notify = !(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION);
1851 if (notify) {
1852
1853 if (cpufreq_driver->get_intermediate) {
1854 retval = __target_intermediate(policy, &freqs, index);
1855 if (retval)
1856 return retval;
1857
1858 intermediate_freq = freqs.new;
1859
1860 if (intermediate_freq)
1861 freqs.old = freqs.new;
1862 }
1863
1864 freqs.new = freq_table[index].frequency;
1865 pr_debug("%s: cpu: %d, oldfreq: %u, new freq: %u\n",
1866 __func__, policy->cpu, freqs.old, freqs.new);
1867
1868 cpufreq_freq_transition_begin(policy, &freqs);
1869 }
1870
1871 retval = cpufreq_driver->target_index(policy, index);
1872 if (retval)
1873 pr_err("%s: Failed to change cpu frequency: %d\n", __func__,
1874 retval);
1875
1876 if (notify) {
1877 cpufreq_freq_transition_end(policy, &freqs, retval);
1878
1879
1880
1881
1882
1883
1884
1885 if (unlikely(retval && intermediate_freq)) {
1886 freqs.old = intermediate_freq;
1887 freqs.new = policy->restore_freq;
1888 cpufreq_freq_transition_begin(policy, &freqs);
1889 cpufreq_freq_transition_end(policy, &freqs, 0);
1890 }
1891 }
1892
1893 return retval;
1894}
1895
1896int __cpufreq_driver_target(struct cpufreq_policy *policy,
1897 unsigned int target_freq,
1898 unsigned int relation)
1899{
1900 unsigned int old_target_freq = target_freq;
1901 int retval = -EINVAL;
1902
1903 if (cpufreq_disabled())
1904 return -ENODEV;
1905
1906
1907 if (target_freq > policy->max)
1908 target_freq = policy->max;
1909 if (target_freq < policy->min)
1910 target_freq = policy->min;
1911
1912 pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
1913 policy->cpu, target_freq, relation, old_target_freq);
1914
1915
1916
1917
1918
1919
1920
1921 if (target_freq == policy->cur)
1922 return 0;
1923
1924
1925 policy->restore_freq = policy->cur;
1926
1927 if (cpufreq_driver->target)
1928 retval = cpufreq_driver->target(policy, target_freq, relation);
1929 else if (cpufreq_driver->target_index) {
1930 struct cpufreq_frequency_table *freq_table;
1931 int index;
1932
1933 freq_table = cpufreq_frequency_get_table(policy->cpu);
1934 if (unlikely(!freq_table)) {
1935 pr_err("%s: Unable to find freq_table\n", __func__);
1936 goto out;
1937 }
1938
1939 retval = cpufreq_frequency_table_target(policy, freq_table,
1940 target_freq, relation, &index);
1941 if (unlikely(retval)) {
1942 pr_err("%s: Unable to find matching freq\n", __func__);
1943 goto out;
1944 }
1945
1946 if (freq_table[index].frequency == policy->cur) {
1947 retval = 0;
1948 goto out;
1949 }
1950
1951 retval = __target_index(policy, freq_table, index);
1952 }
1953
1954out:
1955 return retval;
1956}
1957EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1958
1959int cpufreq_driver_target(struct cpufreq_policy *policy,
1960 unsigned int target_freq,
1961 unsigned int relation)
1962{
1963 int ret = -EINVAL;
1964
1965 down_write(&policy->rwsem);
1966
1967 ret = __cpufreq_driver_target(policy, target_freq, relation);
1968
1969 up_write(&policy->rwsem);
1970
1971 return ret;
1972}
1973EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1974
1975
1976
1977
1978
1979static int __cpufreq_governor(struct cpufreq_policy *policy,
1980 unsigned int event)
1981{
1982 int ret;
1983
1984
1985
1986
1987
1988#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1989 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1990#else
1991 struct cpufreq_governor *gov = NULL;
1992#endif
1993
1994
1995 if (cpufreq_suspended)
1996 return 0;
1997
1998 if (policy->governor->max_transition_latency &&
1999 policy->cpuinfo.transition_latency >
2000 policy->governor->max_transition_latency) {
2001 if (!gov)
2002 return -EINVAL;
2003 else {
2004 pr_warn("%s governor failed, too long transition latency of HW, fallback to %s governor\n",
2005 policy->governor->name, gov->name);
2006 policy->governor = gov;
2007 }
2008 }
2009
2010 if (event == CPUFREQ_GOV_POLICY_INIT)
2011 if (!try_module_get(policy->governor->owner))
2012 return -EINVAL;
2013
2014 pr_debug("__cpufreq_governor for CPU %u, event %u\n",
2015 policy->cpu, event);
2016
2017 mutex_lock(&cpufreq_governor_lock);
2018 if ((policy->governor_enabled && event == CPUFREQ_GOV_START)
2019 || (!policy->governor_enabled
2020 && (event == CPUFREQ_GOV_LIMITS || event == CPUFREQ_GOV_STOP))) {
2021 mutex_unlock(&cpufreq_governor_lock);
2022 return -EBUSY;
2023 }
2024
2025 if (event == CPUFREQ_GOV_STOP)
2026 policy->governor_enabled = false;
2027 else if (event == CPUFREQ_GOV_START)
2028 policy->governor_enabled = true;
2029
2030 mutex_unlock(&cpufreq_governor_lock);
2031
2032 ret = policy->governor->governor(policy, event);
2033
2034 if (!ret) {
2035 if (event == CPUFREQ_GOV_POLICY_INIT)
2036 policy->governor->initialized++;
2037 else if (event == CPUFREQ_GOV_POLICY_EXIT)
2038 policy->governor->initialized--;
2039 } else {
2040
2041 mutex_lock(&cpufreq_governor_lock);
2042 if (event == CPUFREQ_GOV_STOP)
2043 policy->governor_enabled = true;
2044 else if (event == CPUFREQ_GOV_START)
2045 policy->governor_enabled = false;
2046 mutex_unlock(&cpufreq_governor_lock);
2047 }
2048
2049 if (((event == CPUFREQ_GOV_POLICY_INIT) && ret) ||
2050 ((event == CPUFREQ_GOV_POLICY_EXIT) && !ret))
2051 module_put(policy->governor->owner);
2052
2053 return ret;
2054}
2055
2056int cpufreq_register_governor(struct cpufreq_governor *governor)
2057{
2058 int err;
2059
2060 if (!governor)
2061 return -EINVAL;
2062
2063 if (cpufreq_disabled())
2064 return -ENODEV;
2065
2066 mutex_lock(&cpufreq_governor_mutex);
2067
2068 governor->initialized = 0;
2069 err = -EBUSY;
2070 if (__find_governor(governor->name) == NULL) {
2071 err = 0;
2072 list_add(&governor->governor_list, &cpufreq_governor_list);
2073 }
2074
2075 mutex_unlock(&cpufreq_governor_mutex);
2076 return err;
2077}
2078EXPORT_SYMBOL_GPL(cpufreq_register_governor);
2079
2080void cpufreq_unregister_governor(struct cpufreq_governor *governor)
2081{
2082 int cpu;
2083
2084 if (!governor)
2085 return;
2086
2087 if (cpufreq_disabled())
2088 return;
2089
2090 for_each_present_cpu(cpu) {
2091 if (cpu_online(cpu))
2092 continue;
2093 if (!strcmp(per_cpu(cpufreq_cpu_governor, cpu), governor->name))
2094 strcpy(per_cpu(cpufreq_cpu_governor, cpu), "\0");
2095 }
2096
2097 mutex_lock(&cpufreq_governor_mutex);
2098 list_del(&governor->governor_list);
2099 mutex_unlock(&cpufreq_governor_mutex);
2100 return;
2101}
2102EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
2117{
2118 struct cpufreq_policy *cpu_policy;
2119 if (!policy)
2120 return -EINVAL;
2121
2122 cpu_policy = cpufreq_cpu_get(cpu);
2123 if (!cpu_policy)
2124 return -EINVAL;
2125
2126 memcpy(policy, cpu_policy, sizeof(*policy));
2127
2128 cpufreq_cpu_put(cpu_policy);
2129 return 0;
2130}
2131EXPORT_SYMBOL(cpufreq_get_policy);
2132
2133
2134
2135
2136
2137static int cpufreq_set_policy(struct cpufreq_policy *policy,
2138 struct cpufreq_policy *new_policy)
2139{
2140 struct cpufreq_governor *old_gov;
2141 int ret;
2142
2143 pr_debug("setting new policy for CPU %u: %u - %u kHz\n",
2144 new_policy->cpu, new_policy->min, new_policy->max);
2145
2146 memcpy(&new_policy->cpuinfo, &policy->cpuinfo, sizeof(policy->cpuinfo));
2147
2148 if (new_policy->min > policy->max || new_policy->max < policy->min)
2149 return -EINVAL;
2150
2151
2152 ret = cpufreq_driver->verify(new_policy);
2153 if (ret)
2154 return ret;
2155
2156
2157 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
2158 CPUFREQ_ADJUST, new_policy);
2159
2160
2161 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
2162 CPUFREQ_INCOMPATIBLE, new_policy);
2163
2164
2165
2166
2167
2168 ret = cpufreq_driver->verify(new_policy);
2169 if (ret)
2170 return ret;
2171
2172
2173 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
2174 CPUFREQ_NOTIFY, new_policy);
2175
2176 policy->min = new_policy->min;
2177 policy->max = new_policy->max;
2178
2179 pr_debug("new min and max freqs are %u - %u kHz\n",
2180 policy->min, policy->max);
2181
2182 if (cpufreq_driver->setpolicy) {
2183 policy->policy = new_policy->policy;
2184 pr_debug("setting range\n");
2185 return cpufreq_driver->setpolicy(new_policy);
2186 }
2187
2188 if (new_policy->governor == policy->governor)
2189 goto out;
2190
2191 pr_debug("governor switch\n");
2192
2193
2194 old_gov = policy->governor;
2195
2196 if (old_gov) {
2197 __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
2198 up_write(&policy->rwsem);
2199 __cpufreq_governor(policy, CPUFREQ_GOV_POLICY_EXIT);
2200 down_write(&policy->rwsem);
2201 }
2202
2203
2204 policy->governor = new_policy->governor;
2205 if (!__cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT)) {
2206 if (!__cpufreq_governor(policy, CPUFREQ_GOV_START))
2207 goto out;
2208
2209 up_write(&policy->rwsem);
2210 __cpufreq_governor(policy, CPUFREQ_GOV_POLICY_EXIT);
2211 down_write(&policy->rwsem);
2212 }
2213
2214
2215 pr_debug("starting governor %s failed\n", policy->governor->name);
2216 if (old_gov) {
2217 policy->governor = old_gov;
2218 __cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT);
2219 __cpufreq_governor(policy, CPUFREQ_GOV_START);
2220 }
2221
2222 return -EINVAL;
2223
2224 out:
2225 pr_debug("governor: change or update limits\n");
2226 return __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
2227}
2228
2229
2230
2231
2232
2233
2234
2235
2236int cpufreq_update_policy(unsigned int cpu)
2237{
2238 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
2239 struct cpufreq_policy new_policy;
2240 int ret;
2241
2242 if (!policy)
2243 return -ENODEV;
2244
2245 down_write(&policy->rwsem);
2246
2247 pr_debug("updating policy for CPU %u\n", cpu);
2248 memcpy(&new_policy, policy, sizeof(*policy));
2249 new_policy.min = policy->user_policy.min;
2250 new_policy.max = policy->user_policy.max;
2251 new_policy.policy = policy->user_policy.policy;
2252 new_policy.governor = policy->user_policy.governor;
2253
2254
2255
2256
2257
2258 if (cpufreq_driver->get && !cpufreq_driver->setpolicy) {
2259 new_policy.cur = cpufreq_driver->get(cpu);
2260 if (WARN_ON(!new_policy.cur)) {
2261 ret = -EIO;
2262 goto unlock;
2263 }
2264
2265 if (!policy->cur) {
2266 pr_debug("Driver did not initialize current freq\n");
2267 policy->cur = new_policy.cur;
2268 } else {
2269 if (policy->cur != new_policy.cur && has_target())
2270 cpufreq_out_of_sync(cpu, policy->cur,
2271 new_policy.cur);
2272 }
2273 }
2274
2275 ret = cpufreq_set_policy(policy, &new_policy);
2276
2277unlock:
2278 up_write(&policy->rwsem);
2279
2280 cpufreq_cpu_put(policy);
2281 return ret;
2282}
2283EXPORT_SYMBOL(cpufreq_update_policy);
2284
2285static int cpufreq_cpu_callback(struct notifier_block *nfb,
2286 unsigned long action, void *hcpu)
2287{
2288 unsigned int cpu = (unsigned long)hcpu;
2289 struct device *dev;
2290
2291 dev = get_cpu_device(cpu);
2292 if (dev) {
2293 switch (action & ~CPU_TASKS_FROZEN) {
2294 case CPU_ONLINE:
2295 __cpufreq_add_dev(dev, NULL);
2296 break;
2297
2298 case CPU_DOWN_PREPARE:
2299 __cpufreq_remove_dev_prepare(dev, NULL);
2300 break;
2301
2302 case CPU_POST_DEAD:
2303 __cpufreq_remove_dev_finish(dev, NULL);
2304 break;
2305
2306 case CPU_DOWN_FAILED:
2307 __cpufreq_add_dev(dev, NULL);
2308 break;
2309 }
2310 }
2311 return NOTIFY_OK;
2312}
2313
2314static struct notifier_block __refdata cpufreq_cpu_notifier = {
2315 .notifier_call = cpufreq_cpu_callback,
2316};
2317
2318
2319
2320
2321static int cpufreq_boost_set_sw(int state)
2322{
2323 struct cpufreq_frequency_table *freq_table;
2324 struct cpufreq_policy *policy;
2325 int ret = -EINVAL;
2326
2327 list_for_each_entry(policy, &cpufreq_policy_list, policy_list) {
2328 freq_table = cpufreq_frequency_get_table(policy->cpu);
2329 if (freq_table) {
2330 ret = cpufreq_frequency_table_cpuinfo(policy,
2331 freq_table);
2332 if (ret) {
2333 pr_err("%s: Policy frequency update failed\n",
2334 __func__);
2335 break;
2336 }
2337 policy->user_policy.max = policy->max;
2338 __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
2339 }
2340 }
2341
2342 return ret;
2343}
2344
2345int cpufreq_boost_trigger_state(int state)
2346{
2347 unsigned long flags;
2348 int ret = 0;
2349
2350 if (cpufreq_driver->boost_enabled == state)
2351 return 0;
2352
2353 write_lock_irqsave(&cpufreq_driver_lock, flags);
2354 cpufreq_driver->boost_enabled = state;
2355 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2356
2357 ret = cpufreq_driver->set_boost(state);
2358 if (ret) {
2359 write_lock_irqsave(&cpufreq_driver_lock, flags);
2360 cpufreq_driver->boost_enabled = !state;
2361 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2362
2363 pr_err("%s: Cannot %s BOOST\n",
2364 __func__, state ? "enable" : "disable");
2365 }
2366
2367 return ret;
2368}
2369
2370int cpufreq_boost_supported(void)
2371{
2372 if (likely(cpufreq_driver))
2373 return cpufreq_driver->boost_supported;
2374
2375 return 0;
2376}
2377EXPORT_SYMBOL_GPL(cpufreq_boost_supported);
2378
2379int cpufreq_boost_enabled(void)
2380{
2381 return cpufreq_driver->boost_enabled;
2382}
2383EXPORT_SYMBOL_GPL(cpufreq_boost_enabled);
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399int cpufreq_register_driver(struct cpufreq_driver *driver_data)
2400{
2401 unsigned long flags;
2402 int ret;
2403
2404 if (cpufreq_disabled())
2405 return -ENODEV;
2406
2407 if (!driver_data || !driver_data->verify || !driver_data->init ||
2408 !(driver_data->setpolicy || driver_data->target_index ||
2409 driver_data->target) ||
2410 (driver_data->setpolicy && (driver_data->target_index ||
2411 driver_data->target)) ||
2412 (!!driver_data->get_intermediate != !!driver_data->target_intermediate))
2413 return -EINVAL;
2414
2415 pr_debug("trying to register driver %s\n", driver_data->name);
2416
2417 if (driver_data->setpolicy)
2418 driver_data->flags |= CPUFREQ_CONST_LOOPS;
2419
2420 write_lock_irqsave(&cpufreq_driver_lock, flags);
2421 if (cpufreq_driver) {
2422 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2423 return -EEXIST;
2424 }
2425 cpufreq_driver = driver_data;
2426 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2427
2428 if (cpufreq_boost_supported()) {
2429
2430
2431
2432
2433 if (!cpufreq_driver->set_boost)
2434 cpufreq_driver->set_boost = cpufreq_boost_set_sw;
2435
2436 ret = cpufreq_sysfs_create_file(&boost.attr);
2437 if (ret) {
2438 pr_err("%s: cannot register global BOOST sysfs file\n",
2439 __func__);
2440 goto err_null_driver;
2441 }
2442 }
2443
2444 ret = subsys_interface_register(&cpufreq_interface);
2445 if (ret)
2446 goto err_boost_unreg;
2447
2448 if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) {
2449 int i;
2450 ret = -ENODEV;
2451
2452
2453 for (i = 0; i < nr_cpu_ids; i++)
2454 if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
2455 ret = 0;
2456 break;
2457 }
2458
2459
2460 if (ret) {
2461 pr_debug("no CPU initialized for driver %s\n",
2462 driver_data->name);
2463 goto err_if_unreg;
2464 }
2465 }
2466
2467 register_hotcpu_notifier(&cpufreq_cpu_notifier);
2468 pr_debug("driver %s up and running\n", driver_data->name);
2469
2470 return 0;
2471err_if_unreg:
2472 subsys_interface_unregister(&cpufreq_interface);
2473err_boost_unreg:
2474 if (cpufreq_boost_supported())
2475 cpufreq_sysfs_remove_file(&boost.attr);
2476err_null_driver:
2477 write_lock_irqsave(&cpufreq_driver_lock, flags);
2478 cpufreq_driver = NULL;
2479 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2480 return ret;
2481}
2482EXPORT_SYMBOL_GPL(cpufreq_register_driver);
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492int cpufreq_unregister_driver(struct cpufreq_driver *driver)
2493{
2494 unsigned long flags;
2495
2496 if (!cpufreq_driver || (driver != cpufreq_driver))
2497 return -EINVAL;
2498
2499 pr_debug("unregistering driver %s\n", driver->name);
2500
2501 subsys_interface_unregister(&cpufreq_interface);
2502 if (cpufreq_boost_supported())
2503 cpufreq_sysfs_remove_file(&boost.attr);
2504
2505 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
2506
2507 down_write(&cpufreq_rwsem);
2508 write_lock_irqsave(&cpufreq_driver_lock, flags);
2509
2510 cpufreq_driver = NULL;
2511
2512 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2513 up_write(&cpufreq_rwsem);
2514
2515 return 0;
2516}
2517EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
2518
2519static int __init cpufreq_core_init(void)
2520{
2521 if (cpufreq_disabled())
2522 return -ENODEV;
2523
2524 cpufreq_global_kobject = kobject_create();
2525 BUG_ON(!cpufreq_global_kobject);
2526
2527 return 0;
2528}
2529core_initcall(cpufreq_core_init);
2530