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