Quellcode-Bibliothek cpufreq.c
Sprache: C
// SPDX-License-Identifier: GPL-2.0-only /* * linux / drivers / cpufreq / cpufreq . c * * Copyright ( C ) 2001 Russell King * ( C ) 2002 - 2003 Dominik Brodowski < linux @ brodo . de > * ( C ) 2013 Viresh Kumar < viresh . kumar @ linaro . org > * * Oct 2005 - Ashok Raj < ashok . raj @ intel . com > * Added handling for CPU hotplug * Feb 2006 - Jacob Shin < jacob . shin @ amd . com > * Fix handling for CPU hotplug - - affected CPUs #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt#include <linux/cpu.h>#include <linux/cpufreq.h>#include <linux/cpu_cooling.h>#include <linux/delay.h>#include <linux/device.h>#include <linux/init.h>#include <linux/kernel_stat.h>#include <linux/module.h>#include <linux/mutex.h>#include <linux/pm_qos.h>#include <linux/slab.h>#include <linux/string_choices.h>#include <linux/suspend.h>#include <linux/syscore_ops.h>#include <linux/tick.h>#include <linux/units.h>#include <trace/events/power.h>static LIST_HEAD(cpufreq_policy_list);/* Macros to iterate over CPU policies */ #define for_each_suitable_policy(__policy, __active) \if ((__active) == !policy_is_inactive(__policy))#define for_each_active_policy(__policy) \true )#define for_each_inactive_policy(__policy) \false )/* Iterate over governors */ static LIST_HEAD(cpufreq_governor_list);#define for_each_governor(__governor) \static char default_governor[CPUFREQ_NAME_LEN];/* * The " cpufreq driver " - the arch - or hardware - dependent low * level driver of CPUFreq support , and its spinlock . This lock * also protects the cpufreq_cpu_data array . static struct cpufreq_driver *cpufreq_driver;static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);static DEFINE_RWLOCK(cpufreq_driver_lock);static DEFINE_STATIC_KEY_FALSE(cpufreq_freq_invariance);bool cpufreq_supports_freq_invariance(void )return static_branch_likely(&cpufreq_freq_invariance);/* Flag to suspend/resume CPUFreq governors */ static bool cpufreq_suspended;static inline bool has_target(void )return cpufreq_driver->target_index || cpufreq_driver->target;bool has_target_index(void )return !!cpufreq_driver->target_index;/* internal prototypes */ static unsigned int __cpufreq_get(struct cpufreq_policy *policy);static int cpufreq_init_governor(struct cpufreq_policy *policy);static void cpufreq_exit_governor(struct cpufreq_policy *policy);static void cpufreq_governor_limits(struct cpufreq_policy *policy);static int cpufreq_set_policy(struct cpufreq_policy *policy,struct cpufreq_governor *new_gov,unsigned int new_pol);static bool cpufreq_boost_supported(void );static int cpufreq_boost_trigger_state(int state);/* * Two notifier lists : the " policy " list is involved in the * validation process for a new CPU frequency policy ; the * " transition " list for kernel code that needs to handle * changes to devices when the CPU clock speed changes . * The mutex locks both lists . static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);static int off __read_mostly;static int cpufreq_disabled(void )return off;void disable_cpufreq(void )1 ;static DEFINE_MUTEX(cpufreq_governor_mutex);bool have_governor_per_policy(void )return !!(cpufreq_driver->flags & CPUFREQ_HAVE_GOVERNOR_PER_POLICY);static struct kobject *cpufreq_global_kobject;struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)if (have_governor_per_policy())return &policy->kobj;else return cpufreq_global_kobject;static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)struct kernel_cpustat kcpustat;if (wall)return div_u64(idle_time, NSEC_PER_USEC);unsigned int cpu, u64 *wall, int io_busy)if (idle_time == -1 ULL)return get_cpu_idle_time_jiffy(cpu, wall);else if (!io_busy)return idle_time;/* * This is a generic cpufreq init ( ) routine which can be used by cpufreq * drivers of SMP systems . It will do following : * - validate & show freq table passed * - set policies transition latency * - policy - > cpus with all possible CPUs void cpufreq_generic_init(struct cpufreq_policy *policy,struct cpufreq_frequency_table *table,unsigned int transition_latency)/* * The driver only supports the SMP configuration where all processors * share the clock and voltage and clock . struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);return policy && cpumask_test_cpu(cpu, policy->cpus) ? policy : NULL;unsigned int cpufreq_generic_get(unsigned int cpu)struct cpufreq_policy *policy = cpufreq_cpu_get_raw(cpu);if (!policy || IS_ERR(policy->clk)) {"%s: No %s associated to cpu: %d\n" ,"clk" : "policy" , cpu);return 0 ;return clk_get_rate(policy->clk) / 1000 ;/** * cpufreq_cpu_get - Return policy for a CPU and mark it as busy . * @ cpu : CPU to find the policy for . * * Call cpufreq_cpu_get_raw ( ) to obtain a cpufreq policy for @ cpu and increment * the kobject reference counter of that policy . Return a valid policy on * success or NULL on failure . * * The policy returned by this function has to be released with the help of * cpufreq_cpu_put ( ) to balance its kobject reference counter properly . struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)struct cpufreq_policy *policy = NULL;unsigned long flags;if (WARN_ON(cpu >= nr_cpu_ids))return NULL;/* get the cpufreq driver */ if (cpufreq_driver) {/* get the CPU */ if (policy)return policy;/** * cpufreq_cpu_put - Decrement kobject usage counter for cpufreq policy . * @ policy : cpufreq policy returned by cpufreq_cpu_get ( ) . void cpufreq_cpu_put(struct cpufreq_policy *policy)/********************************************************************* * EXTERNALLY AFFECTING FREQUENCY CHANGES * /** * adjust_jiffies - Adjust the system " loops_per_jiffy " . * @ val : CPUFREQ_PRECHANGE or CPUFREQ_POSTCHANGE . * @ ci : Frequency change information . * * This function alters the system " loops_per_jiffy " for the clock * speed change . Note that loops_per_jiffy cannot be updated on SMP * systems as each CPU might be scaled differently . So , use the arch * per - CPU loops_per_jiffy value wherever possible . static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)#ifndef CONFIG_SMPstatic unsigned long l_p_j_ref;static unsigned int l_p_j_ref_freq;if (ci->flags & CPUFREQ_CONST_LOOPS)return ;if (!l_p_j_ref_freq) {"saving %lu as reference value for loops_per_jiffy; freq is %u kHz\n" ,if (val == CPUFREQ_POSTCHANGE && ci->old != ci->new ) {new );"scaling loops_per_jiffy to %lu for frequency %u kHz\n" ,new );#endif /** * cpufreq_notify_transition - Notify frequency transition and adjust jiffies . * @ policy : cpufreq policy to enable fast frequency switching for . * @ freqs : contain details of the frequency update . * @ state : set to CPUFREQ_PRECHANGE or CPUFREQ_POSTCHANGE . * * This function calls the transition notifiers and adjust_jiffies ( ) . * * It is called twice on all CPU frequency changes that have external effects . static void cpufreq_notify_transition(struct cpufreq_policy *policy,struct cpufreq_freqs *freqs,unsigned int state)int cpu;if (cpufreq_disabled())return ;"notification %u of frequency transition to %u kHz\n" ,new );switch (state) {case CPUFREQ_PRECHANGE:/* * Detect if the driver reported a value as " old frequency " * which is not equal to what the cpufreq core thinks is * " old frequency " . if (policy->cur && policy->cur != freqs->old) {"Warning: CPU frequency is %u, cpufreq assumed %u kHz\n" ,break ;case CPUFREQ_POSTCHANGE:"FREQ: %u - CPUs: %*pbl\n" , freqs->new ,new , cpu);new );new ;/* Do post notifications when there are chances that transition has failed */ static void cpufreq_notify_post_transition(struct cpufreq_policy *policy,struct cpufreq_freqs *freqs, int transition_failed)if (!transition_failed)return ;new );void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,struct cpufreq_freqs *freqs)/* * Catch double invocations of _ begin ( ) which lead to self - deadlock . * ASYNC_NOTIFICATION drivers are left out because the cpufreq core * doesn ' t invoke _ begin ( ) on their behalf , and hence the chances of * double invocations are very low . Moreover , there are scenarios * where these checks can emit false - positive warnings in these * drivers ; so we avoid that by skipping them altogether . if (unlikely(policy->transition_ongoing)) {goto wait;true ;void cpufreq_freq_transition_end(struct cpufreq_policy *policy,struct cpufreq_freqs *freqs, int transition_failed)if (WARN_ON(!policy->transition_ongoing))return ;false ;/* * Fast frequency switching status count . Positive means " enabled " , negative * means " disabled " and 0 means " not decided yet " . static int cpufreq_fast_switch_count;static DEFINE_MUTEX(cpufreq_fast_switch_lock);static void cpufreq_list_transition_notifiers(void )struct notifier_block *nb;"Registered transition notifiers:\n" );for (nb = cpufreq_transition_notifier_list.head; nb; nb = nb->next)"%pS\n" , nb->notifier_call);/** * cpufreq_enable_fast_switch - Enable fast frequency switching for policy . * @ policy : cpufreq policy to enable fast frequency switching for . * * Try to enable fast frequency switching for @ policy . * * The attempt will fail if there is at least one transition notifier registered * at this point , as fast frequency switching is quite fundamentally at odds * with transition notifiers . Thus if successful , it will make registration of * transition notifiers fail going forward . void cpufreq_enable_fast_switch(struct cpufreq_policy *policy)if (!policy->fast_switch_possible)return ;if (cpufreq_fast_switch_count >= 0 ) {true ;else {"CPU%u: Fast frequency switching not enabled\n" ,/** * cpufreq_disable_fast_switch - Disable fast frequency switching for policy . * @ policy : cpufreq policy to disable fast frequency switching for . void cpufreq_disable_fast_switch(struct cpufreq_policy *policy)if (policy->fast_switch_enabled) {false ;if (!WARN_ON(cpufreq_fast_switch_count <= 0 ))static unsigned int __resolve_freq(struct cpufreq_policy *policy,unsigned int target_freq,unsigned int min, unsigned int max,unsigned int relation)unsigned int idx;if (!policy->freq_table)return target_freq;return policy->freq_table[idx].frequency;/** * cpufreq_driver_resolve_freq - Map a target frequency to a driver - supported * one . * @ policy : associated policy to interrogate * @ target_freq : target frequency to resolve . * * The target to driver frequency mapping is cached in the policy . * * Return : Lowest driver - supported frequency greater than or equal to the * given target_freq , subject to policy ( min / max ) and driver limitations . unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy,unsigned int target_freq)unsigned int min = READ_ONCE(policy->min);unsigned int max = READ_ONCE(policy->max);/* * If this function runs in parallel with cpufreq_set_policy ( ) , it may * read policy - > min before the update and policy - > max after the update * or the other way around , so there is no ordering guarantee . * * Resolve this by always honoring the max ( in case it comes from * thermal throttling or similar ) . if (unlikely(min > max))return __resolve_freq(policy, target_freq, min, max, CPUFREQ_RELATION_LE);unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy *policy)unsigned int latency;if (policy->transition_delay_us)return policy->transition_delay_us;if (latency)/* Give a 50% breathing room between updates */ return latency + (latency >> 1 );return USEC_PER_MSEC;/********************************************************************* * SYSFS INTERFACE * static ssize_t show_boost(struct kobject *kobj,struct kobj_attribute *attr, char *buf)return sysfs_emit(buf, "%d\n" , cpufreq_driver->boost_enabled);static ssize_t store_boost(struct kobject *kobj, struct kobj_attribute *attr,const char *buf, size_t count)bool enable;if (kstrtobool(buf, &enable))return -EINVAL;if (cpufreq_boost_trigger_state(enable)) {"%s: Cannot %s BOOST!\n" ,return -EINVAL;"%s: cpufreq BOOST %s\n" ,return count;static ssize_t show_local_boost(struct cpufreq_policy *policy, char *buf)return sysfs_emit(buf, "%d\n" , policy->boost_enabled);static int policy_set_boost(struct cpufreq_policy *policy, bool enable)int ret;if (policy->boost_enabled == enable)return 0 ;if (ret)return ret;static ssize_t store_local_boost(struct cpufreq_policy *policy,const char *buf, size_t count)int ret;bool enable;if (kstrtobool(buf, &enable))return -EINVAL;if (!cpufreq_driver->boost_enabled)return -EINVAL;if (!policy->boost_supported)return -EINVAL;if (!ret)return count;return ret;static struct freq_attr local_boost = __ATTR(boost, 0644 , show_local_boost, store_local_boost);static struct cpufreq_governor *find_governor(const char *str_governor)struct cpufreq_governor *t;if (!strncasecmp(str_governor, t->name, CPUFREQ_NAME_LEN))return t;return NULL;static struct cpufreq_governor *get_governor(const char *str_governor)struct cpufreq_governor *t;if (!t)goto unlock;if (!try_module_get(t->owner))return t;static unsigned int cpufreq_parse_policy(char *str_governor)if (!strncasecmp(str_governor, "performance" , CPUFREQ_NAME_LEN))return CPUFREQ_POLICY_PERFORMANCE;if (!strncasecmp(str_governor, "powersave" , CPUFREQ_NAME_LEN))return CPUFREQ_POLICY_POWERSAVE;return CPUFREQ_POLICY_UNKNOWN;/** * cpufreq_parse_governor - parse a governor string only for has_target ( ) * @ str_governor : Governor name . static struct cpufreq_governor *cpufreq_parse_governor(char *str_governor)struct cpufreq_governor *t;if (t)return t;if (request_module("cpufreq_%s" , str_governor))return NULL;return get_governor(str_governor);/* * cpufreq_per_cpu_attr_read ( ) / show_ # # file_name ( ) - * print out cpufreq information * * Write out information from cpufreq_driver - > policy [ cpu ] ; object must be * " unsigned int " . #define show_one(file_name, object) \static ssize_t show_## file_name \struct cpufreq_policy *policy, char *buf) \return sysfs_emit(buf, "%u\n" , policy->object); \int arch_freq_get_on_cpu(int cpu)return -EOPNOTSUPP;static inline bool cpufreq_avg_freq_supported(struct cpufreq_policy *policy)return arch_freq_get_on_cpu(policy->cpu) != -EOPNOTSUPP;static ssize_t show_scaling_cur_freq(struct cpufreq_policy *policy, char *buf)int freq;0 ;if (freq > 0 )"%u\n" , freq);else if (cpufreq_driver->setpolicy && cpufreq_driver->get)"%u\n" , cpufreq_driver->get(policy->cpu));else "%u\n" , policy->cur);return ret;/* * cpufreq_per_cpu_attr_write ( ) / store_ # # file_name ( ) - sysfs write access #define store_one(file_name, object) \static ssize_t store_## file_name \struct cpufreq_policy *policy, const char *buf, size_t count) \unsigned long val; \int ret; \0 , &val); \if (ret) \return ret; \## _freq_req, val);\return ret >= 0 ? count : ret; \/* * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,char *buf)unsigned int cur_freq = __cpufreq_get(policy);if (cur_freq)return sysfs_emit(buf, "%u\n" , cur_freq);return sysfs_emit(buf, "<unknown>\n" );/* * show_cpuinfo_avg_freq - average CPU frequency as detected by hardware static ssize_t show_cpuinfo_avg_freq(struct cpufreq_policy *policy,char *buf)int avg_freq = arch_freq_get_on_cpu(policy->cpu);if (avg_freq > 0 )return sysfs_emit(buf, "%u\n" , avg_freq);return avg_freq != 0 ? avg_freq : -EINVAL;/* * show_scaling_governor - show the current policy for the specified CPU static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)if (policy->policy == CPUFREQ_POLICY_POWERSAVE)return sysfs_emit(buf, "powersave\n" );else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)return sysfs_emit(buf, "performance\n" );else if (policy->governor)return sysfs_emit(buf, "%s\n" , policy->governor->name);return -EINVAL;/* * store_scaling_governor - store policy for the specified CPU static ssize_t store_scaling_governor(struct cpufreq_policy *policy,const char *buf, size_t count)char str_governor[CPUFREQ_NAME_LEN];int ret;"%15s" , str_governor);if (ret != 1 )return -EINVAL;if (cpufreq_driver->setpolicy) {unsigned int new_pol;if (!new_pol)return -EINVAL;else {struct cpufreq_governor *new_gov;if (!new_gov)return -EINVAL;return ret ? ret : count;/* * show_scaling_driver - show the cpufreq driver currently loaded static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n" , cpufreq_driver->name);/* * show_scaling_available_governors - show the available CPUfreq governors static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,char *buf)0 ;struct cpufreq_governor *t;if (!has_target()) {"performance powersave" );goto out;if (i >= (ssize_t) ((PAGE_SIZE / sizeof (char ))2 )))break ;"%s " , t->name);"\n" );return i;const struct cpumask *mask, char *buf)0 ;unsigned int cpu;"%u " , cpu);if (i >= (PAGE_SIZE - 5 ))break ;/* Remove the extra space at the end */ "\n" );return i;/* * show_related_cpus - show the CPUs affected by each transition even if * hw coordination is in use static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)return cpufreq_show_cpus(policy->related_cpus, buf);/* * show_affected_cpus - show the CPUs affected by each transition static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)return cpufreq_show_cpus(policy->cpus, buf);static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,const char *buf, size_t count)unsigned int freq = 0 ;unsigned int ret;if (!policy->governor || !policy->governor->store_setspeed)return -EINVAL;0 , &freq);if (ret)return ret;return count;static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)if (!policy->governor || !policy->governor->show_setspeed)return sysfs_emit(buf, "<unsupported>\n" );return policy->governor->show_setspeed(policy, buf);/* * show_bios_limit - show the current cpufreq HW / BIOS limitation static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)unsigned int limit;int ret;if (!ret)return sysfs_emit(buf, "%u\n" , limit);return sysfs_emit(buf, "%u\n" , policy->cpuinfo.max_freq);0400 );static struct attribute *cpufreq_attrs[] = {#define to_policy(k) container_of(k, struct cpufreq_policy, kobj)#define to_attr(a) container_of(a, struct freq_attr, attr)static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)struct cpufreq_policy *policy = to_policy(kobj);struct freq_attr *fattr = to_attr(attr);if (!fattr->show)return -EIO;if (likely(!policy_is_inactive(policy)))return fattr->show(policy, buf);return -EBUSY;static ssize_t store(struct kobject *kobj, struct attribute *attr,const char *buf, size_t count)struct cpufreq_policy *policy = to_policy(kobj);struct freq_attr *fattr = to_attr(attr);if (!fattr->store)return -EIO;if (likely(!policy_is_inactive(policy)))return fattr->store(policy, buf, count);return -EBUSY;static void cpufreq_sysfs_release(struct kobject *kobj)struct cpufreq_policy *policy = to_policy(kobj);"last reference is dropped\n" );static const struct sysfs_ops sysfs_ops = {static const struct kobj_type ktype_cpufreq = {static void add_cpu_dev_symlink(struct cpufreq_policy *policy, unsigned int cpu,struct device *dev)if (unlikely(!dev))return ;if (cpumask_test_and_set_cpu(cpu, policy->real_cpus))return ;"%s: Adding symlink\n" , __func__);if (sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq" ))"cpufreq symlink creation failed\n" );static void remove_cpu_dev_symlink(struct cpufreq_policy *policy, int cpu,struct device *dev)"%s: Removing symlink\n" , __func__);"cpufreq" );static int cpufreq_add_dev_interface(struct cpufreq_policy *policy)struct freq_attr **drv_attr;int ret = 0 ;/* Attributes that need freq_table */ if (policy->freq_table) {if (ret)return ret;if (cpufreq_boost_supported()) {if (ret)return ret;/* set up files for this cpu device */ while (drv_attr && *drv_attr) {if (ret)return ret;if (cpufreq_driver->get) {if (ret)return ret;if (cpufreq_avg_freq_supported(policy)) {if (ret)return ret;if (cpufreq_driver->bios_limit) {if (ret)return ret;if (cpufreq_boost_supported()) {if (ret)return ret;return 0 ;static int cpufreq_init_policy(struct cpufreq_policy *policy)struct cpufreq_governor *gov = NULL;unsigned int pol = CPUFREQ_POLICY_UNKNOWN;int ret;if (has_target()) {/* Update policy governor to the one used before hotplug. */ if (gov) {"Restoring governor %s for cpu %d\n" ,else {if (!gov) {else {/* Use the default policy if there is no last_policy. */ if (policy->last_policy) {else {/* * In case the default governor is neither " performance " * nor " powersave " , fall back to the initial policy * value set by the driver . if (pol == CPUFREQ_POLICY_UNKNOWN)if (pol != CPUFREQ_POLICY_PERFORMANCE &&return -ENODATA;if (gov)return ret;static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)int ret = 0 ;/* Has this CPU been taken care of already? */ if (cpumask_test_cpu(cpu, policy->cpus))return 0 ;if (has_target())if (has_target()) {if (ret)"%s: Failed to start governor\n" , __func__);return ret;void refresh_frequency_limits(struct cpufreq_policy *policy)if (!policy_is_inactive(policy)) {"updating policy for CPU %u\n" , policy->cpu);static void handle_update(struct work_struct *work)struct cpufreq_policy *policy =struct cpufreq_policy, update);"handle_update for cpu %u called\n" , policy->cpu);static int cpufreq_notifier_min(struct notifier_block *nb, unsigned long freq,void *data)struct cpufreq_policy *policy = container_of(nb, struct cpufreq_policy, nb_min);return 0 ;static int cpufreq_notifier_max(struct notifier_block *nb, unsigned long freq,void *data)struct cpufreq_policy *policy = container_of(nb, struct cpufreq_policy, nb_max);return 0 ;static void cpufreq_policy_put_kobj(struct cpufreq_policy *policy)struct kobject *kobj;struct completion *cmp;/* * We need to make sure that the underlying kobj is * actually not referenced anymore by anybody before we * proceed with unloading . "waiting for dropping of refcount\n" );"wait complete\n" );static struct cpufreq_policy *cpufreq_policy_alloc(unsigned int cpu)struct cpufreq_policy *policy;struct device *dev = get_cpu_device(cpu);int ret;if (!dev)return NULL;sizeof (*policy), GFP_KERNEL);if (!policy)return NULL;if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))goto err_free_policy;if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))goto err_free_cpumask;if (!zalloc_cpumask_var(&policy->real_cpus, GFP_KERNEL))goto err_free_rcpumask;"policy%u" , cpu);if (ret) {"%s: failed to init policy->kobj: %d\n" , __func__, ret);/* * The entire policy object will be freed below , but the extra * memory allocated for the kobject name needs to be freed by * releasing the kobject . goto err_free_real_cpus;if (ret) {"Failed to register MIN QoS notifier: %d (CPU%u)\n" ,goto err_kobj_remove;if (ret) {"Failed to register MAX QoS notifier: %d (CPU%u)\n" ,goto err_min_qos_notifier;return policy;return NULL;static void cpufreq_policy_free(struct cpufreq_policy *policy)unsigned long flags;int cpu;/* * The callers must ensure the policy is inactive by now , to avoid any * races with show ( ) / store ( ) callbacks . if (unlikely(!policy_is_inactive(policy)))"%s: Freeing active policy\n" , __func__);/* Remove policy from list */ /* Cancel any pending policy->update work before freeing the policy. */ if (policy->max_freq_req) {/* * Remove max_freq_req after sending CPUFREQ_REMOVE_POLICY * notification , since CPUFREQ_CREATE_POLICY notification was * sent after adding max_freq_req earlier . static int cpufreq_policy_online(struct cpufreq_policy *policy,unsigned int cpu, bool new_policy)unsigned long flags;unsigned int j;int ret;if (!new_policy && cpufreq_driver->online) {/* Recover policy->cpus using related_cpus */ if (ret) {"%s: %d: initialization failed\n" , __func__,goto out_exit_policy;else {/* * Call driver . From then on the cpufreq must be able * to accept all calls to - > verify and - > setpolicy for this CPU . if (ret) {"%s: %d: initialization failed\n" , __func__,goto out_clear_policy;/* * The initialization has succeeded and the policy is online . * If there is a problem with its frequency table , take it * offline and drop it . if (ret)goto out_offline_policy;/* related_cpus should at least include policy->cpus. */ /* * affected cpus must always be the one , which are online . We aren ' t * managing offline cpus here . if (new_policy) {2 * sizeof (*policy->min_freq_req),if (!policy->min_freq_req) {goto out_destroy_policy;if (ret < 0 ) {/* * So we don ' t call freq_qos_remove_request ( ) for an * uninitialized request . goto out_destroy_policy;/* * This must be initialized right here to avoid calling * freq_qos_remove_request ( ) on uninitialized request in case * of errors . 1 ;if (ret < 0 ) {goto out_destroy_policy;else {if (ret < 0 )goto out_destroy_policy;if (cpufreq_driver->get && has_target()) {if (!policy->cur) {"%s: ->get() failed\n" , __func__);goto out_destroy_policy;/* * Sometimes boot loaders set CPU frequency to a value outside of * frequency table present with cpufreq core . In such cases CPU might be * unstable if it has to run on that frequency for long duration of time * and so its better to set it to a frequency which is specified in * freq - table . This also makes cpufreq stats inconsistent as * cpufreq - stats would fail to register because current frequency of CPU * isn ' t found in freq - table . * * Because we don ' t want this change to effect boot process badly , we go * for the next freq which is > = policy - > cur ( ' cur ' must be set by now , * otherwise we will end up setting freq to lowest of the table as ' cur ' * is initialized to zero ) . * * We are passing target - freq as " policy - > cur - 1 " otherwise * _ _ cpufreq_driver_target ( ) would simply fail , as policy - > cur will be * equal to target - freq . if ((cpufreq_driver->flags & CPUFREQ_NEED_INITIAL_FREQ_CHECK)unsigned int old_freq = policy->cur;/* Are we running at unknown frequency ? */ if (ret == -EINVAL) {1 ,/* * Reaching here after boot in a few seconds may not * mean that system will remain stable at " unknown " * frequency for longer duration . Hence , a BUG_ON ( ) . "%s: CPU%d: Running at unlisted initial frequency: %u kHz, changing to: %u kHz\n" ,if (new_policy) {if (ret)goto out_destroy_policy;/* * Register with the energy model before * em_rebuild_sched_domains ( ) is called , which will result * in rebuilding of the sched domains , which should only be done * once the energy model is properly initialized for the policy * first . * * Also , this should be called before the policy is registered * with cooling framework . if (cpufreq_driver->register_em)if (ret) {"%s: Failed to initialize policy for cpu: %d (%d)\n" ,goto out_destroy_policy;return 0 ;if (cpufreq_driver->offline)if (cpufreq_driver->exit )exit (policy);return ret;static int cpufreq_online(unsigned int cpu)struct cpufreq_policy *policy;bool new_policy;int ret;"%s: bringing CPU%u online\n" , __func__, cpu);/* Check if this CPU already has a policy to manage it */ if (policy) {if (!policy_is_inactive(policy))return cpufreq_add_policy_cpu(policy, cpu);/* This is the only online CPU for the policy. Start over. */ false ;else {true ;if (!policy)return -ENOMEM;if (ret) {return ret;/* Callback for handling stuff after policy is ready */ if (cpufreq_driver->ready)/* Register cpufreq cooling only for a new policy */ if (new_policy && cpufreq_thermal_control_enabled(cpufreq_driver))/* * Let the per - policy boost flag mirror the cpufreq_driver boost during * initialization for a new policy . For an existing policy , maintain the * previous boost value unless global boost is disabled . if (cpufreq_driver->set_boost && policy->boost_supported &&if (ret) {/* If the set_boost fails, the online operation is not affected */ "%s: CPU%d: Cannot %s BOOST\n" , __func__, policy->cpu,"initialization complete\n" );return 0 ;/** * cpufreq_add_dev - the cpufreq interface for a CPU device . * @ dev : CPU device . * @ sif : Subsystem interface structure pointer ( not used ) static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)struct cpufreq_policy *policy;unsigned cpu = dev->id;int ret;"%s: adding CPU%u\n" , __func__, cpu);if (cpu_online(cpu)) {if (ret)return ret;/* Create sysfs link on CPU registration */ if (policy)return 0 ;static void __cpufreq_offline(unsigned int cpu, struct cpufreq_policy *policy)int ret;if (has_target())if (!policy_is_inactive(policy)) {/* Nominate a new CPU if necessary. */ if (cpu == policy->cpu)/* Start the governor again for the active policy. */ if (has_target()) {if (ret)"%s: Failed to start governor\n" , __func__);return ;if (has_target()) {else {/* * Perform the - > offline ( ) during light - weight tear - down , as * that allows fast recovery when the CPU comes back . if (cpufreq_driver->offline) {return ;if (cpufreq_driver->exit )exit (policy);static int cpufreq_offline(unsigned int cpu)struct cpufreq_policy *policy;"%s: unregistering CPU %u\n" , __func__, cpu);if (!policy) {"%s: No cpu_data found\n" , __func__);return 0 ;return 0 ;/* * cpufreq_remove_dev - remove a CPU device * * Removes the cpufreq interface for a CPU device . static void cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)unsigned int cpu = dev->id;struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);if (!policy)return ;if (cpu_online(cpu))if (!cpumask_empty(policy->real_cpus))return ;/* * Unregister cpufreq cooling once all the CPUs of the policy * are removed . if (cpufreq_thermal_control_enabled(cpufreq_driver)) {/* We did light-weight exit earlier, do full tear down now */ if (cpufreq_driver->offline && cpufreq_driver->exit )exit (policy);/** * cpufreq_out_of_sync - Fix up actual and saved CPU frequency difference . * @ policy : Policy managing CPUs . * @ new_freq : New CPU frequency . * * Adjust to the current frequency first and clean up later by either calling * cpufreq_update_policy ( ) , or scheduling handle_update ( ) . static void cpufreq_out_of_sync(struct cpufreq_policy *policy,unsigned int new_freq)struct cpufreq_freqs freqs;"Warning: CPU frequency out of sync: cpufreq and timing core thinks of %u, is %u kHz\n" ,new = new_freq;0 );static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, bool update)unsigned int new_freq;if (!cpufreq_driver->get)return 0 ;if (!new_freq)return 0 ;/* * If fast frequency switching is used with the given policy , the check * against policy - > cur is pointless , so skip it in that case . if (policy->fast_switch_enabled || !has_target())return new_freq;if (policy->cur != new_freq) {/* * For some platforms , the frequency returned by hardware may be * slightly different from what is provided in the frequency * table , for example hardware may return 499 MHz instead of 500 * MHz . In such cases it is better to avoid getting into * unnecessary frequency updates . if (abs(policy->cur - new_freq) < KHZ_PER_MHZ)return policy->cur;if (update)return new_freq;/** * cpufreq_quick_get - get the CPU frequency ( in kHz ) from policy - > cur * @ cpu : CPU number * * This is the last known freq , without actually getting it from the driver . * Return value will be same as what is shown in scaling_cur_freq in sysfs . unsigned int cpufreq_quick_get(unsigned int cpu)struct cpufreq_policy *policy __free(put_cpufreq_policy) = NULL;unsigned long flags;if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get) {unsigned int ret_freq = cpufreq_driver->get(cpu);return ret_freq;if (policy)return policy->cur;return 0 ;/** * cpufreq_quick_get_max - get the max reported CPU frequency for this CPU * @ cpu : CPU number * * Just return the max possible frequency for a given CPU . unsigned int cpufreq_quick_get_max(unsigned int cpu)struct cpufreq_policy *policy __free(put_cpufreq_policy);if (policy)return policy->max;return 0 ;/** * cpufreq_get_hw_max_freq - get the max hardware frequency of the CPU * @ cpu : CPU number * * The default return value is the max_freq field of cpuinfo . unsigned int cpufreq_get_hw_max_freq(unsigned int cpu)struct cpufreq_policy *policy __free(put_cpufreq_policy);if (policy)return policy->cpuinfo.max_freq;return 0 ;static unsigned int __cpufreq_get(struct cpufreq_policy *policy)if (unlikely(policy_is_inactive(policy)))return 0 ;return cpufreq_verify_current_freq(policy, true );/** * cpufreq_get - get the current CPU frequency ( in kHz ) * @ cpu : CPU number * * Get the CPU current ( static ) CPU frequency unsigned int cpufreq_get(unsigned int cpu)struct cpufreq_policy *policy __free(put_cpufreq_policy);if (!policy)return 0 ;return __cpufreq_get(policy);static struct subsys_interface cpufreq_interface = {"cpufreq" ,/* * In case platform wants some specific frequency to be configured * during suspend . . int cpufreq_generic_suspend(struct cpufreq_policy *policy)int ret;if (!policy->suspend_freq) {"%s: suspend_freq not defined\n" , __func__);return 0 ;"%s: Setting suspend-freq: %u\n" , __func__,if (ret)"%s: unable to set suspend-freq: %u. err: %d\n" ,return ret;/** * cpufreq_suspend ( ) - Suspend CPUFreq governors . * * Called during system wide Suspend / Hibernate cycles for suspending governors * as some platforms can ' t change frequency after this point in suspend cycle . * Because some of the devices ( like : i2c , regulators , etc ) they use for * changing frequency are suspended quickly after this point . void cpufreq_suspend(void )struct cpufreq_policy *policy;if (!cpufreq_driver)return ;if (!has_target() && !cpufreq_driver->suspend)goto suspend;"%s: Suspending Governors\n" , __func__);if (has_target()) {if (cpufreq_driver->suspend && cpufreq_driver->suspend(policy))"%s: Failed to suspend driver: %s\n" , __func__,true ;/** * cpufreq_resume ( ) - Resume CPUFreq governors . * * Called during system wide Suspend / Hibernate cycle for resuming governors that * are suspended with cpufreq_suspend ( ) . void cpufreq_resume(void )struct cpufreq_policy *policy;int ret;if (!cpufreq_driver)return ;if (unlikely(!cpufreq_suspended))return ;false ;if (!has_target() && !cpufreq_driver->resume)return ;"%s: Resuming Governors\n" , __func__);if (cpufreq_driver->resume && cpufreq_driver->resume(policy)) {"%s: Failed to resume driver: %s\n" , __func__,else if (has_target()) {if (ret)"%s: Failed to start governor for CPU%u's policy\n" ,/** * cpufreq_driver_test_flags - Test cpufreq driver ' s flags against given ones . * @ flags : Flags to test against the current cpufreq driver ' s flags . * * Assumes that the driver is there , so callers must ensure that this is the * case . bool cpufreq_driver_test_flags(u16 flags)return !!(cpufreq_driver->flags & flags);/** * cpufreq_get_current_driver - Return the current driver ' s name . * * Return the name string of the currently registered cpufreq driver or NULL if * none . const char *cpufreq_get_current_driver(void )if (cpufreq_driver)return cpufreq_driver->name;return NULL;/** * cpufreq_get_driver_data - Return current driver data . * * Return the private data of the currently registered cpufreq driver , or NULL * if no cpufreq driver has been registered . void *cpufreq_get_driver_data(void )if (cpufreq_driver)return cpufreq_driver->driver_data;return NULL;/********************************************************************* * NOTIFIER LISTS INTERFACE * /** * cpufreq_register_notifier - Register a notifier with cpufreq . * @ nb : notifier function to register . * @ list : CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER . * * Add a notifier to one of two lists : either a list of notifiers that run on * clock rate changes ( once before and once after every transition ) , or a list * of notifiers that ron on cpufreq policy changes . * * This function may sleep and it has the same return values as * blocking_notifier_chain_register ( ) . int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)int ret;if (cpufreq_disabled())return -EINVAL;switch (list) {case CPUFREQ_TRANSITION_NOTIFIER:if (cpufreq_fast_switch_count > 0 ) {return -EBUSY;if (!ret)break ;case CPUFREQ_POLICY_NOTIFIER:break ;default :return ret;/** * cpufreq_unregister_notifier - Unregister a notifier from cpufreq . * @ nb : notifier block to be unregistered . * @ list : CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER . * * Remove a notifier from one of the cpufreq notifier lists . * * This function may sleep and it has the same return values as * blocking_notifier_chain_unregister ( ) . int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)int ret;if (cpufreq_disabled())return -EINVAL;switch (list) {case CPUFREQ_TRANSITION_NOTIFIER:if (!ret && !WARN_ON(cpufreq_fast_switch_count >= 0 ))break ;case CPUFREQ_POLICY_NOTIFIER:break ;default :return ret;/********************************************************************* * GOVERNORS * /** * cpufreq_driver_fast_switch - Carry out a fast CPU frequency switch . * @ policy : cpufreq policy to switch the frequency for . * @ target_freq : New frequency to set ( may be approximate ) . * * Carry out a fast frequency switch without sleeping . * * The driver ' s - > fast_switch ( ) callback invoked by this function must be * suitable for being called from within RCU - sched read - side critical sections * and it is expected to select the minimum available frequency greater than or * equal to @ target_freq ( CPUFREQ_RELATION_L ) . * * This function must not be called if policy - > fast_switch_enabled is unset . * * Governors calling this function must guarantee that it will never be invoked * twice in parallel for the same policy and that it will never be called in * parallel with either - > target ( ) or - > target_index ( ) for the same policy . * * Returns the actual frequency set for the CPU . * * If 0 is returned by the driver ' s - > fast_switch ( ) callback to indicate an * error condition , the hardware configuration must be preserved . unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,unsigned int target_freq)unsigned int freq;int cpu;if (!freq)return 0 ;if (trace_cpu_frequency_enabled()) {return freq;/** * cpufreq_driver_adjust_perf - Adjust CPU performance level in one go . * @ cpu : Target CPU . * @ min_perf : Minimum ( required ) performance level ( units of @ capacity ) . * @ target_perf : Target ( desired ) performance level ( units of @ capacity ) . * @ capacity : Capacity of the target CPU . * * Carry out a fast performance level switch of @ cpu without sleeping . * * The driver ' s - > adjust_perf ( ) callback invoked by this function must be * suitable for being called from within RCU - sched read - side critical sections * and it is expected to select a suitable performance level equal to or above * @ min_perf and preferably equal to or below @ target_perf . * * This function must not be called if policy - > fast_switch_enabled is unset . * * Governors calling this function must guarantee that it will never be invoked * twice in parallel for the same CPU and that it will never be called in * parallel with either - > target ( ) or - > target_index ( ) or - > fast_switch ( ) for * the same CPU . void cpufreq_driver_adjust_perf(unsigned int cpu,unsigned long min_perf,unsigned long target_perf,unsigned long capacity)/** * cpufreq_driver_has_adjust_perf - Check " direct fast switch " callback . * * Return ' true ' if the - > adjust_perf callback is present for the * current driver or ' false ' otherwise . bool cpufreq_driver_has_adjust_perf(void )return !!cpufreq_driver->adjust_perf;/* Must set freqs->new to intermediate frequency */ static int __target_intermediate(struct cpufreq_policy *policy,struct cpufreq_freqs *freqs, int index)int ret;new = cpufreq_driver->get_intermediate(policy, index);/* We don't need to switch to intermediate freq */ if (!freqs->new )return 0 ;"%s: cpu: %d, switching to intermediate freq: oldfreq: %u, intermediate freq: %u\n" ,new );if (ret)"%s: Failed to change to intermediate frequency: %d\n" ,return ret;static int __target_index(struct cpufreq_policy *policy, int index)struct cpufreq_freqs freqs = {.old = policy->cur, .flags = 0 };unsigned int restore_freq, intermediate_freq = 0 ;unsigned int newfreq = policy->freq_table[index].frequency;int retval = -EINVAL;bool notify;if (newfreq == policy->cur)return 0 ;/* Save last value to restore later on errors */ if (notify) {/* Handle switching to intermediate frequency */ if (cpufreq_driver->get_intermediate) {if (retval)return retval;new ;/* Set old freq to intermediate */ if (intermediate_freq)new ;new = newfreq;"%s: cpu: %d, oldfreq: %u, new freq: %u\n" ,new );if (retval)"%s: Failed to change cpu frequency: %d\n" , __func__,if (notify) {/* * Failed after setting to intermediate freq ? Driver should have * reverted back to initial frequency and so should we . Check * here for intermediate_freq instead of get_intermediate , in * case we haven ' t switched to intermediate freq at all . if (unlikely(retval && intermediate_freq)) {new = restore_freq;0 );return retval;int __cpufreq_driver_target(struct cpufreq_policy *policy,unsigned int target_freq,unsigned int relation)unsigned int old_target_freq = target_freq;if (cpufreq_disabled())return -ENODEV;"target for CPU %u: %u kHz, relation %u, requested %u kHz\n" ,/* * This might look like a redundant call as we are checking it again * after finding index . But it is left intentionally for cases where * exactly same freq is called again and so we can save on few function * calls . if (target_freq == policy->cur &&return 0 ;if (cpufreq_driver->target) {/* * If the driver hasn ' t setup a single inefficient frequency , * it ' s unlikely it knows how to decode CPUFREQ_RELATION_E . if (!policy->efficiencies_available)return cpufreq_driver->target(policy, target_freq, relation);if (!cpufreq_driver->target_index)return -EINVAL;return __target_index(policy, policy->cached_resolved_idx);int cpufreq_driver_target(struct cpufreq_policy *policy,unsigned int target_freq,unsigned int relation)return __cpufreq_driver_target(policy, target_freq, relation);struct cpufreq_governor *cpufreq_fallback_governor(void )return NULL;static int cpufreq_init_governor(struct cpufreq_policy *policy)int ret;/* Don't start any governor operations if we are entering suspend */ if (cpufreq_suspended)return 0 ;/* * Governor might not be initiated here if ACPI _ PPC changed * notification happened , so check it . if (!policy->governor)return -EINVAL;/* Platform doesn't want dynamic frequency switching ? */ if (policy->governor->flags & CPUFREQ_GOV_DYNAMIC_SWITCHING &&struct cpufreq_governor *gov = cpufreq_fallback_governor();if (gov) {"Can't use %s governor as dynamic switching is disallowed. Fallback to %s governor\n" ,else {return -EINVAL;if (!try_module_get(policy->governor->owner))return -EINVAL;"%s: for CPU %u\n" , __func__, policy->cpu);if (policy->governor->init) {if (ret) {return ret;return 0 ;static void cpufreq_exit_governor(struct cpufreq_policy *policy)if (cpufreq_suspended || !policy->governor)return ;"%s: for CPU %u\n" , __func__, policy->cpu);if (policy->governor->exit )exit (policy);int cpufreq_start_governor(struct cpufreq_policy *policy)int ret;if (cpufreq_suspended)return 0 ;if (!policy->governor)return -EINVAL;"%s: for CPU %u\n" , __func__, policy->cpu);false );if (policy->governor->start) {if (ret)return ret;if (policy->governor->limits)return 0 ;void cpufreq_stop_governor(struct cpufreq_policy *policy)if (cpufreq_suspended || !policy->governor)return ;"%s: for CPU %u\n" , __func__, policy->cpu);if (policy->governor->stop)static void cpufreq_governor_limits(struct cpufreq_policy *policy)if (cpufreq_suspended || !policy->governor)return ;"%s: for CPU %u\n" , __func__, policy->cpu);if (policy->governor->limits)int cpufreq_register_governor(struct cpufreq_governor *governor)int err;if (!governor)return -EINVAL;if (cpufreq_disabled())return -ENODEV;if (!find_governor(governor->name)) {0 ;return err;void cpufreq_unregister_governor(struct cpufreq_governor *governor)struct cpufreq_policy *policy;unsigned long flags;if (!governor)return ;if (cpufreq_disabled())return ;/* clear last_governor for all inactive policies */ if (!strcmp(policy->last_governor, governor->name)) {"\0" );/********************************************************************* * POLICY INTERFACE * unsigned long , cpufreq_pressure);/** * cpufreq_update_pressure ( ) - Update cpufreq pressure for CPUs * @ policy : cpufreq policy of the CPUs . * * Update the value of cpufreq pressure for all @ cpus in the policy . static void cpufreq_update_pressure(struct cpufreq_policy *policy)unsigned long max_capacity, capped_freq, pressure;int cpu;/* * Handle properly the boost frequencies , which should simply clean * the cpufreq pressure value . if (max_freq <= capped_freq) {0 ;else {/** * cpufreq_set_policy - Modify cpufreq policy parameters . * @ policy : Policy object to modify . * @ new_gov : Policy governor pointer . * @ new_pol : Policy value ( for drivers with built - in governors ) . * * Invoke the cpufreq driver ' s - > verify ( ) callback to sanity - check the frequency * limits to be set for the policy , update @ policy with the verified limits * values and either invoke the driver ' s - > setpolicy ( ) callback ( if present ) or * carry out a governor update for @ policy . That is , run the current governor ' s * - > limits ( ) callback ( if @ new_gov points to the same object as the one in * @ policy ) or replace the governor for @ policy with @ new_gov . * * The cpuinfo part of @ policy is not updated by this function . static int cpufreq_set_policy(struct cpufreq_policy *policy,struct cpufreq_governor *new_gov,unsigned int new_pol)struct cpufreq_policy_data new_data;struct cpufreq_governor *old_gov;int ret;sizeof (policy->cpuinfo));/* * PM QoS framework collects all the requests from users and provide us * the final aggregated value here . "setting new policy for CPU %u: %u - %u kHz\n" ,/* * Verify that the CPU speed can be set within these limits and make sure * that min < = max . if (ret)return ret;/* * Resolve policy min / max to available frequencies . It ensures * no frequency resolution will neither overshoot the requested maximum * nor undershoot the requested minimum . * * Avoid storing intermediate values in policy - > max or policy - > min and * compiler optimizations around them because they may be accessed * concurrently by cpufreq_driver_resolve_freq ( ) during the update . "new min and max freqs are %u - %u kHz\n" ,if (cpufreq_driver->setpolicy) {"setting range\n" );return cpufreq_driver->setpolicy(policy);if (new_gov == policy->governor) {"governor limits update\n" );return 0 ;"governor switch\n" );/* save old, working values */ /* end old governor */ if (old_gov) {/* start new governor */ if (!ret) {if (!ret) {"governor change\n" );return 0 ;/* new governor failed, so re-start old one */ "starting governor %s failed\n" , policy->governor->name);if (old_gov) {if (cpufreq_init_governor(policy)) {else if (cpufreq_start_governor(policy)) {return ret;static void cpufreq_policy_refresh(struct cpufreq_policy *policy)/* * BIOS might change freq behind our back * - > ask driver for current freq and notify governors about a change if (cpufreq_driver->get && has_target() &&false ))))return ;/** * cpufreq_update_policy - Re - evaluate an existing cpufreq policy . * @ cpu : CPU to re - evaluate the policy for . * * Update the current frequency for the cpufreq policy of @ cpu and use * cpufreq_set_policy ( ) to re - apply the min and max limits , which triggers the * evaluation of policy notifiers and the cpufreq driver ' s - > verify ( ) callback * for the policy in question , among other things . void cpufreq_update_policy(unsigned int cpu)struct cpufreq_policy *policy __free(put_cpufreq_policy);if (!policy)return ;/** * cpufreq_update_limits - Update policy limits for a given CPU . * @ cpu : CPU to update the policy limits for . * * Invoke the driver ' s - > update_limits callback if present or call * cpufreq_policy_refresh ( ) for @ cpu . void cpufreq_update_limits(unsigned int cpu)struct cpufreq_policy *policy __free(put_cpufreq_policy);if (!policy)return ;if (cpufreq_driver->update_limits)else /********************************************************************* * BOOST * int cpufreq_boost_set_sw(struct cpufreq_policy *policy, int state)int ret;if (!policy->freq_table)return -ENXIO;if (ret) {"%s: Policy frequency update failed\n" , __func__);return ret;if (ret < 0 )return ret;return 0 ;static int cpufreq_boost_trigger_state(int state)struct cpufreq_policy *policy;unsigned long flags;int ret = 0 ;/* * Don ' t compare ' cpufreq_driver - > boost_enabled ' with ' state ' here to * make sure all policies are in sync with global boost flag . if (!policy->boost_supported)continue ;if (ret)goto err_reset_state;return 0 ;"%s: Cannot %s BOOST\n" ,return ret;static bool cpufreq_boost_supported(void )return cpufreq_driver->set_boost;static int create_boost_sysfs_file(void )int ret;if (ret)"%s: cannot register global BOOST sysfs file\n" ,return ret;static void remove_boost_sysfs_file(void )if (cpufreq_boost_supported())bool cpufreq_boost_enabled(void )return cpufreq_driver->boost_enabled;/********************************************************************* * REGISTER / UNREGISTER CPUFREQ DRIVER * static enum cpuhp_state hp_online;static int cpuhp_cpufreq_online(unsigned int cpu)return 0 ;static int cpuhp_cpufreq_offline(unsigned int cpu)return 0 ;/** * cpufreq_register_driver - register a CPU Frequency driver * @ driver_data : A struct cpufreq_driver containing the values # * submitted by the CPU Frequency driver . * * Registers a CPU Frequency driver to this core code . This code * returns zero on success , - EEXIST when another driver got here first * ( and isn ' t unregistered in the meantime ) . * int cpufreq_register_driver(struct cpufreq_driver *driver_data)unsigned long flags;int ret;if (cpufreq_disabled())return -ENODEV;/* * The cpufreq core depends heavily on the availability of device * structure , make sure they are available before proceeding further . if (!get_cpu_device(0 ))return -EPROBE_DEFER;if (!driver_data || !driver_data->verify || !driver_data->init ||return -EINVAL;"trying to register driver %s\n" , driver_data->name);/* Protect against concurrent CPU online/offline. */ if (cpufreq_driver) {goto out;if (driver_data->setpolicy)if (cpufreq_boost_supported()) {if (ret)goto err_null_driver;/* * Mark support for the scheduler ' s frequency invariance engine for * drivers that implement target ( ) , target_index ( ) or fast_switch ( ) . if (!cpufreq_driver->setpolicy) {"cpufreq: supports frequency invariance\n" );if (ret)goto err_boost_unreg;if (unlikely(list_empty(&cpufreq_policy_list))) {/* if all ->init() calls failed, unregister */ "%s: No CPU initialized for driver %s\n" , __func__,goto err_if_unreg;"cpufreq:online" ,if (ret < 0 )goto err_if_unreg;0 ;"driver %s up and running\n" , driver_data->name);goto out;if (!cpufreq_driver->setpolicy)return ret;/* * cpufreq_unregister_driver - unregister the current CPUFreq driver * * Unregister the current CPUFreq driver . Only call this if you have * the right to do so , i . e . if you have succeeded in initialising before ! * Returns zero if successful , and - EINVAL if the cpufreq_driver is * currently not initialised . void cpufreq_unregister_driver(struct cpufreq_driver *driver)unsigned long flags;if (WARN_ON(!cpufreq_driver || (driver != cpufreq_driver)))return ;"unregistering driver %s\n" , driver->name);/* Protect against concurrent cpu hotplug */ static int __init cpufreq_core_init(void )struct cpufreq_governor *gov = cpufreq_default_governor();struct device *dev_root;if (cpufreq_disabled())return -ENODEV;if (dev_root) {"cpufreq" , &dev_root->kobj);if (!strlen(default_governor))return 0 ;static bool cpufreq_policy_is_good_for_eas(unsigned int cpu)struct cpufreq_policy *policy __free(put_cpufreq_policy);if (!policy) {"cpufreq policy not set for CPU: %d\n" , cpu);return false ;return sugov_is_governor(policy);bool cpufreq_ready_for_eas(const struct cpumask *cpu_mask)unsigned int cpu;/* Do not attempt EAS if schedutil is not being used. */ if (!cpufreq_policy_is_good_for_eas(cpu)) {"rd %*pbl: schedutil is mandatory for EAS\n" ,return false ;return true ;int , 0444 );0444 );
Messung V0.5 in Prozent C=96 H=96 G=95
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.116Angebot
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-09-29)
¤ *Eine klare Vorstellung vom Zielzustand
2026-10-10
Neuigkeiten Aktuelles Motto des Tages Open Source Software
Jenseits des Üblichen ....
Besucherstatistik
Statistik #Sources=1126438 #Domains=1897691
