/* SPDX-License-Identifier: GPL-2.0-only */ /* * linux/include/linux/cpufreq.h * * Copyright (C) 2001 Russell King * (C) 2002 - 2003 Dominik Brodowski <[email protected]> */ #ifndef _LINUX_CPUFREQ_H #define _LINUX_CPUFREQ_H #include <linux/clk.h> #include <linux/cpu.h> #include <linux/cpumask.h> #include <linux/completion.h> #include <linux/kobject.h> #include <linux/notifier.h> #include <linux/of.h> #include <linux/pm_opp.h> #include <linux/pm_qos.h> #include <linux/spinlock.h> #include <linux/sysfs.h> #include <linux/minmax.h> /********************************************************************* * CPUFREQ INTERFACE * *********************************************************************/ /* * Frequency values here are CPU kHz * * Maximum transition latency is in nanoseconds - if it's unknown, * CPUFREQ_ETERNAL shall be used. */ #define CPUFREQ_ETERNAL … #define CPUFREQ_NAME_LEN … /* Print length for names. Extra 1 space for accommodating '\n' in prints */ #define CPUFREQ_NAME_PLEN … struct cpufreq_governor; enum cpufreq_table_sorting { … }; struct cpufreq_cpuinfo { … }; struct cpufreq_policy { … }; /* * Used for passing new cpufreq policy data to the cpufreq driver's ->verify() * callback for sanitization. That callback is only expected to modify the min * and max values, if necessary, and specifically it must not update the * frequency table. */ struct cpufreq_policy_data { … }; struct cpufreq_freqs { … }; /* Only for ACPI */ #define CPUFREQ_SHARED_TYPE_NONE … #define CPUFREQ_SHARED_TYPE_HW … #define CPUFREQ_SHARED_TYPE_ALL … #define CPUFREQ_SHARED_TYPE_ANY … #ifdef CONFIG_CPU_FREQ struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu); struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu); void cpufreq_cpu_put(struct cpufreq_policy *policy); #else static inline struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu) { return NULL; } static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu) { return NULL; } static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { } #endif static inline bool policy_is_inactive(struct cpufreq_policy *policy) { … } static inline bool policy_is_shared(struct cpufreq_policy *policy) { … } #ifdef CONFIG_CPU_FREQ unsigned int cpufreq_get(unsigned int cpu); unsigned int cpufreq_quick_get(unsigned int cpu); unsigned int cpufreq_quick_get_max(unsigned int cpu); unsigned int cpufreq_get_hw_max_freq(unsigned int cpu); void disable_cpufreq(void); u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy); struct cpufreq_policy *cpufreq_cpu_acquire(unsigned int cpu); void cpufreq_cpu_release(struct cpufreq_policy *policy); int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu); void refresh_frequency_limits(struct cpufreq_policy *policy); void cpufreq_update_policy(unsigned int cpu); void cpufreq_update_limits(unsigned int cpu); bool have_governor_per_policy(void); bool cpufreq_supports_freq_invariance(void); struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy); void cpufreq_enable_fast_switch(struct cpufreq_policy *policy); void cpufreq_disable_fast_switch(struct cpufreq_policy *policy); bool has_target_index(void); DECLARE_PER_CPU(unsigned long, cpufreq_pressure); static inline unsigned long cpufreq_get_pressure(int cpu) { … } #else static inline unsigned int cpufreq_get(unsigned int cpu) { return 0; } static inline unsigned int cpufreq_quick_get(unsigned int cpu) { return 0; } static inline unsigned int cpufreq_quick_get_max(unsigned int cpu) { return 0; } static inline unsigned int cpufreq_get_hw_max_freq(unsigned int cpu) { return 0; } static inline bool cpufreq_supports_freq_invariance(void) { return false; } static inline void disable_cpufreq(void) { } static inline void cpufreq_update_limits(unsigned int cpu) { } static inline unsigned long cpufreq_get_pressure(int cpu) { return 0; } #endif #ifdef CONFIG_CPU_FREQ_STAT void cpufreq_stats_create_table(struct cpufreq_policy *policy); void cpufreq_stats_free_table(struct cpufreq_policy *policy); void cpufreq_stats_record_transition(struct cpufreq_policy *policy, unsigned int new_freq); #else static inline void cpufreq_stats_create_table(struct cpufreq_policy *policy) { } static inline void cpufreq_stats_free_table(struct cpufreq_policy *policy) { } static inline void cpufreq_stats_record_transition(struct cpufreq_policy *policy, unsigned int new_freq) { } #endif /* CONFIG_CPU_FREQ_STAT */ /********************************************************************* * CPUFREQ DRIVER INTERFACE * *********************************************************************/ #define CPUFREQ_RELATION_L … #define CPUFREQ_RELATION_H … #define CPUFREQ_RELATION_C … /* relation flags */ #define CPUFREQ_RELATION_E … #define CPUFREQ_RELATION_LE … #define CPUFREQ_RELATION_HE … #define CPUFREQ_RELATION_CE … struct freq_attr { … }; #define cpufreq_freq_attr_ro(_name) … #define cpufreq_freq_attr_ro_perm(_name, _perm) … #define cpufreq_freq_attr_rw(_name) … #define cpufreq_freq_attr_wo(_name) … #define define_one_global_ro(_name) … #define define_one_global_rw(_name) … struct cpufreq_driver { … }; /* flags */ /* * Set by drivers that need to update internal upper and lower boundaries along * with the target frequency and so the core and governors should also invoke * the diver if the target frequency does not change, but the policy min or max * may have changed. */ #define CPUFREQ_NEED_UPDATE_LIMITS … /* loops_per_jiffy or other kernel "constants" aren't affected by frequency transitions */ #define CPUFREQ_CONST_LOOPS … /* * Set by drivers that want the core to automatically register the cpufreq * driver as a thermal cooling device. */ #define CPUFREQ_IS_COOLING_DEV … /* * This should be set by platforms having multiple clock-domains, i.e. * supporting multiple policies. With this sysfs directories of governor would * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same * governor with different tunables for different clusters. */ #define CPUFREQ_HAVE_GOVERNOR_PER_POLICY … /* * Driver will do POSTCHANGE notifications from outside of their ->target() * routine and so must set cpufreq_driver->flags with this flag, so that core * can handle them specially. */ #define CPUFREQ_ASYNC_NOTIFICATION … /* * Set by drivers which want cpufreq core to check if CPU is running at a * frequency present in freq-table exposed by the driver. For these drivers if * CPU is found running at an out of table freq, we will try to set it to a freq * from the table. And if that fails, we will stop further boot process by * issuing a BUG_ON(). */ #define CPUFREQ_NEED_INITIAL_FREQ_CHECK … /* * Set by drivers to disallow use of governors with "dynamic_switching" flag * set. */ #define CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING … int cpufreq_register_driver(struct cpufreq_driver *driver_data); void cpufreq_unregister_driver(struct cpufreq_driver *driver_data); bool cpufreq_driver_test_flags(u16 flags); const char *cpufreq_get_current_driver(void); void *cpufreq_get_driver_data(void); static inline int cpufreq_thermal_control_enabled(struct cpufreq_driver *drv) { … } static inline void cpufreq_verify_within_limits(struct cpufreq_policy_data *policy, unsigned int min, unsigned int max) { … } static inline void cpufreq_verify_within_cpu_limits(struct cpufreq_policy_data *policy) { … } #ifdef CONFIG_CPU_FREQ void cpufreq_suspend(void); void cpufreq_resume(void); int cpufreq_generic_suspend(struct cpufreq_policy *policy); #else static inline void cpufreq_suspend(void) {} static inline void cpufreq_resume(void) {} #endif /********************************************************************* * CPUFREQ NOTIFIER INTERFACE * *********************************************************************/ #define CPUFREQ_TRANSITION_NOTIFIER … #define CPUFREQ_POLICY_NOTIFIER … /* Transition notifiers */ #define CPUFREQ_PRECHANGE … #define CPUFREQ_POSTCHANGE … /* Policy Notifiers */ #define CPUFREQ_CREATE_POLICY … #define CPUFREQ_REMOVE_POLICY … #ifdef CONFIG_CPU_FREQ int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list); int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list); void cpufreq_freq_transition_begin(struct cpufreq_policy *policy, struct cpufreq_freqs *freqs); void cpufreq_freq_transition_end(struct cpufreq_policy *policy, struct cpufreq_freqs *freqs, int transition_failed); #else /* CONFIG_CPU_FREQ */ static inline int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list) { return 0; } static inline int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list) { return 0; } #endif /* !CONFIG_CPU_FREQ */ /** * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch * safe) * @old: old value * @div: divisor * @mult: multiplier * * * new = old * mult / div */ static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mult) { … } /********************************************************************* * CPUFREQ GOVERNORS * *********************************************************************/ #define CPUFREQ_POLICY_UNKNOWN … /* * If (cpufreq_driver->target) exists, the ->governor decides what frequency * within the limits is used. If (cpufreq_driver->setpolicy> exists, these * two generic policies are available: */ #define CPUFREQ_POLICY_POWERSAVE … #define CPUFREQ_POLICY_PERFORMANCE … /* * The polling frequency depends on the capability of the processor. Default * polling frequency is 1000 times the transition latency of the processor. */ #define LATENCY_MULTIPLIER … struct cpufreq_governor { … }; /* Governor flags */ /* For governors which change frequency dynamically by themselves */ #define CPUFREQ_GOV_DYNAMIC_SWITCHING … /* For governors wanting the target frequency to be set exactly */ #define CPUFREQ_GOV_STRICT_TARGET … /* Pass a target to the cpufreq driver */ unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy, unsigned int target_freq); void cpufreq_driver_adjust_perf(unsigned int cpu, unsigned long min_perf, unsigned long target_perf, unsigned long capacity); bool cpufreq_driver_has_adjust_perf(void); int cpufreq_driver_target(struct cpufreq_policy *policy, unsigned int target_freq, unsigned int relation); int __cpufreq_driver_target(struct cpufreq_policy *policy, unsigned int target_freq, unsigned int relation); unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy, unsigned int target_freq); unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy *policy); int cpufreq_register_governor(struct cpufreq_governor *governor); void cpufreq_unregister_governor(struct cpufreq_governor *governor); int cpufreq_start_governor(struct cpufreq_policy *policy); void cpufreq_stop_governor(struct cpufreq_policy *policy); #define cpufreq_governor_init(__governor) … #define cpufreq_governor_exit(__governor) … struct cpufreq_governor *cpufreq_default_governor(void); struct cpufreq_governor *cpufreq_fallback_governor(void); static inline void cpufreq_policy_apply_limits(struct cpufreq_policy *policy) { … } /* Governor attribute set */ struct gov_attr_set { … }; /* sysfs ops for cpufreq governors */ extern const struct sysfs_ops governor_sysfs_ops; static inline struct gov_attr_set *to_gov_attr_set(struct kobject *kobj) { … } void gov_attr_set_init(struct gov_attr_set *attr_set, struct list_head *list_node); void gov_attr_set_get(struct gov_attr_set *attr_set, struct list_head *list_node); unsigned int gov_attr_set_put(struct gov_attr_set *attr_set, struct list_head *list_node); /* Governor sysfs attribute */ struct governor_attr { … }; /********************************************************************* * FREQUENCY TABLE HELPERS * *********************************************************************/ /* Special Values of .frequency field */ #define CPUFREQ_ENTRY_INVALID … #define CPUFREQ_TABLE_END … /* Special Values of .flags field */ #define CPUFREQ_BOOST_FREQ … #define CPUFREQ_INEFFICIENT_FREQ … struct cpufreq_frequency_table { … }; /* * cpufreq_for_each_entry - iterate over a cpufreq_frequency_table * @pos: the cpufreq_frequency_table * to use as a loop cursor. * @table: the cpufreq_frequency_table * to iterate over. */ #define cpufreq_for_each_entry(pos, table) … /* * cpufreq_for_each_entry_idx - iterate over a cpufreq_frequency_table * with index * @pos: the cpufreq_frequency_table * to use as a loop cursor. * @table: the cpufreq_frequency_table * to iterate over. * @idx: the table entry currently being processed */ #define cpufreq_for_each_entry_idx(pos, table, idx) … /* * cpufreq_for_each_valid_entry - iterate over a cpufreq_frequency_table * excluding CPUFREQ_ENTRY_INVALID frequencies. * @pos: the cpufreq_frequency_table * to use as a loop cursor. * @table: the cpufreq_frequency_table * to iterate over. */ #define cpufreq_for_each_valid_entry(pos, table) … /* * cpufreq_for_each_valid_entry_idx - iterate with index over a cpufreq * frequency_table excluding CPUFREQ_ENTRY_INVALID frequencies. * @pos: the cpufreq_frequency_table * to use as a loop cursor. * @table: the cpufreq_frequency_table * to iterate over. * @idx: the table entry currently being processed */ #define cpufreq_for_each_valid_entry_idx(pos, table, idx) … /** * cpufreq_for_each_efficient_entry_idx - iterate with index over a cpufreq * frequency_table excluding CPUFREQ_ENTRY_INVALID and * CPUFREQ_INEFFICIENT_FREQ frequencies. * @pos: the &struct cpufreq_frequency_table to use as a loop cursor. * @table: the &struct cpufreq_frequency_table to iterate over. * @idx: the table entry currently being processed. * @efficiencies: set to true to only iterate over efficient frequencies. */ #define cpufreq_for_each_efficient_entry_idx(pos, table, idx, efficiencies) … int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, struct cpufreq_frequency_table *table); int cpufreq_frequency_table_verify(struct cpufreq_policy_data *policy, struct cpufreq_frequency_table *table); int cpufreq_generic_frequency_table_verify(struct cpufreq_policy_data *policy); int cpufreq_table_index_unsorted(struct cpufreq_policy *policy, unsigned int target_freq, unsigned int relation); int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy, unsigned int freq); ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf); #ifdef CONFIG_CPU_FREQ int cpufreq_boost_trigger_state(int state); bool cpufreq_boost_enabled(void); int cpufreq_enable_boost_support(void); bool policy_has_boost_freq(struct cpufreq_policy *policy); /* Find lowest freq at or above target in a table in ascending order */ static inline int cpufreq_table_find_index_al(struct cpufreq_policy *policy, unsigned int target_freq, bool efficiencies) { … } /* Find lowest freq at or above target in a table in descending order */ static inline int cpufreq_table_find_index_dl(struct cpufreq_policy *policy, unsigned int target_freq, bool efficiencies) { … } /* Works only on sorted freq-tables */ static inline int cpufreq_table_find_index_l(struct cpufreq_policy *policy, unsigned int target_freq, bool efficiencies) { … } /* Find highest freq at or below target in a table in ascending order */ static inline int cpufreq_table_find_index_ah(struct cpufreq_policy *policy, unsigned int target_freq, bool efficiencies) { … } /* Find highest freq at or below target in a table in descending order */ static inline int cpufreq_table_find_index_dh(struct cpufreq_policy *policy, unsigned int target_freq, bool efficiencies) { … } /* Works only on sorted freq-tables */ static inline int cpufreq_table_find_index_h(struct cpufreq_policy *policy, unsigned int target_freq, bool efficiencies) { … } /* Find closest freq to target in a table in ascending order */ static inline int cpufreq_table_find_index_ac(struct cpufreq_policy *policy, unsigned int target_freq, bool efficiencies) { … } /* Find closest freq to target in a table in descending order */ static inline int cpufreq_table_find_index_dc(struct cpufreq_policy *policy, unsigned int target_freq, bool efficiencies) { … } /* Works only on sorted freq-tables */ static inline int cpufreq_table_find_index_c(struct cpufreq_policy *policy, unsigned int target_freq, bool efficiencies) { … } static inline bool cpufreq_is_in_limits(struct cpufreq_policy *policy, int idx) { … } static inline int cpufreq_frequency_table_target(struct cpufreq_policy *policy, unsigned int target_freq, unsigned int relation) { … } static inline int cpufreq_table_count_valid_entries(const struct cpufreq_policy *policy) { … } /** * cpufreq_table_set_inefficient() - Mark a frequency as inefficient * @policy: the &struct cpufreq_policy containing the inefficient frequency * @frequency: the inefficient frequency * * The &struct cpufreq_policy must use a sorted frequency table * * Return: %0 on success or a negative errno code */ static inline int cpufreq_table_set_inefficient(struct cpufreq_policy *policy, unsigned int frequency) { … } static inline int parse_perf_domain(int cpu, const char *list_name, const char *cell_name, struct of_phandle_args *args) { … } static inline int of_perf_domain_get_sharing_cpumask(int pcpu, const char *list_name, const char *cell_name, struct cpumask *cpumask, struct of_phandle_args *pargs) { … } #else static inline int cpufreq_boost_trigger_state(int state) { return 0; } static inline bool cpufreq_boost_enabled(void) { return false; } static inline int cpufreq_enable_boost_support(void) { return -EINVAL; } static inline bool policy_has_boost_freq(struct cpufreq_policy *policy) { return false; } static inline int cpufreq_table_set_inefficient(struct cpufreq_policy *policy, unsigned int frequency) { return -EINVAL; } static inline int of_perf_domain_get_sharing_cpumask(int pcpu, const char *list_name, const char *cell_name, struct cpumask *cpumask, struct of_phandle_args *pargs) { return -EOPNOTSUPP; } #endif extern unsigned int arch_freq_get_on_cpu(int cpu); #ifndef arch_set_freq_scale static __always_inline void arch_set_freq_scale(const struct cpumask *cpus, unsigned long cur_freq, unsigned long max_freq) { … } #endif /* the following are really really optional */ extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs; extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs; extern struct freq_attr *cpufreq_generic_attr[]; int cpufreq_table_validate_and_sort(struct cpufreq_policy *policy); unsigned int cpufreq_generic_get(unsigned int cpu); void cpufreq_generic_init(struct cpufreq_policy *policy, struct cpufreq_frequency_table *table, unsigned int transition_latency); static inline void cpufreq_register_em_with_opp(struct cpufreq_policy *policy) { … } #endif /* _LINUX_CPUFREQ_H */
Codebase Browser
linux