1 /* SPDX-License-Identifier: GPL-2.0-only */
3 * linux/include/linux/cpufreq.h
5 * Copyright (C) 2001 Russell King
6 * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
8 #ifndef _LINUX_CPUFREQ_H
9 #define _LINUX_CPUFREQ_H
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>
19 /*********************************************************************
21 *********************************************************************/
23 * Frequency values here are CPU kHz
25 * Maximum transition latency is in nanoseconds - if it's unknown,
26 * CPUFREQ_ETERNAL shall be used.
29 #define CPUFREQ_ETERNAL (-1)
30 #define CPUFREQ_NAME_LEN 16
31 /* Print length for names. Extra 1 space for accommodating '\n' in prints */
32 #define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
34 struct cpufreq_governor
;
36 enum cpufreq_table_sorting
{
37 CPUFREQ_TABLE_UNSORTED
,
38 CPUFREQ_TABLE_SORTED_ASCENDING
,
39 CPUFREQ_TABLE_SORTED_DESCENDING
42 struct cpufreq_cpuinfo
{
43 unsigned int max_freq
;
44 unsigned int min_freq
;
46 /* in 10^(-9) s = nanoseconds */
47 unsigned int transition_latency
;
50 struct cpufreq_user_policy
{
51 unsigned int min
; /* in kHz */
52 unsigned int max
; /* in kHz */
55 struct cpufreq_policy
{
56 /* CPUs sharing clock, require sw coordination */
57 cpumask_var_t cpus
; /* Online CPUs only */
58 cpumask_var_t related_cpus
; /* Online + Offline CPUs */
59 cpumask_var_t real_cpus
; /* Related and present */
61 unsigned int shared_type
; /* ACPI: ANY or ALL affected CPUs
63 unsigned int cpu
; /* cpu managing this policy, must be online */
66 struct cpufreq_cpuinfo cpuinfo
;/* see above */
68 unsigned int min
; /* in kHz */
69 unsigned int max
; /* in kHz */
70 unsigned int cur
; /* in kHz, only needed if cpufreq
71 * governors are used */
72 unsigned int restore_freq
; /* = policy->cur before transition */
73 unsigned int suspend_freq
; /* freq to set during suspend */
75 unsigned int policy
; /* see above */
76 unsigned int last_policy
; /* policy before unplug */
77 struct cpufreq_governor
*governor
; /* see below */
79 char last_governor
[CPUFREQ_NAME_LEN
]; /* last governor used */
81 struct work_struct update
; /* if update_policy() needs to be
82 * called, but you're in IRQ context */
84 struct cpufreq_user_policy user_policy
;
85 struct cpufreq_frequency_table
*freq_table
;
86 enum cpufreq_table_sorting freq_table_sorted
;
88 struct list_head policy_list
;
90 struct completion kobj_unregister
;
93 * The rules for this semaphore:
94 * - Any routine that wants to read from the policy structure will
95 * do a down_read on this semaphore.
96 * - Any routine that will write to the policy structure and/or may take away
97 * the policy altogether (eg. CPU hotplug), will hold this lock in write
98 * mode before doing so.
100 struct rw_semaphore rwsem
;
104 * - fast_switch_possible should be set by the driver if it can
105 * guarantee that frequency can be changed on any CPU sharing the
106 * policy and that the change will affect all of the policy CPUs then.
107 * - fast_switch_enabled is to be set by governors that support fast
108 * frequency switching with the help of cpufreq_enable_fast_switch().
110 bool fast_switch_possible
;
111 bool fast_switch_enabled
;
114 * Preferred average time interval between consecutive invocations of
115 * the driver to set the frequency for this policy. To be set by the
116 * scaling driver (0, which is the default, means no preference).
118 unsigned int transition_delay_us
;
121 * Remote DVFS flag (Not added to the driver structure as we don't want
122 * to access another structure from scheduler hotpath).
124 * Should be set if CPUs can do DVFS on behalf of other CPUs from
125 * different cpufreq policies.
127 bool dvfs_possible_from_any_cpu
;
129 /* Cached frequency lookup from cpufreq_driver_resolve_freq. */
130 unsigned int cached_target_freq
;
131 int cached_resolved_idx
;
133 /* Synchronization for frequency transitions */
134 bool transition_ongoing
; /* Tracks transition status */
135 spinlock_t transition_lock
;
136 wait_queue_head_t transition_wait
;
137 struct task_struct
*transition_task
; /* Task which is doing the transition */
140 struct cpufreq_stats
*stats
;
142 /* For cpufreq driver's internal use */
145 /* Pointer to the cooling device if used for thermal mitigation */
146 struct thermal_cooling_device
*cdev
;
149 struct cpufreq_freqs
{
150 struct cpufreq_policy
*policy
;
153 u8 flags
; /* flags of cpufreq_driver, see below. */
157 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
158 #define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */
159 #define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */
160 #define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/
162 #ifdef CONFIG_CPU_FREQ
163 struct cpufreq_policy
*cpufreq_cpu_get_raw(unsigned int cpu
);
164 struct cpufreq_policy
*cpufreq_cpu_get(unsigned int cpu
);
165 void cpufreq_cpu_put(struct cpufreq_policy
*policy
);
167 static inline struct cpufreq_policy
*cpufreq_cpu_get_raw(unsigned int cpu
)
171 static inline struct cpufreq_policy
*cpufreq_cpu_get(unsigned int cpu
)
175 static inline void cpufreq_cpu_put(struct cpufreq_policy
*policy
) { }
178 static inline bool policy_is_inactive(struct cpufreq_policy
*policy
)
180 return cpumask_empty(policy
->cpus
);
183 static inline bool policy_is_shared(struct cpufreq_policy
*policy
)
185 return cpumask_weight(policy
->cpus
) > 1;
188 /* /sys/devices/system/cpu/cpufreq: entry point for global variables */
189 extern struct kobject
*cpufreq_global_kobject
;
191 #ifdef CONFIG_CPU_FREQ
192 unsigned int cpufreq_get(unsigned int cpu
);
193 unsigned int cpufreq_quick_get(unsigned int cpu
);
194 unsigned int cpufreq_quick_get_max(unsigned int cpu
);
195 void disable_cpufreq(void);
197 u64
get_cpu_idle_time(unsigned int cpu
, u64
*wall
, int io_busy
);
199 struct cpufreq_policy
*cpufreq_cpu_acquire(unsigned int cpu
);
200 void cpufreq_cpu_release(struct cpufreq_policy
*policy
);
201 int cpufreq_get_policy(struct cpufreq_policy
*policy
, unsigned int cpu
);
202 int cpufreq_set_policy(struct cpufreq_policy
*policy
,
203 struct cpufreq_policy
*new_policy
);
204 void cpufreq_update_policy(unsigned int cpu
);
205 void cpufreq_update_limits(unsigned int cpu
);
206 bool have_governor_per_policy(void);
207 struct kobject
*get_governor_parent_kobj(struct cpufreq_policy
*policy
);
208 void cpufreq_enable_fast_switch(struct cpufreq_policy
*policy
);
209 void cpufreq_disable_fast_switch(struct cpufreq_policy
*policy
);
211 static inline unsigned int cpufreq_get(unsigned int cpu
)
215 static inline unsigned int cpufreq_quick_get(unsigned int cpu
)
219 static inline unsigned int cpufreq_quick_get_max(unsigned int cpu
)
223 static inline void disable_cpufreq(void) { }
226 #ifdef CONFIG_CPU_FREQ_STAT
227 void cpufreq_stats_create_table(struct cpufreq_policy
*policy
);
228 void cpufreq_stats_free_table(struct cpufreq_policy
*policy
);
229 void cpufreq_stats_record_transition(struct cpufreq_policy
*policy
,
230 unsigned int new_freq
);
232 static inline void cpufreq_stats_create_table(struct cpufreq_policy
*policy
) { }
233 static inline void cpufreq_stats_free_table(struct cpufreq_policy
*policy
) { }
234 static inline void cpufreq_stats_record_transition(struct cpufreq_policy
*policy
,
235 unsigned int new_freq
) { }
236 #endif /* CONFIG_CPU_FREQ_STAT */
238 /*********************************************************************
239 * CPUFREQ DRIVER INTERFACE *
240 *********************************************************************/
242 #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */
243 #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */
244 #define CPUFREQ_RELATION_C 2 /* closest frequency to target */
247 struct attribute attr
;
248 ssize_t (*show
)(struct cpufreq_policy
*, char *);
249 ssize_t (*store
)(struct cpufreq_policy
*, const char *, size_t count
);
252 #define cpufreq_freq_attr_ro(_name) \
253 static struct freq_attr _name = \
254 __ATTR(_name, 0444, show_##_name, NULL)
256 #define cpufreq_freq_attr_ro_perm(_name, _perm) \
257 static struct freq_attr _name = \
258 __ATTR(_name, _perm, show_##_name, NULL)
260 #define cpufreq_freq_attr_rw(_name) \
261 static struct freq_attr _name = \
262 __ATTR(_name, 0644, show_##_name, store_##_name)
264 #define cpufreq_freq_attr_wo(_name) \
265 static struct freq_attr _name = \
266 __ATTR(_name, 0200, NULL, store_##_name)
268 #define define_one_global_ro(_name) \
269 static struct kobj_attribute _name = \
270 __ATTR(_name, 0444, show_##_name, NULL)
272 #define define_one_global_rw(_name) \
273 static struct kobj_attribute _name = \
274 __ATTR(_name, 0644, show_##_name, store_##_name)
277 struct cpufreq_driver
{
278 char name
[CPUFREQ_NAME_LEN
];
282 /* needed by all drivers */
283 int (*init
)(struct cpufreq_policy
*policy
);
284 int (*verify
)(struct cpufreq_policy
*policy
);
286 /* define one out of two */
287 int (*setpolicy
)(struct cpufreq_policy
*policy
);
290 * On failure, should always restore frequency to policy->restore_freq
293 int (*target
)(struct cpufreq_policy
*policy
,
294 unsigned int target_freq
,
295 unsigned int relation
); /* Deprecated */
296 int (*target_index
)(struct cpufreq_policy
*policy
,
298 unsigned int (*fast_switch
)(struct cpufreq_policy
*policy
,
299 unsigned int target_freq
);
302 * Caches and returns the lowest driver-supported frequency greater than
303 * or equal to the target frequency, subject to any driver limitations.
304 * Does not set the frequency. Only to be implemented for drivers with
307 unsigned int (*resolve_freq
)(struct cpufreq_policy
*policy
,
308 unsigned int target_freq
);
311 * Only for drivers with target_index() and CPUFREQ_ASYNC_NOTIFICATION
314 * get_intermediate should return a stable intermediate frequency
315 * platform wants to switch to and target_intermediate() should set CPU
316 * to to that frequency, before jumping to the frequency corresponding
317 * to 'index'. Core will take care of sending notifications and driver
318 * doesn't have to handle them in target_intermediate() or
321 * Drivers can return '0' from get_intermediate() in case they don't
322 * wish to switch to intermediate frequency for some target frequency.
323 * In that case core will directly call ->target_index().
325 unsigned int (*get_intermediate
)(struct cpufreq_policy
*policy
,
327 int (*target_intermediate
)(struct cpufreq_policy
*policy
,
330 /* should be defined, if possible */
331 unsigned int (*get
)(unsigned int cpu
);
333 /* Called to update policy limits on firmware notifications. */
334 void (*update_limits
)(unsigned int cpu
);
337 int (*bios_limit
)(int cpu
, unsigned int *limit
);
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
);
346 /* Will be called after the driver is fully initialized */
347 void (*ready
)(struct cpufreq_policy
*policy
);
349 struct freq_attr
**attr
;
351 /* platform specific boost support code */
353 int (*set_boost
)(int state
);
358 /* driver isn't removed even if all ->init() calls failed */
359 #define CPUFREQ_STICKY BIT(0)
361 /* loops_per_jiffy or other kernel "constants" aren't affected by frequency transitions */
362 #define CPUFREQ_CONST_LOOPS BIT(1)
364 /* don't warn on suspend/resume speed mismatches */
365 #define CPUFREQ_PM_NO_WARN BIT(2)
368 * This should be set by platforms having multiple clock-domains, i.e.
369 * supporting multiple policies. With this sysfs directories of governor would
370 * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same
371 * governor with different tunables for different clusters.
373 #define CPUFREQ_HAVE_GOVERNOR_PER_POLICY BIT(3)
376 * Driver will do POSTCHANGE notifications from outside of their ->target()
377 * routine and so must set cpufreq_driver->flags with this flag, so that core
378 * can handle them specially.
380 #define CPUFREQ_ASYNC_NOTIFICATION BIT(4)
383 * Set by drivers which want cpufreq core to check if CPU is running at a
384 * frequency present in freq-table exposed by the driver. For these drivers if
385 * CPU is found running at an out of table freq, we will try to set it to a freq
386 * from the table. And if that fails, we will stop further boot process by
387 * issuing a BUG_ON().
389 #define CPUFREQ_NEED_INITIAL_FREQ_CHECK BIT(5)
392 * Set by drivers to disallow use of governors with "dynamic_switching" flag
395 #define CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING BIT(6)
398 * Set by drivers that want the core to automatically register the cpufreq
399 * driver as a thermal cooling device.
401 #define CPUFREQ_IS_COOLING_DEV BIT(7)
403 int cpufreq_register_driver(struct cpufreq_driver
*driver_data
);
404 int cpufreq_unregister_driver(struct cpufreq_driver
*driver_data
);
406 const char *cpufreq_get_current_driver(void);
407 void *cpufreq_get_driver_data(void);
409 static inline void cpufreq_verify_within_limits(struct cpufreq_policy
*policy
,
410 unsigned int min
, unsigned int max
)
412 if (policy
->min
< min
)
414 if (policy
->max
< min
)
416 if (policy
->min
> max
)
418 if (policy
->max
> max
)
420 if (policy
->min
> policy
->max
)
421 policy
->min
= policy
->max
;
426 cpufreq_verify_within_cpu_limits(struct cpufreq_policy
*policy
)
428 cpufreq_verify_within_limits(policy
, policy
->cpuinfo
.min_freq
,
429 policy
->cpuinfo
.max_freq
);
432 #ifdef CONFIG_CPU_FREQ
433 void cpufreq_suspend(void);
434 void cpufreq_resume(void);
435 int cpufreq_generic_suspend(struct cpufreq_policy
*policy
);
437 static inline void cpufreq_suspend(void) {}
438 static inline void cpufreq_resume(void) {}
441 /*********************************************************************
442 * CPUFREQ NOTIFIER INTERFACE *
443 *********************************************************************/
445 #define CPUFREQ_TRANSITION_NOTIFIER (0)
446 #define CPUFREQ_POLICY_NOTIFIER (1)
448 /* Transition notifiers */
449 #define CPUFREQ_PRECHANGE (0)
450 #define CPUFREQ_POSTCHANGE (1)
452 /* Policy Notifiers */
453 #define CPUFREQ_ADJUST (0)
454 #define CPUFREQ_NOTIFY (1)
456 #ifdef CONFIG_CPU_FREQ
457 int cpufreq_register_notifier(struct notifier_block
*nb
, unsigned int list
);
458 int cpufreq_unregister_notifier(struct notifier_block
*nb
, unsigned int list
);
460 void cpufreq_freq_transition_begin(struct cpufreq_policy
*policy
,
461 struct cpufreq_freqs
*freqs
);
462 void cpufreq_freq_transition_end(struct cpufreq_policy
*policy
,
463 struct cpufreq_freqs
*freqs
, int transition_failed
);
465 #else /* CONFIG_CPU_FREQ */
466 static inline int cpufreq_register_notifier(struct notifier_block
*nb
,
471 static inline int cpufreq_unregister_notifier(struct notifier_block
*nb
,
476 #endif /* !CONFIG_CPU_FREQ */
479 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch
486 * new = old * mult / div
488 static inline unsigned long cpufreq_scale(unsigned long old
, u_int div
,
491 #if BITS_PER_LONG == 32
492 u64 result
= ((u64
) old
) * ((u64
) mult
);
494 return (unsigned long) result
;
496 #elif BITS_PER_LONG == 64
497 unsigned long result
= old
* ((u64
) mult
);
503 /*********************************************************************
504 * CPUFREQ GOVERNORS *
505 *********************************************************************/
508 * If (cpufreq_driver->target) exists, the ->governor decides what frequency
509 * within the limits is used. If (cpufreq_driver->setpolicy> exists, these
510 * two generic policies are available:
512 #define CPUFREQ_POLICY_POWERSAVE (1)
513 #define CPUFREQ_POLICY_PERFORMANCE (2)
516 * The polling frequency depends on the capability of the processor. Default
517 * polling frequency is 1000 times the transition latency of the processor. The
518 * ondemand governor will work on any processor with transition latency <= 10ms,
519 * using appropriate sampling rate.
521 #define LATENCY_MULTIPLIER (1000)
523 struct 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
,
532 int (*store_setspeed
) (struct cpufreq_policy
*policy
,
534 /* For governors which change frequency dynamically by themselves */
535 bool dynamic_switching
;
536 struct list_head governor_list
;
537 struct module
*owner
;
540 /* Pass a target to the cpufreq driver */
541 unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy
*policy
,
542 unsigned int target_freq
);
543 int cpufreq_driver_target(struct cpufreq_policy
*policy
,
544 unsigned int target_freq
,
545 unsigned int relation
);
546 int __cpufreq_driver_target(struct cpufreq_policy
*policy
,
547 unsigned int target_freq
,
548 unsigned int relation
);
549 unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy
*policy
,
550 unsigned int target_freq
);
551 unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy
*policy
);
552 int cpufreq_register_governor(struct cpufreq_governor
*governor
);
553 void cpufreq_unregister_governor(struct cpufreq_governor
*governor
);
555 struct cpufreq_governor
*cpufreq_default_governor(void);
556 struct cpufreq_governor
*cpufreq_fallback_governor(void);
558 static inline void cpufreq_policy_apply_limits(struct cpufreq_policy
*policy
)
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
);
566 /* Governor attribute set */
567 struct gov_attr_set
{
569 struct list_head policy_list
;
570 struct mutex update_lock
;
574 /* sysfs ops for cpufreq governors */
575 extern const struct sysfs_ops governor_sysfs_ops
;
577 void gov_attr_set_init(struct gov_attr_set
*attr_set
, struct list_head
*list_node
);
578 void gov_attr_set_get(struct gov_attr_set
*attr_set
, struct list_head
*list_node
);
579 unsigned int gov_attr_set_put(struct gov_attr_set
*attr_set
, struct list_head
*list_node
);
581 /* Governor sysfs attribute */
582 struct 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
,
589 static inline bool cpufreq_this_cpu_can_update(struct cpufreq_policy
*policy
)
592 * Allow remote callbacks if:
593 * - dvfs_possible_from_any_cpu flag is set
594 * - the local and remote CPUs share cpufreq policy
596 return policy
->dvfs_possible_from_any_cpu
||
597 cpumask_test_cpu(smp_processor_id(), policy
->cpus
);
600 /*********************************************************************
601 * FREQUENCY TABLE HELPERS *
602 *********************************************************************/
604 /* Special Values of .frequency field */
605 #define CPUFREQ_ENTRY_INVALID ~0u
606 #define CPUFREQ_TABLE_END ~1u
607 /* Special Values of .flags field */
608 #define CPUFREQ_BOOST_FREQ (1 << 0)
610 struct cpufreq_frequency_table
{
612 unsigned int driver_data
; /* driver specific data, not used by core */
613 unsigned int frequency
; /* kHz - doesn't need to be in ascending
617 #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
618 int dev_pm_opp_init_cpufreq_table(struct device
*dev
,
619 struct cpufreq_frequency_table
**table
);
620 void dev_pm_opp_free_cpufreq_table(struct device
*dev
,
621 struct cpufreq_frequency_table
**table
);
623 static inline int dev_pm_opp_init_cpufreq_table(struct device
*dev
,
624 struct cpufreq_frequency_table
630 static inline void dev_pm_opp_free_cpufreq_table(struct device
*dev
,
631 struct cpufreq_frequency_table
638 * cpufreq_for_each_entry - iterate over a cpufreq_frequency_table
639 * @pos: the cpufreq_frequency_table * to use as a loop cursor.
640 * @table: the cpufreq_frequency_table * to iterate over.
643 #define cpufreq_for_each_entry(pos, table) \
644 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)
647 * cpufreq_for_each_entry_idx - iterate over a cpufreq_frequency_table
649 * @pos: the cpufreq_frequency_table * to use as a loop cursor.
650 * @table: the cpufreq_frequency_table * to iterate over.
651 * @idx: the table entry currently being processed
654 #define cpufreq_for_each_entry_idx(pos, table, idx) \
655 for (pos = table, idx = 0; pos->frequency != CPUFREQ_TABLE_END; \
659 * cpufreq_for_each_valid_entry - iterate over a cpufreq_frequency_table
660 * excluding CPUFREQ_ENTRY_INVALID frequencies.
661 * @pos: the cpufreq_frequency_table * to use as a loop cursor.
662 * @table: the cpufreq_frequency_table * to iterate over.
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) \
672 * cpufreq_for_each_valid_entry_idx - iterate with index over a cpufreq
673 * frequency_table excluding CPUFREQ_ENTRY_INVALID frequencies.
674 * @pos: the cpufreq_frequency_table * to use as a loop cursor.
675 * @table: the cpufreq_frequency_table * to iterate over.
676 * @idx: the table entry currently being processed
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) \
686 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy
*policy
,
687 struct cpufreq_frequency_table
*table
);
689 int cpufreq_frequency_table_verify(struct cpufreq_policy
*policy
,
690 struct cpufreq_frequency_table
*table
);
691 int cpufreq_generic_frequency_table_verify(struct cpufreq_policy
*policy
);
693 int cpufreq_table_index_unsorted(struct cpufreq_policy
*policy
,
694 unsigned int target_freq
,
695 unsigned int relation
);
696 int cpufreq_frequency_table_get_index(struct cpufreq_policy
*policy
,
699 ssize_t
cpufreq_show_cpus(const struct cpumask
*mask
, char *buf
);
701 #ifdef CONFIG_CPU_FREQ
702 int cpufreq_boost_trigger_state(int state
);
703 int cpufreq_boost_enabled(void);
704 int cpufreq_enable_boost_support(void);
705 bool policy_has_boost_freq(struct cpufreq_policy
*policy
);
707 /* Find lowest freq at or above target in a table in ascending order */
708 static inline int cpufreq_table_find_index_al(struct cpufreq_policy
*policy
,
709 unsigned int target_freq
)
711 struct cpufreq_frequency_table
*table
= policy
->freq_table
;
712 struct cpufreq_frequency_table
*pos
;
716 cpufreq_for_each_valid_entry_idx(pos
, table
, idx
) {
717 freq
= pos
->frequency
;
719 if (freq
>= target_freq
)
728 /* Find lowest freq at or above target in a table in descending order */
729 static inline int cpufreq_table_find_index_dl(struct cpufreq_policy
*policy
,
730 unsigned int target_freq
)
732 struct cpufreq_frequency_table
*table
= policy
->freq_table
;
733 struct cpufreq_frequency_table
*pos
;
737 cpufreq_for_each_valid_entry_idx(pos
, table
, idx
) {
738 freq
= pos
->frequency
;
740 if (freq
== target_freq
)
743 if (freq
> target_freq
) {
748 /* No freq found above target_freq */
758 /* Works only on sorted freq-tables */
759 static inline int cpufreq_table_find_index_l(struct cpufreq_policy
*policy
,
760 unsigned int target_freq
)
762 target_freq
= clamp_val(target_freq
, policy
->min
, policy
->max
);
764 if (policy
->freq_table_sorted
== CPUFREQ_TABLE_SORTED_ASCENDING
)
765 return cpufreq_table_find_index_al(policy
, target_freq
);
767 return cpufreq_table_find_index_dl(policy
, target_freq
);
770 /* Find highest freq at or below target in a table in ascending order */
771 static inline int cpufreq_table_find_index_ah(struct cpufreq_policy
*policy
,
772 unsigned int target_freq
)
774 struct cpufreq_frequency_table
*table
= policy
->freq_table
;
775 struct cpufreq_frequency_table
*pos
;
779 cpufreq_for_each_valid_entry_idx(pos
, table
, idx
) {
780 freq
= pos
->frequency
;
782 if (freq
== target_freq
)
785 if (freq
< target_freq
) {
790 /* No freq found below target_freq */
800 /* Find highest freq at or below target in a table in descending order */
801 static inline int cpufreq_table_find_index_dh(struct cpufreq_policy
*policy
,
802 unsigned int target_freq
)
804 struct cpufreq_frequency_table
*table
= policy
->freq_table
;
805 struct cpufreq_frequency_table
*pos
;
809 cpufreq_for_each_valid_entry_idx(pos
, table
, idx
) {
810 freq
= pos
->frequency
;
812 if (freq
<= target_freq
)
821 /* Works only on sorted freq-tables */
822 static inline int cpufreq_table_find_index_h(struct cpufreq_policy
*policy
,
823 unsigned int target_freq
)
825 target_freq
= clamp_val(target_freq
, policy
->min
, policy
->max
);
827 if (policy
->freq_table_sorted
== CPUFREQ_TABLE_SORTED_ASCENDING
)
828 return cpufreq_table_find_index_ah(policy
, target_freq
);
830 return cpufreq_table_find_index_dh(policy
, target_freq
);
833 /* Find closest freq to target in a table in ascending order */
834 static inline int cpufreq_table_find_index_ac(struct cpufreq_policy
*policy
,
835 unsigned int target_freq
)
837 struct cpufreq_frequency_table
*table
= policy
->freq_table
;
838 struct cpufreq_frequency_table
*pos
;
842 cpufreq_for_each_valid_entry_idx(pos
, table
, idx
) {
843 freq
= pos
->frequency
;
845 if (freq
== target_freq
)
848 if (freq
< target_freq
) {
853 /* No freq found below target_freq */
857 /* Choose the closest freq */
858 if (target_freq
- table
[best
].frequency
> freq
- target_freq
)
867 /* Find closest freq to target in a table in descending order */
868 static inline int cpufreq_table_find_index_dc(struct cpufreq_policy
*policy
,
869 unsigned int target_freq
)
871 struct cpufreq_frequency_table
*table
= policy
->freq_table
;
872 struct cpufreq_frequency_table
*pos
;
876 cpufreq_for_each_valid_entry_idx(pos
, table
, idx
) {
877 freq
= pos
->frequency
;
879 if (freq
== target_freq
)
882 if (freq
> target_freq
) {
887 /* No freq found above target_freq */
891 /* Choose the closest freq */
892 if (table
[best
].frequency
- target_freq
> target_freq
- freq
)
901 /* Works only on sorted freq-tables */
902 static inline int cpufreq_table_find_index_c(struct cpufreq_policy
*policy
,
903 unsigned int target_freq
)
905 target_freq
= clamp_val(target_freq
, policy
->min
, policy
->max
);
907 if (policy
->freq_table_sorted
== CPUFREQ_TABLE_SORTED_ASCENDING
)
908 return cpufreq_table_find_index_ac(policy
, target_freq
);
910 return cpufreq_table_find_index_dc(policy
, target_freq
);
913 static inline int cpufreq_frequency_table_target(struct cpufreq_policy
*policy
,
914 unsigned int target_freq
,
915 unsigned int relation
)
917 if (unlikely(policy
->freq_table_sorted
== CPUFREQ_TABLE_UNSORTED
))
918 return cpufreq_table_index_unsorted(policy
, target_freq
,
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
);
929 pr_err("%s: Invalid relation: %d\n", __func__
, relation
);
934 static inline int cpufreq_table_count_valid_entries(const struct cpufreq_policy
*policy
)
936 struct cpufreq_frequency_table
*pos
;
939 if (unlikely(!policy
->freq_table
))
942 cpufreq_for_each_valid_entry(pos
, policy
->freq_table
)
948 static inline int cpufreq_boost_trigger_state(int state
)
952 static inline int cpufreq_boost_enabled(void)
957 static inline int cpufreq_enable_boost_support(void)
962 static inline bool policy_has_boost_freq(struct cpufreq_policy
*policy
)
968 #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
969 void sched_cpufreq_governor_change(struct cpufreq_policy
*policy
,
970 struct cpufreq_governor
*old_gov
);
972 static inline void sched_cpufreq_governor_change(struct cpufreq_policy
*policy
,
973 struct cpufreq_governor
*old_gov
) { }
976 extern void arch_freq_prepare_all(void);
977 extern unsigned int arch_freq_get_on_cpu(int cpu
);
979 extern void arch_set_freq_scale(struct cpumask
*cpus
, unsigned long cur_freq
,
980 unsigned long max_freq
);
982 /* the following are really really optional */
983 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs
;
984 extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs
;
985 extern struct freq_attr
*cpufreq_generic_attr
[];
986 int cpufreq_table_validate_and_sort(struct cpufreq_policy
*policy
);
988 unsigned int cpufreq_generic_get(unsigned int cpu
);
989 int cpufreq_generic_init(struct cpufreq_policy
*policy
,
990 struct cpufreq_frequency_table
*table
,
991 unsigned int transition_latency
);
992 #endif /* _LINUX_CPUFREQ_H */