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