![Viresh Kumar](/assets/img/avatar_default.png)
This routine checks if the CPU running this code belongs to the policy of the target CPU or if not, can it do remote DVFS for it remotely. But the current name of it implies as if it is only about doing remote updates. Rename it to make it more relevant. Suggested-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com> Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
970 lines
29 KiB
C
970 lines
29 KiB
C
/*
|
|
* linux/include/linux/cpufreq.h
|
|
*
|
|
* Copyright (C) 2001 Russell King
|
|
* (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
#ifndef _LINUX_CPUFREQ_H
|
|
#define _LINUX_CPUFREQ_H
|
|
|
|
#include <linux/clk.h>
|
|
#include <linux/cpumask.h>
|
|
#include <linux/completion.h>
|
|
#include <linux/kobject.h>
|
|
#include <linux/notifier.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/sysfs.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 (-1)
|
|
#define CPUFREQ_NAME_LEN 16
|
|
/* Print length for names. Extra 1 space for accommodating '\n' in prints */
|
|
#define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
|
|
|
|
struct cpufreq_governor;
|
|
|
|
enum cpufreq_table_sorting {
|
|
CPUFREQ_TABLE_UNSORTED,
|
|
CPUFREQ_TABLE_SORTED_ASCENDING,
|
|
CPUFREQ_TABLE_SORTED_DESCENDING
|
|
};
|
|
|
|
struct cpufreq_freqs {
|
|
unsigned int cpu; /* cpu nr */
|
|
unsigned int old;
|
|
unsigned int new;
|
|
u8 flags; /* flags of cpufreq_driver, see below. */
|
|
};
|
|
|
|
struct cpufreq_cpuinfo {
|
|
unsigned int max_freq;
|
|
unsigned int min_freq;
|
|
|
|
/* in 10^(-9) s = nanoseconds */
|
|
unsigned int transition_latency;
|
|
};
|
|
|
|
struct cpufreq_user_policy {
|
|
unsigned int min; /* in kHz */
|
|
unsigned int max; /* in kHz */
|
|
};
|
|
|
|
struct cpufreq_policy {
|
|
/* CPUs sharing clock, require sw coordination */
|
|
cpumask_var_t cpus; /* Online CPUs only */
|
|
cpumask_var_t related_cpus; /* Online + Offline CPUs */
|
|
cpumask_var_t real_cpus; /* Related and present */
|
|
|
|
unsigned int shared_type; /* ACPI: ANY or ALL affected CPUs
|
|
should set cpufreq */
|
|
unsigned int cpu; /* cpu managing this policy, must be online */
|
|
|
|
struct clk *clk;
|
|
struct cpufreq_cpuinfo cpuinfo;/* see above */
|
|
|
|
unsigned int min; /* in kHz */
|
|
unsigned int max; /* in kHz */
|
|
unsigned int cur; /* in kHz, only needed if cpufreq
|
|
* governors are used */
|
|
unsigned int restore_freq; /* = policy->cur before transition */
|
|
unsigned int suspend_freq; /* freq to set during suspend */
|
|
|
|
unsigned int policy; /* see above */
|
|
unsigned int last_policy; /* policy before unplug */
|
|
struct cpufreq_governor *governor; /* see below */
|
|
void *governor_data;
|
|
char last_governor[CPUFREQ_NAME_LEN]; /* last governor used */
|
|
|
|
struct work_struct update; /* if update_policy() needs to be
|
|
* called, but you're in IRQ context */
|
|
|
|
struct cpufreq_user_policy user_policy;
|
|
struct cpufreq_frequency_table *freq_table;
|
|
enum cpufreq_table_sorting freq_table_sorted;
|
|
|
|
struct list_head policy_list;
|
|
struct kobject kobj;
|
|
struct completion kobj_unregister;
|
|
|
|
/*
|
|
* The rules for this semaphore:
|
|
* - Any routine that wants to read from the policy structure will
|
|
* do a down_read on this semaphore.
|
|
* - Any routine that will write to the policy structure and/or may take away
|
|
* the policy altogether (eg. CPU hotplug), will hold this lock in write
|
|
* mode before doing so.
|
|
*/
|
|
struct rw_semaphore rwsem;
|
|
|
|
/*
|
|
* Fast switch flags:
|
|
* - fast_switch_possible should be set by the driver if it can
|
|
* guarantee that frequency can be changed on any CPU sharing the
|
|
* policy and that the change will affect all of the policy CPUs then.
|
|
* - fast_switch_enabled is to be set by governors that support fast
|
|
* frequency switching with the help of cpufreq_enable_fast_switch().
|
|
*/
|
|
bool fast_switch_possible;
|
|
bool fast_switch_enabled;
|
|
|
|
/*
|
|
* Preferred average time interval between consecutive invocations of
|
|
* the driver to set the frequency for this policy. To be set by the
|
|
* scaling driver (0, which is the default, means no preference).
|
|
*/
|
|
unsigned int transition_delay_us;
|
|
|
|
/*
|
|
* Remote DVFS flag (Not added to the driver structure as we don't want
|
|
* to access another structure from scheduler hotpath).
|
|
*
|
|
* Should be set if CPUs can do DVFS on behalf of other CPUs from
|
|
* different cpufreq policies.
|
|
*/
|
|
bool dvfs_possible_from_any_cpu;
|
|
|
|
/* Cached frequency lookup from cpufreq_driver_resolve_freq. */
|
|
unsigned int cached_target_freq;
|
|
int cached_resolved_idx;
|
|
|
|
/* Synchronization for frequency transitions */
|
|
bool transition_ongoing; /* Tracks transition status */
|
|
spinlock_t transition_lock;
|
|
wait_queue_head_t transition_wait;
|
|
struct task_struct *transition_task; /* Task which is doing the transition */
|
|
|
|
/* cpufreq-stats */
|
|
struct cpufreq_stats *stats;
|
|
|
|
/* For cpufreq driver's internal use */
|
|
void *driver_data;
|
|
};
|
|
|
|
/* Only for ACPI */
|
|
#define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
|
|
#define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */
|
|
#define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */
|
|
#define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/
|
|
|
|
#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_shared(struct cpufreq_policy *policy)
|
|
{
|
|
return cpumask_weight(policy->cpus) > 1;
|
|
}
|
|
|
|
/* /sys/devices/system/cpu/cpufreq: entry point for global variables */
|
|
extern struct kobject *cpufreq_global_kobject;
|
|
|
|
#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);
|
|
void disable_cpufreq(void);
|
|
|
|
u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
|
|
int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
|
|
void cpufreq_update_policy(unsigned int cpu);
|
|
bool have_governor_per_policy(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);
|
|
#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 void disable_cpufreq(void) { }
|
|
#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 0 /* lowest frequency at or above target */
|
|
#define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */
|
|
#define CPUFREQ_RELATION_C 2 /* closest frequency to target */
|
|
|
|
struct freq_attr {
|
|
struct attribute attr;
|
|
ssize_t (*show)(struct cpufreq_policy *, char *);
|
|
ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
|
|
};
|
|
|
|
#define cpufreq_freq_attr_ro(_name) \
|
|
static struct freq_attr _name = \
|
|
__ATTR(_name, 0444, show_##_name, NULL)
|
|
|
|
#define cpufreq_freq_attr_ro_perm(_name, _perm) \
|
|
static struct freq_attr _name = \
|
|
__ATTR(_name, _perm, show_##_name, NULL)
|
|
|
|
#define cpufreq_freq_attr_rw(_name) \
|
|
static struct freq_attr _name = \
|
|
__ATTR(_name, 0644, show_##_name, store_##_name)
|
|
|
|
#define cpufreq_freq_attr_wo(_name) \
|
|
static struct freq_attr _name = \
|
|
__ATTR(_name, 0200, NULL, store_##_name)
|
|
|
|
struct global_attr {
|
|
struct attribute attr;
|
|
ssize_t (*show)(struct kobject *kobj,
|
|
struct attribute *attr, char *buf);
|
|
ssize_t (*store)(struct kobject *a, struct attribute *b,
|
|
const char *c, size_t count);
|
|
};
|
|
|
|
#define define_one_global_ro(_name) \
|
|
static struct global_attr _name = \
|
|
__ATTR(_name, 0444, show_##_name, NULL)
|
|
|
|
#define define_one_global_rw(_name) \
|
|
static struct global_attr _name = \
|
|
__ATTR(_name, 0644, show_##_name, store_##_name)
|
|
|
|
|
|
struct cpufreq_driver {
|
|
char name[CPUFREQ_NAME_LEN];
|
|
u8 flags;
|
|
void *driver_data;
|
|
|
|
/* needed by all drivers */
|
|
int (*init)(struct cpufreq_policy *policy);
|
|
int (*verify)(struct cpufreq_policy *policy);
|
|
|
|
/* define one out of two */
|
|
int (*setpolicy)(struct cpufreq_policy *policy);
|
|
|
|
/*
|
|
* On failure, should always restore frequency to policy->restore_freq
|
|
* (i.e. old freq).
|
|
*/
|
|
int (*target)(struct cpufreq_policy *policy,
|
|
unsigned int target_freq,
|
|
unsigned int relation); /* Deprecated */
|
|
int (*target_index)(struct cpufreq_policy *policy,
|
|
unsigned int index);
|
|
unsigned int (*fast_switch)(struct cpufreq_policy *policy,
|
|
unsigned int target_freq);
|
|
|
|
/*
|
|
* Caches and returns the lowest driver-supported frequency greater than
|
|
* or equal to the target frequency, subject to any driver limitations.
|
|
* Does not set the frequency. Only to be implemented for drivers with
|
|
* target().
|
|
*/
|
|
unsigned int (*resolve_freq)(struct cpufreq_policy *policy,
|
|
unsigned int target_freq);
|
|
|
|
/*
|
|
* Only for drivers with target_index() and CPUFREQ_ASYNC_NOTIFICATION
|
|
* unset.
|
|
*
|
|
* get_intermediate should return a stable intermediate frequency
|
|
* platform wants to switch to and target_intermediate() should set CPU
|
|
* to to that frequency, before jumping to the frequency corresponding
|
|
* to 'index'. Core will take care of sending notifications and driver
|
|
* doesn't have to handle them in target_intermediate() or
|
|
* target_index().
|
|
*
|
|
* Drivers can return '0' from get_intermediate() in case they don't
|
|
* wish to switch to intermediate frequency for some target frequency.
|
|
* In that case core will directly call ->target_index().
|
|
*/
|
|
unsigned int (*get_intermediate)(struct cpufreq_policy *policy,
|
|
unsigned int index);
|
|
int (*target_intermediate)(struct cpufreq_policy *policy,
|
|
unsigned int index);
|
|
|
|
/* should be defined, if possible */
|
|
unsigned int (*get)(unsigned int cpu);
|
|
|
|
/* optional */
|
|
int (*bios_limit)(int cpu, unsigned int *limit);
|
|
|
|
int (*exit)(struct cpufreq_policy *policy);
|
|
void (*stop_cpu)(struct cpufreq_policy *policy);
|
|
int (*suspend)(struct cpufreq_policy *policy);
|
|
int (*resume)(struct cpufreq_policy *policy);
|
|
|
|
/* Will be called after the driver is fully initialized */
|
|
void (*ready)(struct cpufreq_policy *policy);
|
|
|
|
struct freq_attr **attr;
|
|
|
|
/* platform specific boost support code */
|
|
bool boost_enabled;
|
|
int (*set_boost)(int state);
|
|
};
|
|
|
|
/* flags */
|
|
#define CPUFREQ_STICKY (1 << 0) /* driver isn't removed even if
|
|
all ->init() calls failed */
|
|
#define CPUFREQ_CONST_LOOPS (1 << 1) /* loops_per_jiffy or other
|
|
kernel "constants" aren't
|
|
affected by frequency
|
|
transitions */
|
|
#define CPUFREQ_PM_NO_WARN (1 << 2) /* don't warn on suspend/resume
|
|
speed mismatches */
|
|
|
|
/*
|
|
* 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 (1 << 3)
|
|
|
|
/*
|
|
* 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 (1 << 4)
|
|
|
|
/*
|
|
* 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 (1 << 5)
|
|
|
|
/*
|
|
* Set by drivers to disallow use of governors with "dynamic_switching" flag
|
|
* set.
|
|
*/
|
|
#define CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING (1 << 6)
|
|
|
|
int cpufreq_register_driver(struct cpufreq_driver *driver_data);
|
|
int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
|
|
|
|
const char *cpufreq_get_current_driver(void);
|
|
void *cpufreq_get_driver_data(void);
|
|
|
|
static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
|
|
unsigned int min, unsigned int max)
|
|
{
|
|
if (policy->min < min)
|
|
policy->min = min;
|
|
if (policy->max < min)
|
|
policy->max = min;
|
|
if (policy->min > max)
|
|
policy->min = max;
|
|
if (policy->max > max)
|
|
policy->max = max;
|
|
if (policy->min > policy->max)
|
|
policy->min = policy->max;
|
|
return;
|
|
}
|
|
|
|
static inline void
|
|
cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
|
|
{
|
|
cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
|
|
policy->cpuinfo.max_freq);
|
|
}
|
|
|
|
#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 (0)
|
|
#define CPUFREQ_POLICY_NOTIFIER (1)
|
|
|
|
/* Transition notifiers */
|
|
#define CPUFREQ_PRECHANGE (0)
|
|
#define CPUFREQ_POSTCHANGE (1)
|
|
|
|
/* Policy Notifiers */
|
|
#define CPUFREQ_ADJUST (0)
|
|
#define CPUFREQ_NOTIFY (1)
|
|
|
|
#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)
|
|
{
|
|
#if BITS_PER_LONG == 32
|
|
u64 result = ((u64) old) * ((u64) mult);
|
|
do_div(result, div);
|
|
return (unsigned long) result;
|
|
|
|
#elif BITS_PER_LONG == 64
|
|
unsigned long result = old * ((u64) mult);
|
|
result /= div;
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
/*********************************************************************
|
|
* CPUFREQ GOVERNORS *
|
|
*********************************************************************/
|
|
|
|
/*
|
|
* 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 (1)
|
|
#define CPUFREQ_POLICY_PERFORMANCE (2)
|
|
|
|
/*
|
|
* The polling frequency depends on the capability of the processor. Default
|
|
* polling frequency is 1000 times the transition latency of the processor. The
|
|
* ondemand governor will work on any processor with transition latency <= 10ms,
|
|
* using appropriate sampling rate.
|
|
*/
|
|
#define LATENCY_MULTIPLIER (1000)
|
|
|
|
struct cpufreq_governor {
|
|
char name[CPUFREQ_NAME_LEN];
|
|
int (*init)(struct cpufreq_policy *policy);
|
|
void (*exit)(struct cpufreq_policy *policy);
|
|
int (*start)(struct cpufreq_policy *policy);
|
|
void (*stop)(struct cpufreq_policy *policy);
|
|
void (*limits)(struct cpufreq_policy *policy);
|
|
ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
|
|
char *buf);
|
|
int (*store_setspeed) (struct cpufreq_policy *policy,
|
|
unsigned int freq);
|
|
/* For governors which change frequency dynamically by themselves */
|
|
bool dynamic_switching;
|
|
struct list_head governor_list;
|
|
struct module *owner;
|
|
};
|
|
|
|
/* Pass a target to the cpufreq driver */
|
|
unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
|
|
unsigned int target_freq);
|
|
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);
|
|
|
|
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)
|
|
{
|
|
if (policy->max < policy->cur)
|
|
__cpufreq_driver_target(policy, policy->max, CPUFREQ_RELATION_H);
|
|
else if (policy->min > policy->cur)
|
|
__cpufreq_driver_target(policy, policy->min, CPUFREQ_RELATION_L);
|
|
}
|
|
|
|
/* Governor attribute set */
|
|
struct gov_attr_set {
|
|
struct kobject kobj;
|
|
struct list_head policy_list;
|
|
struct mutex update_lock;
|
|
int usage_count;
|
|
};
|
|
|
|
/* sysfs ops for cpufreq governors */
|
|
extern const struct sysfs_ops governor_sysfs_ops;
|
|
|
|
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 {
|
|
struct attribute attr;
|
|
ssize_t (*show)(struct gov_attr_set *attr_set, char *buf);
|
|
ssize_t (*store)(struct gov_attr_set *attr_set, const char *buf,
|
|
size_t count);
|
|
};
|
|
|
|
static inline bool cpufreq_this_cpu_can_update(struct cpufreq_policy *policy)
|
|
{
|
|
/*
|
|
* Allow remote callbacks if:
|
|
* - dvfs_possible_from_any_cpu flag is set
|
|
* - the local and remote CPUs share cpufreq policy
|
|
*/
|
|
return policy->dvfs_possible_from_any_cpu ||
|
|
cpumask_test_cpu(smp_processor_id(), policy->cpus);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* FREQUENCY TABLE HELPERS *
|
|
*********************************************************************/
|
|
|
|
/* Special Values of .frequency field */
|
|
#define CPUFREQ_ENTRY_INVALID ~0u
|
|
#define CPUFREQ_TABLE_END ~1u
|
|
/* Special Values of .flags field */
|
|
#define CPUFREQ_BOOST_FREQ (1 << 0)
|
|
|
|
struct cpufreq_frequency_table {
|
|
unsigned int flags;
|
|
unsigned int driver_data; /* driver specific data, not used by core */
|
|
unsigned int frequency; /* kHz - doesn't need to be in ascending
|
|
* order */
|
|
};
|
|
|
|
#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
|
|
int dev_pm_opp_init_cpufreq_table(struct device *dev,
|
|
struct cpufreq_frequency_table **table);
|
|
void dev_pm_opp_free_cpufreq_table(struct device *dev,
|
|
struct cpufreq_frequency_table **table);
|
|
#else
|
|
static inline int dev_pm_opp_init_cpufreq_table(struct device *dev,
|
|
struct cpufreq_frequency_table
|
|
**table)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
static inline void dev_pm_opp_free_cpufreq_table(struct device *dev,
|
|
struct cpufreq_frequency_table
|
|
**table)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* 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) \
|
|
for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)
|
|
|
|
/*
|
|
* 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) \
|
|
for (pos = table, idx = 0; pos->frequency != CPUFREQ_TABLE_END; \
|
|
pos++, 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) \
|
|
for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) \
|
|
if (pos->frequency == CPUFREQ_ENTRY_INVALID) \
|
|
continue; \
|
|
else
|
|
|
|
/*
|
|
* 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_entry_idx(pos, table, idx) \
|
|
if (pos->frequency == CPUFREQ_ENTRY_INVALID) \
|
|
continue; \
|
|
else
|
|
|
|
|
|
int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
|
|
struct cpufreq_frequency_table *table);
|
|
|
|
int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
|
|
struct cpufreq_frequency_table *table);
|
|
int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *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);
|
|
int 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)
|
|
{
|
|
struct cpufreq_frequency_table *table = policy->freq_table;
|
|
struct cpufreq_frequency_table *pos;
|
|
unsigned int freq;
|
|
int idx, best = -1;
|
|
|
|
cpufreq_for_each_valid_entry_idx(pos, table, idx) {
|
|
freq = pos->frequency;
|
|
|
|
if (freq >= target_freq)
|
|
return idx;
|
|
|
|
best = idx;
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
struct cpufreq_frequency_table *table = policy->freq_table;
|
|
struct cpufreq_frequency_table *pos;
|
|
unsigned int freq;
|
|
int idx, best = -1;
|
|
|
|
cpufreq_for_each_valid_entry_idx(pos, table, idx) {
|
|
freq = pos->frequency;
|
|
|
|
if (freq == target_freq)
|
|
return idx;
|
|
|
|
if (freq > target_freq) {
|
|
best = idx;
|
|
continue;
|
|
}
|
|
|
|
/* No freq found above target_freq */
|
|
if (best == -1)
|
|
return idx;
|
|
|
|
return best;
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
/* Works only on sorted freq-tables */
|
|
static inline int cpufreq_table_find_index_l(struct cpufreq_policy *policy,
|
|
unsigned int target_freq)
|
|
{
|
|
target_freq = clamp_val(target_freq, policy->min, policy->max);
|
|
|
|
if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
|
|
return cpufreq_table_find_index_al(policy, target_freq);
|
|
else
|
|
return cpufreq_table_find_index_dl(policy, target_freq);
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
struct cpufreq_frequency_table *table = policy->freq_table;
|
|
struct cpufreq_frequency_table *pos;
|
|
unsigned int freq;
|
|
int idx, best = -1;
|
|
|
|
cpufreq_for_each_valid_entry_idx(pos, table, idx) {
|
|
freq = pos->frequency;
|
|
|
|
if (freq == target_freq)
|
|
return idx;
|
|
|
|
if (freq < target_freq) {
|
|
best = idx;
|
|
continue;
|
|
}
|
|
|
|
/* No freq found below target_freq */
|
|
if (best == -1)
|
|
return idx;
|
|
|
|
return best;
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
struct cpufreq_frequency_table *table = policy->freq_table;
|
|
struct cpufreq_frequency_table *pos;
|
|
unsigned int freq;
|
|
int idx, best = -1;
|
|
|
|
cpufreq_for_each_valid_entry_idx(pos, table, idx) {
|
|
freq = pos->frequency;
|
|
|
|
if (freq <= target_freq)
|
|
return idx;
|
|
|
|
best = idx;
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
/* Works only on sorted freq-tables */
|
|
static inline int cpufreq_table_find_index_h(struct cpufreq_policy *policy,
|
|
unsigned int target_freq)
|
|
{
|
|
target_freq = clamp_val(target_freq, policy->min, policy->max);
|
|
|
|
if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
|
|
return cpufreq_table_find_index_ah(policy, target_freq);
|
|
else
|
|
return cpufreq_table_find_index_dh(policy, target_freq);
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
struct cpufreq_frequency_table *table = policy->freq_table;
|
|
struct cpufreq_frequency_table *pos;
|
|
unsigned int freq;
|
|
int idx, best = -1;
|
|
|
|
cpufreq_for_each_valid_entry_idx(pos, table, idx) {
|
|
freq = pos->frequency;
|
|
|
|
if (freq == target_freq)
|
|
return idx;
|
|
|
|
if (freq < target_freq) {
|
|
best = idx;
|
|
continue;
|
|
}
|
|
|
|
/* No freq found below target_freq */
|
|
if (best == -1)
|
|
return idx;
|
|
|
|
/* Choose the closest freq */
|
|
if (target_freq - table[best].frequency > freq - target_freq)
|
|
return idx;
|
|
|
|
return best;
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
struct cpufreq_frequency_table *table = policy->freq_table;
|
|
struct cpufreq_frequency_table *pos;
|
|
unsigned int freq;
|
|
int idx, best = -1;
|
|
|
|
cpufreq_for_each_valid_entry_idx(pos, table, idx) {
|
|
freq = pos->frequency;
|
|
|
|
if (freq == target_freq)
|
|
return idx;
|
|
|
|
if (freq > target_freq) {
|
|
best = idx;
|
|
continue;
|
|
}
|
|
|
|
/* No freq found above target_freq */
|
|
if (best == -1)
|
|
return idx;
|
|
|
|
/* Choose the closest freq */
|
|
if (table[best].frequency - target_freq > target_freq - freq)
|
|
return idx;
|
|
|
|
return best;
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
/* Works only on sorted freq-tables */
|
|
static inline int cpufreq_table_find_index_c(struct cpufreq_policy *policy,
|
|
unsigned int target_freq)
|
|
{
|
|
target_freq = clamp_val(target_freq, policy->min, policy->max);
|
|
|
|
if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
|
|
return cpufreq_table_find_index_ac(policy, target_freq);
|
|
else
|
|
return cpufreq_table_find_index_dc(policy, target_freq);
|
|
}
|
|
|
|
static inline int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
|
|
unsigned int target_freq,
|
|
unsigned int relation)
|
|
{
|
|
if (unlikely(policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED))
|
|
return cpufreq_table_index_unsorted(policy, target_freq,
|
|
relation);
|
|
|
|
switch (relation) {
|
|
case CPUFREQ_RELATION_L:
|
|
return cpufreq_table_find_index_l(policy, target_freq);
|
|
case CPUFREQ_RELATION_H:
|
|
return cpufreq_table_find_index_h(policy, target_freq);
|
|
case CPUFREQ_RELATION_C:
|
|
return cpufreq_table_find_index_c(policy, target_freq);
|
|
default:
|
|
pr_err("%s: Invalid relation: %d\n", __func__, relation);
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
static inline int cpufreq_table_count_valid_entries(const struct cpufreq_policy *policy)
|
|
{
|
|
struct cpufreq_frequency_table *pos;
|
|
int count = 0;
|
|
|
|
if (unlikely(!policy->freq_table))
|
|
return 0;
|
|
|
|
cpufreq_for_each_valid_entry(pos, policy->freq_table)
|
|
count++;
|
|
|
|
return count;
|
|
}
|
|
#else
|
|
static inline int cpufreq_boost_trigger_state(int state)
|
|
{
|
|
return 0;
|
|
}
|
|
static inline int cpufreq_boost_enabled(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline int cpufreq_enable_boost_support(void)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
static inline bool policy_has_boost_freq(struct cpufreq_policy *policy)
|
|
{
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
extern void arch_freq_prepare_all(void);
|
|
extern unsigned int arch_freq_get_on_cpu(int cpu);
|
|
|
|
extern void arch_set_freq_scale(struct cpumask *cpus, unsigned long cur_freq,
|
|
unsigned long max_freq);
|
|
|
|
/* 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);
|
|
int cpufreq_generic_init(struct cpufreq_policy *policy,
|
|
struct cpufreq_frequency_table *table,
|
|
unsigned int transition_latency);
|
|
#endif /* _LINUX_CPUFREQ_H */
|