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_policy {
51
52 cpumask_var_t cpus;
53 cpumask_var_t related_cpus;
54 cpumask_var_t real_cpus;
55
56 unsigned int shared_type;
57
58 unsigned int cpu;
59
60 struct clk *clk;
61 struct cpufreq_cpuinfo cpuinfo;
62
63 unsigned int min;
64 unsigned int max;
65 unsigned int cur;
66
67 unsigned int restore_freq;
68 unsigned int suspend_freq;
69
70 unsigned int policy;
71 unsigned int last_policy;
72 struct cpufreq_governor *governor;
73 void *governor_data;
74 char last_governor[CPUFREQ_NAME_LEN];
75
76 struct work_struct update;
77
78
79 struct dev_pm_qos_request *min_freq_req;
80 struct dev_pm_qos_request *max_freq_req;
81 struct cpufreq_frequency_table *freq_table;
82 enum cpufreq_table_sorting freq_table_sorted;
83
84 struct list_head policy_list;
85 struct kobject kobj;
86 struct completion kobj_unregister;
87
88
89
90
91
92
93
94
95
96 struct rw_semaphore rwsem;
97
98
99
100
101
102
103
104
105
106 bool fast_switch_possible;
107 bool fast_switch_enabled;
108
109
110
111
112
113
114 unsigned int transition_delay_us;
115
116
117
118
119
120
121
122
123 bool dvfs_possible_from_any_cpu;
124
125
126 unsigned int cached_target_freq;
127 int cached_resolved_idx;
128
129
130 bool transition_ongoing;
131 spinlock_t transition_lock;
132 wait_queue_head_t transition_wait;
133 struct task_struct *transition_task;
134
135
136 struct cpufreq_stats *stats;
137
138
139 void *driver_data;
140
141
142 struct thermal_cooling_device *cdev;
143
144 struct notifier_block nb_min;
145 struct notifier_block nb_max;
146};
147
148struct cpufreq_freqs {
149 struct cpufreq_policy *policy;
150 unsigned int old;
151 unsigned int new;
152 u8 flags;
153};
154
155
156#define CPUFREQ_SHARED_TYPE_NONE (0)
157#define CPUFREQ_SHARED_TYPE_HW (1)
158#define CPUFREQ_SHARED_TYPE_ALL (2)
159#define CPUFREQ_SHARED_TYPE_ANY (3)
160
161#ifdef CONFIG_CPU_FREQ
162struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu);
163struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
164void cpufreq_cpu_put(struct cpufreq_policy *policy);
165#else
166static inline struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)
167{
168 return NULL;
169}
170static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
171{
172 return NULL;
173}
174static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { }
175#endif
176
177static inline bool policy_is_inactive(struct cpufreq_policy *policy)
178{
179 return cpumask_empty(policy->cpus);
180}
181
182static inline bool policy_is_shared(struct cpufreq_policy *policy)
183{
184 return cpumask_weight(policy->cpus) > 1;
185}
186
187
188extern struct kobject *cpufreq_global_kobject;
189
190#ifdef CONFIG_CPU_FREQ
191unsigned int cpufreq_get(unsigned int cpu);
192unsigned int cpufreq_quick_get(unsigned int cpu);
193unsigned int cpufreq_quick_get_max(unsigned int cpu);
194void disable_cpufreq(void);
195
196u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
197
198struct cpufreq_policy *cpufreq_cpu_acquire(unsigned int cpu);
199void cpufreq_cpu_release(struct cpufreq_policy *policy);
200int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
201int cpufreq_set_policy(struct cpufreq_policy *policy,
202 struct cpufreq_policy *new_policy);
203void refresh_frequency_limits(struct cpufreq_policy *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 int cpufreq_thermal_control_enabled(struct cpufreq_driver *drv)
410{
411 return IS_ENABLED(CONFIG_CPU_THERMAL) &&
412 (drv->flags & CPUFREQ_IS_COOLING_DEV);
413}
414
415static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
416 unsigned int min, unsigned int max)
417{
418 if (policy->min < min)
419 policy->min = min;
420 if (policy->max < min)
421 policy->max = min;
422 if (policy->min > max)
423 policy->min = max;
424 if (policy->max > max)
425 policy->max = max;
426 if (policy->min > policy->max)
427 policy->min = policy->max;
428 return;
429}
430
431static inline void
432cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
433{
434 cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
435 policy->cpuinfo.max_freq);
436}
437
438#ifdef CONFIG_CPU_FREQ
439void cpufreq_suspend(void);
440void cpufreq_resume(void);
441int cpufreq_generic_suspend(struct cpufreq_policy *policy);
442#else
443static inline void cpufreq_suspend(void) {}
444static inline void cpufreq_resume(void) {}
445#endif
446
447
448
449
450
451#define CPUFREQ_TRANSITION_NOTIFIER (0)
452#define CPUFREQ_POLICY_NOTIFIER (1)
453
454
455#define CPUFREQ_PRECHANGE (0)
456#define CPUFREQ_POSTCHANGE (1)
457
458
459#define CPUFREQ_ADJUST (0)
460#define CPUFREQ_NOTIFY (1)
461
462#ifdef CONFIG_CPU_FREQ
463int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
464int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
465
466void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
467 struct cpufreq_freqs *freqs);
468void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
469 struct cpufreq_freqs *freqs, int transition_failed);
470
471#else
472static inline int cpufreq_register_notifier(struct notifier_block *nb,
473 unsigned int list)
474{
475 return 0;
476}
477static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
478 unsigned int list)
479{
480 return 0;
481}
482#endif
483
484
485
486
487
488
489
490
491
492
493
494static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
495 u_int mult)
496{
497#if BITS_PER_LONG == 32
498 u64 result = ((u64) old) * ((u64) mult);
499 do_div(result, div);
500 return (unsigned long) result;
501
502#elif BITS_PER_LONG == 64
503 unsigned long result = old * ((u64) mult);
504 result /= div;
505 return result;
506#endif
507}
508
509
510
511
512
513
514
515
516
517
518#define CPUFREQ_POLICY_POWERSAVE (1)
519#define CPUFREQ_POLICY_PERFORMANCE (2)
520
521
522
523
524
525
526
527#define LATENCY_MULTIPLIER (1000)
528
529struct cpufreq_governor {
530 char name[CPUFREQ_NAME_LEN];
531 int (*init)(struct cpufreq_policy *policy);
532 void (*exit)(struct cpufreq_policy *policy);
533 int (*start)(struct cpufreq_policy *policy);
534 void (*stop)(struct cpufreq_policy *policy);
535 void (*limits)(struct cpufreq_policy *policy);
536 ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
537 char *buf);
538 int (*store_setspeed) (struct cpufreq_policy *policy,
539 unsigned int freq);
540
541 bool dynamic_switching;
542 struct list_head governor_list;
543 struct module *owner;
544};
545
546
547unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
548 unsigned int target_freq);
549int cpufreq_driver_target(struct cpufreq_policy *policy,
550 unsigned int target_freq,
551 unsigned int relation);
552int __cpufreq_driver_target(struct cpufreq_policy *policy,
553 unsigned int target_freq,
554 unsigned int relation);
555unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy,
556 unsigned int target_freq);
557unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy *policy);
558int cpufreq_register_governor(struct cpufreq_governor *governor);
559void cpufreq_unregister_governor(struct cpufreq_governor *governor);
560
561struct cpufreq_governor *cpufreq_default_governor(void);
562struct cpufreq_governor *cpufreq_fallback_governor(void);
563
564static inline void cpufreq_policy_apply_limits(struct cpufreq_policy *policy)
565{
566 if (policy->max < policy->cur)
567 __cpufreq_driver_target(policy, policy->max, CPUFREQ_RELATION_H);
568 else if (policy->min > policy->cur)
569 __cpufreq_driver_target(policy, policy->min, CPUFREQ_RELATION_L);
570}
571
572
573struct gov_attr_set {
574 struct kobject kobj;
575 struct list_head policy_list;
576 struct mutex update_lock;
577 int usage_count;
578};
579
580
581extern const struct sysfs_ops governor_sysfs_ops;
582
583void gov_attr_set_init(struct gov_attr_set *attr_set, struct list_head *list_node);
584void gov_attr_set_get(struct gov_attr_set *attr_set, struct list_head *list_node);
585unsigned int gov_attr_set_put(struct gov_attr_set *attr_set, struct list_head *list_node);
586
587
588struct governor_attr {
589 struct attribute attr;
590 ssize_t (*show)(struct gov_attr_set *attr_set, char *buf);
591 ssize_t (*store)(struct gov_attr_set *attr_set, const char *buf,
592 size_t count);
593};
594
595static inline bool cpufreq_this_cpu_can_update(struct cpufreq_policy *policy)
596{
597
598
599
600
601
602 return policy->dvfs_possible_from_any_cpu ||
603 cpumask_test_cpu(smp_processor_id(), policy->cpus);
604}
605
606
607
608
609
610
611#define CPUFREQ_ENTRY_INVALID ~0u
612#define CPUFREQ_TABLE_END ~1u
613
614#define CPUFREQ_BOOST_FREQ (1 << 0)
615
616struct cpufreq_frequency_table {
617 unsigned int flags;
618 unsigned int driver_data;
619 unsigned int frequency;
620
621};
622
623#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
624int dev_pm_opp_init_cpufreq_table(struct device *dev,
625 struct cpufreq_frequency_table **table);
626void dev_pm_opp_free_cpufreq_table(struct device *dev,
627 struct cpufreq_frequency_table **table);
628#else
629static inline int dev_pm_opp_init_cpufreq_table(struct device *dev,
630 struct cpufreq_frequency_table
631 **table)
632{
633 return -EINVAL;
634}
635
636static inline void dev_pm_opp_free_cpufreq_table(struct device *dev,
637 struct cpufreq_frequency_table
638 **table)
639{
640}
641#endif
642
643
644
645
646
647
648
649#define cpufreq_for_each_entry(pos, table) \
650 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)
651
652
653
654
655
656
657
658
659
660#define cpufreq_for_each_entry_idx(pos, table, idx) \
661 for (pos = table, idx = 0; pos->frequency != CPUFREQ_TABLE_END; \
662 pos++, idx++)
663
664
665
666
667
668
669
670
671#define cpufreq_for_each_valid_entry(pos, table) \
672 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) \
673 if (pos->frequency == CPUFREQ_ENTRY_INVALID) \
674 continue; \
675 else
676
677
678
679
680
681
682
683
684
685#define cpufreq_for_each_valid_entry_idx(pos, table, idx) \
686 cpufreq_for_each_entry_idx(pos, table, idx) \
687 if (pos->frequency == CPUFREQ_ENTRY_INVALID) \
688 continue; \
689 else
690
691
692int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
693 struct cpufreq_frequency_table *table);
694
695int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
696 struct cpufreq_frequency_table *table);
697int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy);
698
699int cpufreq_table_index_unsorted(struct cpufreq_policy *policy,
700 unsigned int target_freq,
701 unsigned int relation);
702int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
703 unsigned int freq);
704
705ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
706
707#ifdef CONFIG_CPU_FREQ
708int cpufreq_boost_trigger_state(int state);
709int cpufreq_boost_enabled(void);
710int cpufreq_enable_boost_support(void);
711bool policy_has_boost_freq(struct cpufreq_policy *policy);
712
713
714static inline int cpufreq_table_find_index_al(struct cpufreq_policy *policy,
715 unsigned int target_freq)
716{
717 struct cpufreq_frequency_table *table = policy->freq_table;
718 struct cpufreq_frequency_table *pos;
719 unsigned int freq;
720 int idx, best = -1;
721
722 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
723 freq = pos->frequency;
724
725 if (freq >= target_freq)
726 return idx;
727
728 best = idx;
729 }
730
731 return best;
732}
733
734
735static inline int cpufreq_table_find_index_dl(struct cpufreq_policy *policy,
736 unsigned int target_freq)
737{
738 struct cpufreq_frequency_table *table = policy->freq_table;
739 struct cpufreq_frequency_table *pos;
740 unsigned int freq;
741 int idx, best = -1;
742
743 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
744 freq = pos->frequency;
745
746 if (freq == target_freq)
747 return idx;
748
749 if (freq > target_freq) {
750 best = idx;
751 continue;
752 }
753
754
755 if (best == -1)
756 return idx;
757
758 return best;
759 }
760
761 return best;
762}
763
764
765static inline int cpufreq_table_find_index_l(struct cpufreq_policy *policy,
766 unsigned int target_freq)
767{
768 target_freq = clamp_val(target_freq, policy->min, policy->max);
769
770 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
771 return cpufreq_table_find_index_al(policy, target_freq);
772 else
773 return cpufreq_table_find_index_dl(policy, target_freq);
774}
775
776
777static inline int cpufreq_table_find_index_ah(struct cpufreq_policy *policy,
778 unsigned int target_freq)
779{
780 struct cpufreq_frequency_table *table = policy->freq_table;
781 struct cpufreq_frequency_table *pos;
782 unsigned int freq;
783 int idx, best = -1;
784
785 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
786 freq = pos->frequency;
787
788 if (freq == target_freq)
789 return idx;
790
791 if (freq < target_freq) {
792 best = idx;
793 continue;
794 }
795
796
797 if (best == -1)
798 return idx;
799
800 return best;
801 }
802
803 return best;
804}
805
806
807static inline int cpufreq_table_find_index_dh(struct cpufreq_policy *policy,
808 unsigned int target_freq)
809{
810 struct cpufreq_frequency_table *table = policy->freq_table;
811 struct cpufreq_frequency_table *pos;
812 unsigned int freq;
813 int idx, best = -1;
814
815 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
816 freq = pos->frequency;
817
818 if (freq <= target_freq)
819 return idx;
820
821 best = idx;
822 }
823
824 return best;
825}
826
827
828static inline int cpufreq_table_find_index_h(struct cpufreq_policy *policy,
829 unsigned int target_freq)
830{
831 target_freq = clamp_val(target_freq, policy->min, policy->max);
832
833 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
834 return cpufreq_table_find_index_ah(policy, target_freq);
835 else
836 return cpufreq_table_find_index_dh(policy, target_freq);
837}
838
839
840static inline int cpufreq_table_find_index_ac(struct cpufreq_policy *policy,
841 unsigned int target_freq)
842{
843 struct cpufreq_frequency_table *table = policy->freq_table;
844 struct cpufreq_frequency_table *pos;
845 unsigned int freq;
846 int idx, best = -1;
847
848 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
849 freq = pos->frequency;
850
851 if (freq == target_freq)
852 return idx;
853
854 if (freq < target_freq) {
855 best = idx;
856 continue;
857 }
858
859
860 if (best == -1)
861 return idx;
862
863
864 if (target_freq - table[best].frequency > freq - target_freq)
865 return idx;
866
867 return best;
868 }
869
870 return best;
871}
872
873
874static inline int cpufreq_table_find_index_dc(struct cpufreq_policy *policy,
875 unsigned int target_freq)
876{
877 struct cpufreq_frequency_table *table = policy->freq_table;
878 struct cpufreq_frequency_table *pos;
879 unsigned int freq;
880 int idx, best = -1;
881
882 cpufreq_for_each_valid_entry_idx(pos, table, idx) {
883 freq = pos->frequency;
884
885 if (freq == target_freq)
886 return idx;
887
888 if (freq > target_freq) {
889 best = idx;
890 continue;
891 }
892
893
894 if (best == -1)
895 return idx;
896
897
898 if (table[best].frequency - target_freq > target_freq - freq)
899 return idx;
900
901 return best;
902 }
903
904 return best;
905}
906
907
908static inline int cpufreq_table_find_index_c(struct cpufreq_policy *policy,
909 unsigned int target_freq)
910{
911 target_freq = clamp_val(target_freq, policy->min, policy->max);
912
913 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
914 return cpufreq_table_find_index_ac(policy, target_freq);
915 else
916 return cpufreq_table_find_index_dc(policy, target_freq);
917}
918
919static inline int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
920 unsigned int target_freq,
921 unsigned int relation)
922{
923 if (unlikely(policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED))
924 return cpufreq_table_index_unsorted(policy, target_freq,
925 relation);
926
927 switch (relation) {
928 case CPUFREQ_RELATION_L:
929 return cpufreq_table_find_index_l(policy, target_freq);
930 case CPUFREQ_RELATION_H:
931 return cpufreq_table_find_index_h(policy, target_freq);
932 case CPUFREQ_RELATION_C:
933 return cpufreq_table_find_index_c(policy, target_freq);
934 default:
935 pr_err("%s: Invalid relation: %d\n", __func__, relation);
936 return -EINVAL;
937 }
938}
939
940static inline int cpufreq_table_count_valid_entries(const struct cpufreq_policy *policy)
941{
942 struct cpufreq_frequency_table *pos;
943 int count = 0;
944
945 if (unlikely(!policy->freq_table))
946 return 0;
947
948 cpufreq_for_each_valid_entry(pos, policy->freq_table)
949 count++;
950
951 return count;
952}
953#else
954static inline int cpufreq_boost_trigger_state(int state)
955{
956 return 0;
957}
958static inline int cpufreq_boost_enabled(void)
959{
960 return 0;
961}
962
963static inline int cpufreq_enable_boost_support(void)
964{
965 return -EINVAL;
966}
967
968static inline bool policy_has_boost_freq(struct cpufreq_policy *policy)
969{
970 return false;
971}
972#endif
973
974#if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
975void sched_cpufreq_governor_change(struct cpufreq_policy *policy,
976 struct cpufreq_governor *old_gov);
977#else
978static inline void sched_cpufreq_governor_change(struct cpufreq_policy *policy,
979 struct cpufreq_governor *old_gov) { }
980#endif
981
982extern void arch_freq_prepare_all(void);
983extern unsigned int arch_freq_get_on_cpu(int cpu);
984
985extern void arch_set_freq_scale(struct cpumask *cpus, unsigned long cur_freq,
986 unsigned long max_freq);
987
988
989extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
990extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs;
991extern struct freq_attr *cpufreq_generic_attr[];
992int cpufreq_table_validate_and_sort(struct cpufreq_policy *policy);
993
994unsigned int cpufreq_generic_get(unsigned int cpu);
995void cpufreq_generic_init(struct cpufreq_policy *policy,
996 struct cpufreq_frequency_table *table,
997 unsigned int transition_latency);
998#endif
999