1
2
3
4
5
6
7
8#ifndef _LINUX_CPUFREQ_H
9#define _LINUX_CPUFREQ_H
10
11#include <linux/clk.h>
12#include <linux/cpumask.h>
13#include <linux/completion.h>
14#include <linux/kobject.h>
15#include <linux/notifier.h>
16#include <linux/spinlock.h>
17#include <linux/sysfs.h>
18
19
20
21
22
23
24
25
26
27
28
29#define CPUFREQ_ETERNAL (-1)
30#define CPUFREQ_NAME_LEN 16
31
32#define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
33
34struct cpufreq_governor;
35
36enum cpufreq_table_sorting {
37 CPUFREQ_TABLE_UNSORTED,
38 CPUFREQ_TABLE_SORTED_ASCENDING,
39 CPUFREQ_TABLE_SORTED_DESCENDING
40};
41
42struct cpufreq_cpuinfo {
43 unsigned int max_freq;
44 unsigned int min_freq;
45
46
47 unsigned int transition_latency;
48};
49
50struct cpufreq_user_policy {
51 unsigned int min;
52 unsigned int max;
53};
54
55struct cpufreq_policy {
56
57 cpumask_var_t cpus;
58 cpumask_var_t related_cpus;
59 cpumask_var_t real_cpus;
60
61 unsigned int shared_type;
62
63 unsigned int cpu;
64
65 struct clk *clk;
66 struct cpufreq_cpuinfo cpuinfo;
67
68 unsigned int min;
69 unsigned int max;
70 unsigned int cur;
71
72 unsigned int restore_freq;
73 unsigned int suspend_freq;
74
75 unsigned int policy;
76 unsigned int last_policy;
77 struct cpufreq_governor *governor;
78 void *governor_data;
79 char last_governor[CPUFREQ_NAME_LEN];
80
81 struct work_struct update;
82
83
84 struct cpufreq_user_policy user_policy;
85 struct cpufreq_frequency_table *freq_table;
86 enum cpufreq_table_sorting freq_table_sorted;
87
88 struct list_head policy_list;
89 struct kobject kobj;
90 struct completion kobj_unregister;
91
92
93
94
95
96
97
98
99
100 struct rw_semaphore rwsem;
101
102
103
104
105
106
107
108
109
110 bool fast_switch_possible;
111 bool fast_switch_enabled;
112
113
114
115
116
117
118 unsigned int transition_delay_us;
119
120
121
122
123
124
125
126
127 bool dvfs_possible_from_any_cpu;
128
129
130 unsigned int cached_target_freq;
131 int cached_resolved_idx;
132
133
134 bool transition_ongoing;
135 spinlock_t transition_lock;
136 wait_queue_head_t transition_wait;
137 struct task_struct *transition_task;
138
139
140 struct cpufreq_stats *stats;
141
142
143 void *driver_data;
144
145
146 struct thermal_cooling_device *cdev;
147};
148
149struct cpufreq_freqs {
150 struct cpufreq_policy *policy;
151 unsigned int old;
152 unsigned int new;
153 u8 flags;
154};
155
156
157#define CPUFREQ_SHARED_TYPE_NONE (0)
158#define CPUFREQ_SHARED_TYPE_HW (1)
159#define CPUFREQ_SHARED_TYPE_ALL (2)
160#define CPUFREQ_SHARED_TYPE_ANY (3)
161
162#ifdef CONFIG_CPU_FREQ
163struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu);
164struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
165void cpufreq_cpu_put(struct cpufreq_policy *policy);
166#else
167static inline struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)
168{
169 return NULL;
170}
171static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
172{
173 return NULL;
174}
175static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { }
176#endif
177
178static inline bool policy_is_inactive(struct cpufreq_policy *policy)
179{
180 return cpumask_empty(policy->cpus);
181}
182
183static inline bool policy_is_shared(struct cpufreq_policy *policy)
184{
185 return cpumask_weight(policy->cpus) > 1;
186}
187
188
189extern struct kobject *cpufreq_global_kobject;
190
191#ifdef CONFIG_CPU_FREQ
192unsigned int cpufreq_get(unsigned int cpu);
193unsigned int cpufreq_quick_get(unsigned int cpu);
194unsigned int cpufreq_quick_get_max(unsigned int cpu);
195void disable_cpufreq(void);
196
197u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
198
199struct cpufreq_policy *cpufreq_cpu_acquire(unsigned int cpu);
200void cpufreq_cpu_release(struct cpufreq_policy *policy);
201int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
202int cpufreq_set_policy(struct cpufreq_policy *policy,
203 struct cpufreq_policy *new_policy);
204void cpufreq_update_policy(unsigned int cpu);
205void cpufreq_update_limits(unsigned int cpu);
206bool have_governor_per_policy(void);
207struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
208void cpufreq_enable_fast_switch(struct cpufreq_policy *policy);
209void cpufreq_disable_fast_switch(struct cpufreq_policy *policy);
210#else
211static inline unsigned int cpufreq_get(unsigned int cpu)
212{
213 return 0;
214}
215static inline unsigned int cpufreq_quick_get(unsigned int cpu)
216{
217 return 0;
218}
219static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
220{
221 return 0;
222}
223static inline void disable_cpufreq(void) { }
224#endif
225
226#ifdef CONFIG_CPU_FREQ_STAT
227void cpufreq_stats_create_table(struct cpufreq_policy *policy);
228void cpufreq_stats_free_table(struct cpufreq_policy *policy);
229void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
230 unsigned int new_freq);
231#else
232static inline void cpufreq_stats_create_table(struct cpufreq_policy *policy) { }
233static inline void cpufreq_stats_free_table(struct cpufreq_policy *policy) { }
234static inline void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
235 unsigned int new_freq) { }
236#endif
237
238
239
240
241
242#define CPUFREQ_RELATION_L 0
243#define CPUFREQ_RELATION_H 1
244#define CPUFREQ_RELATION_C 2
245
246struct freq_attr {
247 struct attribute attr;
248 ssize_t (*show)(struct cpufreq_policy *, char *);
249 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
250};
251
252#define cpufreq_freq_attr_ro(_name) \
253static struct freq_attr _name = \
254__ATTR(_name, 0444, show_##_name, NULL)
255
256#define cpufreq_freq_attr_ro_perm(_name, _perm) \
257static struct freq_attr _name = \
258__ATTR(_name, _perm, show_##_name, NULL)
259
260#define cpufreq_freq_attr_rw(_name) \
261static struct freq_attr _name = \
262__ATTR(_name, 0644, show_##_name, store_##_name)
263
264#define cpufreq_freq_attr_wo(_name) \
265static struct freq_attr _name = \
266__ATTR(_name, 0200, NULL, store_##_name)
267
268#define define_one_global_ro(_name) \
269static struct kobj_attribute _name = \
270__ATTR(_name, 0444, show_##_name, NULL)
271
272#define define_one_global_rw(_name) \
273static struct kobj_attribute _name = \
274__ATTR(_name, 0644, show_##_name, store_##_name)
275
276
277struct cpufreq_driver {
278 char name[CPUFREQ_NAME_LEN];
279 u8 flags;
280 void *driver_data;
281
282
283 int (*init)(struct cpufreq_policy *policy);
284 int (*verify)(struct cpufreq_policy *policy);
285
286
287 int (*setpolicy)(struct cpufreq_policy *policy);
288
289
290
291
292
293 int (*target)(struct cpufreq_policy *policy,
294 unsigned int target_freq,
295 unsigned int relation);
296 int (*target_index)(struct cpufreq_policy *policy,
297 unsigned int index);
298 unsigned int (*fast_switch)(struct cpufreq_policy *policy,
299 unsigned int target_freq);
300
301
302
303
304
305
306
307 unsigned int (*resolve_freq)(struct cpufreq_policy *policy,
308 unsigned int target_freq);
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325 unsigned int (*get_intermediate)(struct cpufreq_policy *policy,
326 unsigned int index);
327 int (*target_intermediate)(struct cpufreq_policy *policy,
328 unsigned int index);
329
330
331 unsigned int (*get)(unsigned int cpu);
332
333
334 void (*update_limits)(unsigned int cpu);
335
336
337 int (*bios_limit)(int cpu, unsigned int *limit);
338
339 int (*online)(struct cpufreq_policy *policy);
340 int (*offline)(struct cpufreq_policy *policy);
341 int (*exit)(struct cpufreq_policy *policy);
342 void (*stop_cpu)(struct cpufreq_policy *policy);
343 int (*suspend)(struct cpufreq_policy *policy);
344 int (*resume)(struct cpufreq_policy *policy);
345
346
347 void (*ready)(struct cpufreq_policy *policy);
348
349 struct freq_attr **attr;
350
351
352 bool boost_enabled;
353 int (*set_boost)(int state);
354};
355
356
357
358
359#define CPUFREQ_STICKY BIT(0)
360
361
362#define CPUFREQ_CONST_LOOPS BIT(1)
363
364
365#define CPUFREQ_PM_NO_WARN BIT(2)
366
367
368
369
370
371
372
373#define CPUFREQ_HAVE_GOVERNOR_PER_POLICY BIT(3)
374
375
376
377
378
379
380#define CPUFREQ_ASYNC_NOTIFICATION BIT(4)
381
382
383
384
385
386
387
388
389#define CPUFREQ_NEED_INITIAL_FREQ_CHECK BIT(5)
390
391
392
393
394
395#define CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING BIT(6)
396
397
398
399
400
401#define CPUFREQ_IS_COOLING_DEV BIT(7)
402
403int cpufreq_register_driver(struct cpufreq_driver *driver_data);
404int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
405
406const char *cpufreq_get_current_driver(void);
407void *cpufreq_get_driver_data(void);
408
409static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
410 unsigned int min, unsigned int max)
411{
412 if (policy->min < min)
413 policy->min = min;
414 if (policy->max < min)
415 policy->max = min;
416 if (policy->min > max)
417 policy->min = max;
418 if (policy->max > max)
419 policy->max = max;
420 if (policy->min > policy->max)
421 policy->min = policy->max;
422 return;
423}
424
425static inline void
426cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
427{
428 cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
429 policy->cpuinfo.max_freq);
430}
431
432#ifdef CONFIG_CPU_FREQ
433void cpufreq_suspend(void);
434void cpufreq_resume(void);
435int cpufreq_generic_suspend(struct cpufreq_policy *policy);
436#else
437static inline void cpufreq_suspend(void) {}
438static inline void cpufreq_resume(void) {}
439#endif
440
441
442
443
444
445#define CPUFREQ_TRANSITION_NOTIFIER (0)
446#define CPUFREQ_POLICY_NOTIFIER (1)
447
448
449#define CPUFREQ_PRECHANGE (0)
450#define CPUFREQ_POSTCHANGE (1)
451
452
453#define CPUFREQ_ADJUST (0)
454#define CPUFREQ_NOTIFY (1)
455
456#ifdef CONFIG_CPU_FREQ
457int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
458int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
459
460void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
461 struct cpufreq_freqs *freqs);
462void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
463 struct cpufreq_freqs *freqs, int transition_failed);
464
465#else
466static inline int cpufreq_register_notifier(struct notifier_block *nb,
467 unsigned int list)
468{
469 return 0;
470}
471static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
472 unsigned int list)
473{
474 return 0;
475}
476#endif
477
478
479
480
481
482
483
484
485
486
487
488static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
489 u_int mult)
490{
491#if BITS_PER_LONG == 32
492 u64 result = ((u64) old) * ((u64) mult);
493 do_div(result, div);
494 return (unsigned long) result;
495
496#elif BITS_PER_LONG == 64
497 unsigned long result = old * ((u64) mult);
498 result /= div;
499 return result;
500#endif
501}
502
503
504
505
506
507
508
509
510
511
512#define CPUFREQ_POLICY_POWERSAVE (1)
513#define CPUFREQ_POLICY_PERFORMANCE (2)
514
515
516
517
518
519
520
521#define LATENCY_MULTIPLIER (1000)
522
523struct cpufreq_governor {
524 char name[CPUFREQ_NAME_LEN];
525 int (*init)(struct cpufreq_policy *policy);
526 void (*exit)(struct cpufreq_policy *policy);
527 int (*start)(struct cpufreq_policy *policy);
528 void (*stop)(struct cpufreq_policy *policy);
529 void (*limits)(struct cpufreq_policy *policy);
530 ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
531 char *buf);
532 int (*store_setspeed) (struct cpufreq_policy *policy,
533 unsigned int freq);
534
535 bool dynamic_switching;
536 struct list_head governor_list;
537 struct module *owner;
538};
539
540
541unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
542 unsigned int target_freq);
543int cpufreq_driver_target(struct cpufreq_policy *policy,
544 unsigned int target_freq,
545 unsigned int relation);
546int __cpufreq_driver_target(struct cpufreq_policy *policy,
547 unsigned int target_freq,
548 unsigned int relation);
549unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy,
550 unsigned int target_freq);
551unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy *policy);
552int cpufreq_register_governor(struct cpufreq_governor *governor);
553void cpufreq_unregister_governor(struct cpufreq_governor *governor);
554
555struct cpufreq_governor *cpufreq_default_governor(void);
556struct cpufreq_governor *cpufreq_fallback_governor(void);
557
558static inline void cpufreq_policy_apply_limits(struct cpufreq_policy *policy)
559{
560 if (policy->max < policy->cur)
561 __cpufreq_driver_target(policy, policy->max, CPUFREQ_RELATION_H);
562 else if (policy->min > policy->cur)
563 __cpufreq_driver_target(policy, policy->min, CPUFREQ_RELATION_L);
564}
565
566
567struct gov_attr_set {
568 struct kobject kobj;
569 struct list_head policy_list;
570 struct mutex update_lock;
571 int usage_count;
572};
573
574
575extern const struct sysfs_ops governor_sysfs_ops;
576
577void gov_attr_set_init(struct gov_attr_set *attr_set, struct list_head *list_node);
578void gov_attr_set_get(struct gov_attr_set *attr_set, struct list_head *list_node);
579unsigned int gov_attr_set_put(struct gov_attr_set *attr_set, struct list_head *list_node);
580
581
582struct governor_attr {
583 struct attribute attr;
584 ssize_t (*show)(struct gov_attr_set *attr_set, char *buf);
585 ssize_t (*store)(struct gov_attr_set *attr_set, const char *buf,
586 size_t count);
587};
588
589static inline bool cpufreq_this_cpu_can_update(struct cpufreq_policy *policy)
590{
591
592
593
594
595
596 return policy->dvfs_possible_from_any_cpu ||
597 cpumask_test_cpu(smp_processor_id(), policy->cpus);
598}
599
600
601
602
603
604
605#define CPUFREQ_ENTRY_INVALID ~0u
606#define CPUFREQ_TABLE_END ~1u
607
608#define CPUFREQ_BOOST_FREQ (1 << 0)
609
610struct cpufreq_frequency_table {
611 unsigned int flags;
612 unsigned int driver_data;
613 unsigned int frequency;
614
615};
616
617#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
618int dev_pm_opp_init_cpufreq_table(struct device *dev,
619 struct cpufreq_frequency_table **table);
620void dev_pm_opp_free_cpufreq_table(struct device *dev,
621 struct cpufreq_frequency_table **table);
622#else
623static inline int dev_pm_opp_init_cpufreq_table(struct device *dev,
624 struct cpufreq_frequency_table
625 **table)
626{
627 return -EINVAL;
628}
629
630static inline void dev_pm_opp_free_cpufreq_table(struct device *dev,
631 struct cpufreq_frequency_table
632 **table)
633{
634}
635#endif
636
637
638
639
640
641
642
643#define cpufreq_for_each_entry(pos, table) \
644 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)
645
646
647
648
649
650
651
652
653
654#define cpufreq_for_each_entry_idx(pos, table, idx) \
655 for (pos = table, idx = 0; pos->frequency != CPUFREQ_TABLE_END; \
656 pos++, idx++)
657
658
659
660
661
662
663
664
665#define cpufreq_for_each_valid_entry(pos, table) \
666 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) \
667 if (pos->frequency == CPUFREQ_ENTRY_INVALID) \
668 continue; \
669 else
670
671
672
673
674
675
676
677
678
679#define cpufreq_for_each_valid_entry_idx(pos, table, idx) \
680 cpufreq_for_each_entry_idx(pos, table, idx) \
681 if (pos->frequency == CPUFREQ_ENTRY_INVALID) \
682 continue; \
683 else
684
685
686int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
687 struct cpufreq_frequency_table *table);
688
689int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
690 struct cpufreq_frequency_table *table);
691int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy);
692
693int cpufreq_table_index_unsorted(struct cpufreq_policy *policy,
694 unsigned int target_freq,
695 unsigned int relation);
696int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
697 unsigned int freq);
698
699ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
700
701#ifdef CONFIG_CPU_FREQ
702int cpufreq_boost_trigger_state(int state);
703int cpufreq_boost_enabled(void);
704int cpufreq_enable_boost_support(void);
705bool policy_has_boost_freq(struct cpufreq_policy *policy);
706
707
708static inline int cpufreq_table_find_index_al(struct cpufreq_policy *policy,
709 unsigned int target_freq)
710{
711 struct cpufreq_frequency_table *table = policy->freq_table;
712 struct cpufreq_frequency_table *pos;
713 unsigned int freq;
714 int idx, best = -1;
715
716 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
717 freq = pos->frequency;
718
719 if (freq >= target_freq)
720 return idx;
721
722 best = idx;
723 }
724
725 return best;
726}
727
728
729static inline int cpufreq_table_find_index_dl(struct cpufreq_policy *policy,
730 unsigned int target_freq)
731{
732 struct cpufreq_frequency_table *table = policy->freq_table;
733 struct cpufreq_frequency_table *pos;
734 unsigned int freq;
735 int idx, best = -1;
736
737 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
738 freq = pos->frequency;
739
740 if (freq == target_freq)
741 return idx;
742
743 if (freq > target_freq) {
744 best = idx;
745 continue;
746 }
747
748
749 if (best == -1)
750 return idx;
751
752 return best;
753 }
754
755 return best;
756}
757
758
759static inline int cpufreq_table_find_index_l(struct cpufreq_policy *policy,
760 unsigned int target_freq)
761{
762 target_freq = clamp_val(target_freq, policy->min, policy->max);
763
764 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
765 return cpufreq_table_find_index_al(policy, target_freq);
766 else
767 return cpufreq_table_find_index_dl(policy, target_freq);
768}
769
770
771static inline int cpufreq_table_find_index_ah(struct cpufreq_policy *policy,
772 unsigned int target_freq)
773{
774 struct cpufreq_frequency_table *table = policy->freq_table;
775 struct cpufreq_frequency_table *pos;
776 unsigned int freq;
777 int idx, best = -1;
778
779 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
780 freq = pos->frequency;
781
782 if (freq == target_freq)
783 return idx;
784
785 if (freq < target_freq) {
786 best = idx;
787 continue;
788 }
789
790
791 if (best == -1)
792 return idx;
793
794 return best;
795 }
796
797 return best;
798}
799
800
801static inline int cpufreq_table_find_index_dh(struct cpufreq_policy *policy,
802 unsigned int target_freq)
803{
804 struct cpufreq_frequency_table *table = policy->freq_table;
805 struct cpufreq_frequency_table *pos;
806 unsigned int freq;
807 int idx, best = -1;
808
809 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
810 freq = pos->frequency;
811
812 if (freq <= target_freq)
813 return idx;
814
815 best = idx;
816 }
817
818 return best;
819}
820
821
822static inline int cpufreq_table_find_index_h(struct cpufreq_policy *policy,
823 unsigned int target_freq)
824{
825 target_freq = clamp_val(target_freq, policy->min, policy->max);
826
827 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
828 return cpufreq_table_find_index_ah(policy, target_freq);
829 else
830 return cpufreq_table_find_index_dh(policy, target_freq);
831}
832
833
834static inline int cpufreq_table_find_index_ac(struct cpufreq_policy *policy,
835 unsigned int target_freq)
836{
837 struct cpufreq_frequency_table *table = policy->freq_table;
838 struct cpufreq_frequency_table *pos;
839 unsigned int freq;
840 int idx, best = -1;
841
842 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
843 freq = pos->frequency;
844
845 if (freq == target_freq)
846 return idx;
847
848 if (freq < target_freq) {
849 best = idx;
850 continue;
851 }
852
853
854 if (best == -1)
855 return idx;
856
857
858 if (target_freq - table[best].frequency > freq - target_freq)
859 return idx;
860
861 return best;
862 }
863
864 return best;
865}
866
867
868static inline int cpufreq_table_find_index_dc(struct cpufreq_policy *policy,
869 unsigned int target_freq)
870{
871 struct cpufreq_frequency_table *table = policy->freq_table;
872 struct cpufreq_frequency_table *pos;
873 unsigned int freq;
874 int idx, best = -1;
875
876 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
877 freq = pos->frequency;
878
879 if (freq == target_freq)
880 return idx;
881
882 if (freq > target_freq) {
883 best = idx;
884 continue;
885 }
886
887
888 if (best == -1)
889 return idx;
890
891
892 if (table[best].frequency - target_freq > target_freq - freq)
893 return idx;
894
895 return best;
896 }
897
898 return best;
899}
900
901
902static inline int cpufreq_table_find_index_c(struct cpufreq_policy *policy,
903 unsigned int target_freq)
904{
905 target_freq = clamp_val(target_freq, policy->min, policy->max);
906
907 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
908 return cpufreq_table_find_index_ac(policy, target_freq);
909 else
910 return cpufreq_table_find_index_dc(policy, target_freq);
911}
912
913static inline int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
914 unsigned int target_freq,
915 unsigned int relation)
916{
917 if (unlikely(policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED))
918 return cpufreq_table_index_unsorted(policy, target_freq,
919 relation);
920
921 switch (relation) {
922 case CPUFREQ_RELATION_L:
923 return cpufreq_table_find_index_l(policy, target_freq);
924 case CPUFREQ_RELATION_H:
925 return cpufreq_table_find_index_h(policy, target_freq);
926 case CPUFREQ_RELATION_C:
927 return cpufreq_table_find_index_c(policy, target_freq);
928 default:
929 pr_err("%s: Invalid relation: %d\n", __func__, relation);
930 return -EINVAL;
931 }
932}
933
934static inline int cpufreq_table_count_valid_entries(const struct cpufreq_policy *policy)
935{
936 struct cpufreq_frequency_table *pos;
937 int count = 0;
938
939 if (unlikely(!policy->freq_table))
940 return 0;
941
942 cpufreq_for_each_valid_entry(pos, policy->freq_table)
943 count++;
944
945 return count;
946}
947#else
948static inline int cpufreq_boost_trigger_state(int state)
949{
950 return 0;
951}
952static inline int cpufreq_boost_enabled(void)
953{
954 return 0;
955}
956
957static inline int cpufreq_enable_boost_support(void)
958{
959 return -EINVAL;
960}
961
962static inline bool policy_has_boost_freq(struct cpufreq_policy *policy)
963{
964 return false;
965}
966#endif
967
968#if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
969void sched_cpufreq_governor_change(struct cpufreq_policy *policy,
970 struct cpufreq_governor *old_gov);
971#else
972static inline void sched_cpufreq_governor_change(struct cpufreq_policy *policy,
973 struct cpufreq_governor *old_gov) { }
974#endif
975
976extern void arch_freq_prepare_all(void);
977extern unsigned int arch_freq_get_on_cpu(int cpu);
978
979extern void arch_set_freq_scale(struct cpumask *cpus, unsigned long cur_freq,
980 unsigned long max_freq);
981
982
983extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
984extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs;
985extern struct freq_attr *cpufreq_generic_attr[];
986int cpufreq_table_validate_and_sort(struct cpufreq_policy *policy);
987
988unsigned int cpufreq_generic_get(unsigned int cpu);
989int cpufreq_generic_init(struct cpufreq_policy *policy,
990 struct cpufreq_frequency_table *table,
991 unsigned int transition_latency);
992#endif
993