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