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