2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2013-06-19 16:49:33 +08:00
|
|
|
* linux/include/linux/cpufreq.h
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2013-06-19 16:49:33 +08:00
|
|
|
* Copyright (C) 2001 Russell King
|
|
|
|
|
* (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
|
2011-04-29 07:42:53 +08:00
|
|
|
*
|
2005-04-17 06:20:36 +08:00
|
|
|
* 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
|
|
|
|
|
|
2014-01-09 23:08:43 +08:00
|
|
|
#include <linux/clk.h>
|
2013-08-07 01:23:03 +08:00
|
|
|
#include <linux/cpumask.h>
|
|
|
|
|
#include <linux/completion.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/kobject.h>
|
2013-08-07 01:23:03 +08:00
|
|
|
#include <linux/notifier.h>
|
cpufreq: Make sure frequency transitions are serialized
Whenever we change the frequency of a CPU, we call the PRECHANGE and POSTCHANGE
notifiers. They must be serialized, i.e. PRECHANGE and POSTCHANGE notifiers
should strictly alternate, thereby preventing two different sets of PRECHANGE or
POSTCHANGE notifiers from interleaving arbitrarily.
The following examples illustrate why this is important:
Scenario 1:
-----------
A thread reading the value of cpuinfo_cur_freq, will call
__cpufreq_cpu_get()->cpufreq_out_of_sync()->cpufreq_notify_transition()
The ondemand governor can decide to change the frequency of the CPU at the same
time and hence it can end up sending the notifications via ->target().
If the notifiers are not serialized, the following sequence can occur:
- PRECHANGE Notification for freq A (from cpuinfo_cur_freq)
- PRECHANGE Notification for freq B (from target())
- Freq changed by target() to B
- POSTCHANGE Notification for freq B
- POSTCHANGE Notification for freq A
We can see from the above that the last POSTCHANGE Notification happens for freq
A but the hardware is set to run at freq B.
Where would we break then?: adjust_jiffies() in cpufreq.c & cpufreq_callback()
in arch/arm/kernel/smp.c (which also adjusts the jiffies). All the
loops_per_jiffy calculations will get messed up.
Scenario 2:
-----------
The governor calls __cpufreq_driver_target() to change the frequency. At the
same time, if we change scaling_{min|max}_freq from sysfs, it will end up
calling the governor's CPUFREQ_GOV_LIMITS notification, which will also call
__cpufreq_driver_target(). And hence we end up issuing concurrent calls to
->target().
Typically, platforms have the following logic in their ->target() routines:
(Eg: cpufreq-cpu0, omap, exynos, etc)
A. If new freq is more than old: Increase voltage
B. Change freq
C. If new freq is less than old: decrease voltage
Now, if the two concurrent calls to ->target() are X and Y, where X is trying to
increase the freq and Y is trying to decrease it, we get the following race
condition:
X.A: voltage gets increased for larger freq
Y.A: nothing happens
Y.B: freq gets decreased
Y.C: voltage gets decreased
X.B: freq gets increased
X.C: nothing happens
Thus we can end up setting a freq which is not supported by the voltage we have
set. That will probably make the clock to the CPU unstable and the system might
not work properly anymore.
This patch introduces a set of synchronization primitives to serialize frequency
transitions, which are to be used as shown below:
cpufreq_freq_transition_begin();
//Perform the frequency change
cpufreq_freq_transition_end();
The _begin() call sends the PRECHANGE notification whereas the _end() call sends
the POSTCHANGE notification. Also, all the necessary synchronization is handled
within these calls. In particular, even drivers which set the ASYNC_NOTIFICATION
flag can also use these APIs for performing frequency transitions (ie., you can
call _begin() from one task, and call the corresponding _end() from a different
task).
The actual synchronization underneath is not that complicated:
The key challenge is to allow drivers to begin the transition from one thread
and end it in a completely different thread (this is to enable drivers that do
asynchronous POSTCHANGE notification from bottom-halves, to also use the same
interface).
To achieve this, a 'transition_ongoing' flag, a 'transition_lock' spinlock and a
wait-queue are added per-policy. The flag and the wait-queue are used in
conjunction to create an "uninterrupted flow" from _begin() to _end(). The
spinlock is used to ensure that only one such "flow" is in flight at any given
time. Put together, this provides us all the necessary synchronization.
Signed-off-by: Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-03-24 16:05:44 +08:00
|
|
|
#include <linux/spinlock.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/sysfs.h>
|
|
|
|
|
|
|
|
|
|
/*********************************************************************
|
2013-08-07 01:23:04 +08:00
|
|
|
* CPUFREQ INTERFACE *
|
2005-04-17 06:20:36 +08:00
|
|
|
*********************************************************************/
|
2013-08-07 01:23:04 +08:00
|
|
|
/*
|
|
|
|
|
* Frequency values here are CPU kHz
|
|
|
|
|
*
|
2005-06-01 10:03:47 +08:00
|
|
|
* Maximum transition latency is in nanoseconds - if it's unknown,
|
2005-04-17 06:20:36 +08:00
|
|
|
* CPUFREQ_ETERNAL shall be used.
|
|
|
|
|
*/
|
|
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
#define CPUFREQ_ETERNAL (-1)
|
|
|
|
|
#define CPUFREQ_NAME_LEN 16
|
|
|
|
|
/* Print length for names. Extra 1 space for accomodating '\n' in prints */
|
|
|
|
|
#define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
struct cpufreq_governor;
|
|
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
struct cpufreq_freqs {
|
|
|
|
|
unsigned int cpu; /* cpu nr */
|
|
|
|
|
unsigned int old;
|
|
|
|
|
unsigned int new;
|
|
|
|
|
u8 flags; /* flags of cpufreq_driver, see below. */
|
|
|
|
|
};
|
2009-07-24 21:25:05 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
struct cpufreq_cpuinfo {
|
|
|
|
|
unsigned int max_freq;
|
|
|
|
|
unsigned int min_freq;
|
2011-04-29 07:42:53 +08:00
|
|
|
|
|
|
|
|
/* in 10^(-9) s = nanoseconds */
|
|
|
|
|
unsigned int transition_latency;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct cpufreq_real_policy {
|
|
|
|
|
unsigned int min; /* in kHz */
|
|
|
|
|
unsigned int max; /* in kHz */
|
2011-04-29 07:42:53 +08:00
|
|
|
unsigned int policy; /* see above */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct cpufreq_governor *governor; /* see below */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct cpufreq_policy {
|
2013-01-31 10:03:53 +08:00
|
|
|
/* CPUs sharing clock, require sw coordination */
|
|
|
|
|
cpumask_var_t cpus; /* Online CPUs only */
|
|
|
|
|
cpumask_var_t related_cpus; /* Online + Offline CPUs */
|
|
|
|
|
|
2013-02-01 14:40:02 +08:00
|
|
|
unsigned int shared_type; /* ACPI: ANY or ALL affected CPUs
|
2005-12-15 04:05:00 +08:00
|
|
|
should set cpufreq */
|
2013-01-14 21:23:03 +08:00
|
|
|
unsigned int cpu; /* cpu nr of CPU managing this policy */
|
|
|
|
|
unsigned int last_cpu; /* cpu nr of previous CPU that managed
|
|
|
|
|
* this policy */
|
2014-01-09 23:08:43 +08:00
|
|
|
struct clk *clk;
|
2005-04-17 06:20:36 +08:00
|
|
|
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 */
|
2014-06-03 01:19:28 +08:00
|
|
|
unsigned int restore_freq; /* = policy->cur before transition */
|
2014-03-04 11:00:27 +08:00
|
|
|
unsigned int suspend_freq; /* freq to set during suspend */
|
|
|
|
|
|
2011-04-29 07:42:53 +08:00
|
|
|
unsigned int policy; /* see above */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct cpufreq_governor *governor; /* see below */
|
2013-03-27 23:58:57 +08:00
|
|
|
void *governor_data;
|
cpufreq: Fix governor start/stop race condition
Cpufreq governors' stop and start operations should be carried out
in sequence. Otherwise, there will be unexpected behavior, like in
the example below.
Suppose there are 4 CPUs and policy->cpu=CPU0, CPU1/2/3 are linked
to CPU0. The normal sequence is:
1) Current governor is userspace. An application tries to set the
governor to ondemand. It will call __cpufreq_set_policy() in
which it will stop the userspace governor and then start the
ondemand governor.
2) Current governor is userspace. The online of CPU3 runs on CPU0.
It will call cpufreq_add_policy_cpu() in which it will first
stop the userspace governor, and then start it again.
If the sequence of the above two cases interleaves, it becomes:
1) Application stops userspace governor
2) Hotplug stops userspace governor
which is a problem, because the governor shouldn't be stopped twice
in a row. What happens next is:
3) Application starts ondemand governor
4) Hotplug starts a governor
In step 4, the hotplug is supposed to start the userspace governor,
but now the governor has been changed by the application to ondemand,
so the ondemand governor is started once again, which is incorrect.
The solution is to prevent policy governors from being stopped
multiple times in a row. A governor should only be stopped once for
one policy. After it has been stopped, no more governor stop
operations should be executed.
Also add a mutex to serialize governor operations.
[rjw: Changelog. And you owe me a beverage of my choice.]
Signed-off-by: Xiaoguang Chen <chenxg@marvell.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-06-19 15:00:07 +08:00
|
|
|
bool governor_enabled; /* governor start/stop flag */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
struct work_struct update; /* if update_policy() needs to be
|
|
|
|
|
* called, but you're in IRQ context */
|
|
|
|
|
|
|
|
|
|
struct cpufreq_real_policy user_policy;
|
2014-03-10 17:23:33 +08:00
|
|
|
struct cpufreq_frequency_table *freq_table;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-07 01:23:08 +08:00
|
|
|
struct list_head policy_list;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct kobject kobj;
|
|
|
|
|
struct completion kobj_unregister;
|
2013-10-18 21:40:15 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*
|
|
|
|
|
* Additional rules:
|
|
|
|
|
* - Lock should not be held across
|
|
|
|
|
* __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
|
|
|
|
|
*/
|
|
|
|
|
struct rw_semaphore rwsem;
|
cpufreq: Make sure frequency transitions are serialized
Whenever we change the frequency of a CPU, we call the PRECHANGE and POSTCHANGE
notifiers. They must be serialized, i.e. PRECHANGE and POSTCHANGE notifiers
should strictly alternate, thereby preventing two different sets of PRECHANGE or
POSTCHANGE notifiers from interleaving arbitrarily.
The following examples illustrate why this is important:
Scenario 1:
-----------
A thread reading the value of cpuinfo_cur_freq, will call
__cpufreq_cpu_get()->cpufreq_out_of_sync()->cpufreq_notify_transition()
The ondemand governor can decide to change the frequency of the CPU at the same
time and hence it can end up sending the notifications via ->target().
If the notifiers are not serialized, the following sequence can occur:
- PRECHANGE Notification for freq A (from cpuinfo_cur_freq)
- PRECHANGE Notification for freq B (from target())
- Freq changed by target() to B
- POSTCHANGE Notification for freq B
- POSTCHANGE Notification for freq A
We can see from the above that the last POSTCHANGE Notification happens for freq
A but the hardware is set to run at freq B.
Where would we break then?: adjust_jiffies() in cpufreq.c & cpufreq_callback()
in arch/arm/kernel/smp.c (which also adjusts the jiffies). All the
loops_per_jiffy calculations will get messed up.
Scenario 2:
-----------
The governor calls __cpufreq_driver_target() to change the frequency. At the
same time, if we change scaling_{min|max}_freq from sysfs, it will end up
calling the governor's CPUFREQ_GOV_LIMITS notification, which will also call
__cpufreq_driver_target(). And hence we end up issuing concurrent calls to
->target().
Typically, platforms have the following logic in their ->target() routines:
(Eg: cpufreq-cpu0, omap, exynos, etc)
A. If new freq is more than old: Increase voltage
B. Change freq
C. If new freq is less than old: decrease voltage
Now, if the two concurrent calls to ->target() are X and Y, where X is trying to
increase the freq and Y is trying to decrease it, we get the following race
condition:
X.A: voltage gets increased for larger freq
Y.A: nothing happens
Y.B: freq gets decreased
Y.C: voltage gets decreased
X.B: freq gets increased
X.C: nothing happens
Thus we can end up setting a freq which is not supported by the voltage we have
set. That will probably make the clock to the CPU unstable and the system might
not work properly anymore.
This patch introduces a set of synchronization primitives to serialize frequency
transitions, which are to be used as shown below:
cpufreq_freq_transition_begin();
//Perform the frequency change
cpufreq_freq_transition_end();
The _begin() call sends the PRECHANGE notification whereas the _end() call sends
the POSTCHANGE notification. Also, all the necessary synchronization is handled
within these calls. In particular, even drivers which set the ASYNC_NOTIFICATION
flag can also use these APIs for performing frequency transitions (ie., you can
call _begin() from one task, and call the corresponding _end() from a different
task).
The actual synchronization underneath is not that complicated:
The key challenge is to allow drivers to begin the transition from one thread
and end it in a completely different thread (this is to enable drivers that do
asynchronous POSTCHANGE notification from bottom-halves, to also use the same
interface).
To achieve this, a 'transition_ongoing' flag, a 'transition_lock' spinlock and a
wait-queue are added per-policy. The flag and the wait-queue are used in
conjunction to create an "uninterrupted flow" from _begin() to _end(). The
spinlock is used to ensure that only one such "flow" is in flight at any given
time. Put together, this provides us all the necessary synchronization.
Signed-off-by: Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-03-24 16:05:44 +08:00
|
|
|
|
|
|
|
|
/* Synchronization for frequency transitions */
|
|
|
|
|
bool transition_ongoing; /* Tracks transition status */
|
|
|
|
|
spinlock_t transition_lock;
|
|
|
|
|
wait_queue_head_t transition_wait;
|
cpufreq: Catch double invocations of cpufreq_freq_transition_begin/end
Some cpufreq drivers were redundantly invoking the _begin() and _end()
APIs around frequency transitions, and this double invocation (one from
the cpufreq core and the other from the cpufreq driver) used to result
in a self-deadlock, leading to system hangs during boot. (The _begin()
API makes contending callers wait until the previous invocation is
complete. Hence, the cpufreq driver would end up waiting on itself!).
Now all such drivers have been fixed, but debugging this issue was not
very straight-forward (even lockdep didn't catch this). So let us add a
debug infrastructure to the cpufreq core to catch such issues more easily
in the future.
We add a new field called 'transition_task' to the policy structure, to keep
track of the task which is performing the frequency transition. Using this
field, we make note of this task during _begin() and print a warning if we
find a case where the same task is calling _begin() again, before completing
the previous frequency transition using the corresponding _end().
We have left out ASYNC_NOTIFICATION drivers from this debug infrastructure
for 2 reasons:
1. At the moment, we have no way to avoid a particular scenario where this
debug infrastructure can emit false-positive warnings for such drivers.
The scenario is depicted below:
Task A Task B
/* 1st freq transition */
Invoke _begin() {
...
...
}
Change the frequency
/* 2nd freq transition */
Invoke _begin() {
... //waiting for B to
... //finish _end() for
... //the 1st transition
... | Got interrupt for successful
... | change of frequency (1st one).
... |
... | /* 1st freq transition */
... | Invoke _end() {
... | ...
... V }
...
...
}
This scenario is actually deadlock-free because, once Task A changes the
frequency, it is Task B's responsibility to invoke the corresponding
_end() for the 1st frequency transition. Hence it is perfectly legal for
Task A to go ahead and attempt another frequency transition in the meantime.
(Of course it won't be able to proceed until Task B finishes the 1st _end(),
but this doesn't cause a deadlock or a hang).
The debug infrastructure cannot handle this scenario and will treat it as
a deadlock and print a warning. To avoid this, we exclude such drivers
from the purview of this code.
2. Luckily, we don't _need_ this infrastructure for ASYNC_NOTIFICATION drivers
at all! The cpufreq core does not automatically invoke the _begin() and
_end() APIs during frequency transitions in such drivers. Thus, the driver
alone is responsible for invoking _begin()/_end() and hence there shouldn't
be any conflicts which lead to double invocations. So, we can skip these
drivers, since the probability that such drivers will hit this problem is
extremely low, as outlined above.
Signed-off-by: Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-05-05 15:22:39 +08:00
|
|
|
struct task_struct *transition_task; /* Task which is doing the transition */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
2013-02-01 14:40:02 +08:00
|
|
|
/* Only for ACPI */
|
2006-06-26 12:34:43 +08:00
|
|
|
#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*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-10-08 16:56:11 +08:00
|
|
|
#ifdef CONFIG_CPU_FREQ
|
2013-08-07 01:23:04 +08:00
|
|
|
struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
|
2013-08-07 01:23:05 +08:00
|
|
|
void cpufreq_cpu_put(struct cpufreq_policy *policy);
|
2013-10-08 16:56:11 +08:00
|
|
|
#else
|
|
|
|
|
static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { }
|
|
|
|
|
#endif
|
2013-08-07 01:23:04 +08:00
|
|
|
|
2013-01-31 17:44:40 +08:00
|
|
|
static inline bool policy_is_shared(struct cpufreq_policy *policy)
|
|
|
|
|
{
|
|
|
|
|
return cpumask_weight(policy->cpus) > 1;
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
/* /sys/devices/system/cpu/cpufreq: entry point for global variables */
|
|
|
|
|
extern struct kobject *cpufreq_global_kobject;
|
|
|
|
|
int cpufreq_get_global_kobject(void);
|
|
|
|
|
void cpufreq_put_global_kobject(void);
|
|
|
|
|
int cpufreq_sysfs_create_file(const struct attribute *attr);
|
|
|
|
|
void cpufreq_sysfs_remove_file(const struct attribute *attr);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
#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);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
|
|
|
|
|
int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
|
|
|
|
|
int cpufreq_update_policy(unsigned int cpu);
|
|
|
|
|
bool have_governor_per_policy(void);
|
|
|
|
|
struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
|
|
|
|
|
#else
|
|
|
|
|
static inline unsigned int cpufreq_get(unsigned int cpu)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-08-07 01:23:04 +08:00
|
|
|
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) { }
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*********************************************************************
|
2013-08-07 01:23:04 +08:00
|
|
|
* CPUFREQ DRIVER INTERFACE *
|
2005-04-17 06:20:36 +08:00
|
|
|
*********************************************************************/
|
|
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
#define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */
|
|
|
|
|
#define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
struct freq_attr {
|
|
|
|
|
struct attribute attr;
|
|
|
|
|
ssize_t (*show)(struct cpufreq_policy *, char *);
|
|
|
|
|
ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
#define cpufreq_freq_attr_ro(_name) \
|
|
|
|
|
static struct freq_attr _name = \
|
|
|
|
|
__ATTR(_name, 0444, show_##_name, NULL)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
#define cpufreq_freq_attr_ro_perm(_name, _perm) \
|
|
|
|
|
static struct freq_attr _name = \
|
|
|
|
|
__ATTR(_name, _perm, show_##_name, NULL)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
#define cpufreq_freq_attr_rw(_name) \
|
|
|
|
|
static struct freq_attr _name = \
|
|
|
|
|
__ATTR(_name, 0644, show_##_name, 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)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
struct cpufreq_driver {
|
|
|
|
|
char name[CPUFREQ_NAME_LEN];
|
|
|
|
|
u8 flags;
|
|
|
|
|
|
|
|
|
|
/* 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);
|
2014-06-03 01:19:28 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* On failure, should always restore frequency to policy->restore_freq
|
|
|
|
|
* (i.e. old freq).
|
|
|
|
|
*/
|
2013-10-25 22:15:48 +08:00
|
|
|
int (*target) (struct cpufreq_policy *policy, /* Deprecated */
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int target_freq,
|
|
|
|
|
unsigned int relation);
|
2013-10-25 22:15:48 +08:00
|
|
|
int (*target_index) (struct cpufreq_policy *policy,
|
|
|
|
|
unsigned int index);
|
2014-06-03 01:19:28 +08:00
|
|
|
/*
|
|
|
|
|
* 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);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* should be defined, if possible */
|
|
|
|
|
unsigned int (*get) (unsigned int cpu);
|
|
|
|
|
|
|
|
|
|
/* optional */
|
2009-11-19 19:31:01 +08:00
|
|
|
int (*bios_limit) (int cpu, unsigned int *limit);
|
2008-08-05 02:59:07 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
int (*exit) (struct cpufreq_policy *policy);
|
2014-03-19 23:45:53 +08:00
|
|
|
void (*stop_cpu) (struct cpufreq_policy *policy);
|
2011-03-11 04:13:05 +08:00
|
|
|
int (*suspend) (struct cpufreq_policy *policy);
|
2005-04-17 06:20:36 +08:00
|
|
|
int (*resume) (struct cpufreq_policy *policy);
|
|
|
|
|
struct freq_attr **attr;
|
2013-12-20 22:24:49 +08:00
|
|
|
|
|
|
|
|
/* platform specific boost support code */
|
|
|
|
|
bool boost_supported;
|
|
|
|
|
bool boost_enabled;
|
|
|
|
|
int (*set_boost) (int state);
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* flags */
|
2013-10-02 16:43:17 +08:00
|
|
|
#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 */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-10-02 16:43:18 +08:00
|
|
|
/*
|
|
|
|
|
* 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)
|
|
|
|
|
|
2013-10-29 21:26:06 +08:00
|
|
|
/*
|
|
|
|
|
* 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)
|
|
|
|
|
|
2013-12-03 13:50:45 +08:00
|
|
|
/*
|
|
|
|
|
* 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)
|
|
|
|
|
|
2007-02-27 06:55:48 +08:00
|
|
|
int cpufreq_register_driver(struct cpufreq_driver *driver_data);
|
|
|
|
|
int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
const char *cpufreq_get_current_driver(void);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-06-19 16:49:33 +08:00
|
|
|
static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
|
|
|
|
|
unsigned int min, unsigned int max)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-02 16:43:19 +08:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-04 11:00:26 +08:00
|
|
|
#ifdef CONFIG_CPU_FREQ
|
|
|
|
|
void cpufreq_suspend(void);
|
|
|
|
|
void cpufreq_resume(void);
|
2014-03-04 11:00:27 +08:00
|
|
|
int cpufreq_generic_suspend(struct cpufreq_policy *policy);
|
2014-03-04 11:00:26 +08:00
|
|
|
#else
|
|
|
|
|
static inline void cpufreq_suspend(void) {}
|
|
|
|
|
static inline void cpufreq_resume(void) {}
|
|
|
|
|
#endif
|
|
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
/*********************************************************************
|
|
|
|
|
* CPUFREQ NOTIFIER INTERFACE *
|
|
|
|
|
*********************************************************************/
|
2010-04-01 03:56:46 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
#define CPUFREQ_TRANSITION_NOTIFIER (0)
|
|
|
|
|
#define CPUFREQ_POLICY_NOTIFIER (1)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
/* Transition notifiers */
|
|
|
|
|
#define CPUFREQ_PRECHANGE (0)
|
|
|
|
|
#define CPUFREQ_POSTCHANGE (1)
|
2010-04-01 03:56:46 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
/* Policy Notifiers */
|
|
|
|
|
#define CPUFREQ_ADJUST (0)
|
|
|
|
|
#define CPUFREQ_INCOMPATIBLE (1)
|
|
|
|
|
#define CPUFREQ_NOTIFY (2)
|
|
|
|
|
#define CPUFREQ_START (3)
|
|
|
|
|
#define CPUFREQ_UPDATE_POLICY_CPU (4)
|
2014-01-07 09:40:10 +08:00
|
|
|
#define CPUFREQ_CREATE_POLICY (5)
|
|
|
|
|
#define CPUFREQ_REMOVE_POLICY (6)
|
2010-04-01 03:56:46 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
#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);
|
2010-04-01 03:56:46 +08:00
|
|
|
|
cpufreq: Make sure frequency transitions are serialized
Whenever we change the frequency of a CPU, we call the PRECHANGE and POSTCHANGE
notifiers. They must be serialized, i.e. PRECHANGE and POSTCHANGE notifiers
should strictly alternate, thereby preventing two different sets of PRECHANGE or
POSTCHANGE notifiers from interleaving arbitrarily.
The following examples illustrate why this is important:
Scenario 1:
-----------
A thread reading the value of cpuinfo_cur_freq, will call
__cpufreq_cpu_get()->cpufreq_out_of_sync()->cpufreq_notify_transition()
The ondemand governor can decide to change the frequency of the CPU at the same
time and hence it can end up sending the notifications via ->target().
If the notifiers are not serialized, the following sequence can occur:
- PRECHANGE Notification for freq A (from cpuinfo_cur_freq)
- PRECHANGE Notification for freq B (from target())
- Freq changed by target() to B
- POSTCHANGE Notification for freq B
- POSTCHANGE Notification for freq A
We can see from the above that the last POSTCHANGE Notification happens for freq
A but the hardware is set to run at freq B.
Where would we break then?: adjust_jiffies() in cpufreq.c & cpufreq_callback()
in arch/arm/kernel/smp.c (which also adjusts the jiffies). All the
loops_per_jiffy calculations will get messed up.
Scenario 2:
-----------
The governor calls __cpufreq_driver_target() to change the frequency. At the
same time, if we change scaling_{min|max}_freq from sysfs, it will end up
calling the governor's CPUFREQ_GOV_LIMITS notification, which will also call
__cpufreq_driver_target(). And hence we end up issuing concurrent calls to
->target().
Typically, platforms have the following logic in their ->target() routines:
(Eg: cpufreq-cpu0, omap, exynos, etc)
A. If new freq is more than old: Increase voltage
B. Change freq
C. If new freq is less than old: decrease voltage
Now, if the two concurrent calls to ->target() are X and Y, where X is trying to
increase the freq and Y is trying to decrease it, we get the following race
condition:
X.A: voltage gets increased for larger freq
Y.A: nothing happens
Y.B: freq gets decreased
Y.C: voltage gets decreased
X.B: freq gets increased
X.C: nothing happens
Thus we can end up setting a freq which is not supported by the voltage we have
set. That will probably make the clock to the CPU unstable and the system might
not work properly anymore.
This patch introduces a set of synchronization primitives to serialize frequency
transitions, which are to be used as shown below:
cpufreq_freq_transition_begin();
//Perform the frequency change
cpufreq_freq_transition_end();
The _begin() call sends the PRECHANGE notification whereas the _end() call sends
the POSTCHANGE notification. Also, all the necessary synchronization is handled
within these calls. In particular, even drivers which set the ASYNC_NOTIFICATION
flag can also use these APIs for performing frequency transitions (ie., you can
call _begin() from one task, and call the corresponding _end() from a different
task).
The actual synchronization underneath is not that complicated:
The key challenge is to allow drivers to begin the transition from one thread
and end it in a completely different thread (this is to enable drivers that do
asynchronous POSTCHANGE notification from bottom-halves, to also use the same
interface).
To achieve this, a 'transition_ongoing' flag, a 'transition_lock' spinlock and a
wait-queue are added per-policy. The flag and the wait-queue are used in
conjunction to create an "uninterrupted flow" from _begin() to _end(). The
spinlock is used to ensure that only one such "flow" is in flight at any given
time. Put together, this provides us all the necessary synchronization.
Signed-off-by: Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-03-24 16:05:44 +08:00
|
|
|
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);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
#else /* CONFIG_CPU_FREQ */
|
|
|
|
|
static inline int cpufreq_register_notifier(struct notifier_block *nb,
|
|
|
|
|
unsigned int list)
|
2009-10-27 07:49:29 +08:00
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2013-08-07 01:23:04 +08:00
|
|
|
static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
|
|
|
|
|
unsigned int list)
|
2005-12-03 02:43:20 +08:00
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2013-08-07 01:23:04 +08:00
|
|
|
#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)
|
2011-06-29 01:59:12 +08:00
|
|
|
{
|
2013-08-07 01:23:04 +08:00
|
|
|
#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;
|
2005-12-03 02:43:20 +08:00
|
|
|
#endif
|
2013-08-07 01:23:04 +08:00
|
|
|
}
|
2005-12-03 02:43:20 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*********************************************************************
|
2013-08-07 01:23:04 +08:00
|
|
|
* CPUFREQ GOVERNORS *
|
2005-04-17 06:20:36 +08:00
|
|
|
*********************************************************************/
|
|
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
/*
|
|
|
|
|
* 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)
|
|
|
|
|
|
|
|
|
|
/* Governor Events */
|
|
|
|
|
#define CPUFREQ_GOV_START 1
|
|
|
|
|
#define CPUFREQ_GOV_STOP 2
|
|
|
|
|
#define CPUFREQ_GOV_LIMITS 3
|
|
|
|
|
#define CPUFREQ_GOV_POLICY_INIT 4
|
|
|
|
|
#define CPUFREQ_GOV_POLICY_EXIT 5
|
|
|
|
|
|
|
|
|
|
struct cpufreq_governor {
|
|
|
|
|
char name[CPUFREQ_NAME_LEN];
|
|
|
|
|
int initialized;
|
|
|
|
|
int (*governor) (struct cpufreq_policy *policy,
|
|
|
|
|
unsigned int event);
|
|
|
|
|
ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
|
|
|
|
|
char *buf);
|
|
|
|
|
int (*store_setspeed) (struct cpufreq_policy *policy,
|
|
|
|
|
unsigned int freq);
|
|
|
|
|
unsigned int max_transition_latency; /* HW must be able to switch to
|
|
|
|
|
next freq faster than this value in nano secs or we
|
|
|
|
|
will fallback to performance governor */
|
|
|
|
|
struct list_head governor_list;
|
|
|
|
|
struct module *owner;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Pass a target to the cpufreq driver */
|
|
|
|
|
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);
|
|
|
|
|
int cpufreq_register_governor(struct cpufreq_governor *governor);
|
|
|
|
|
void cpufreq_unregister_governor(struct cpufreq_governor *governor);
|
|
|
|
|
|
|
|
|
|
/* CPUFREQ DEFAULT GOVERNOR */
|
2007-10-03 04:28:12 +08:00
|
|
|
/*
|
2013-06-19 16:49:33 +08:00
|
|
|
* Performance governor is fallback governor if any other gov failed to auto
|
|
|
|
|
* load due latency restrictions
|
|
|
|
|
*/
|
2007-10-03 04:28:13 +08:00
|
|
|
#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
|
2005-04-17 06:20:36 +08:00
|
|
|
extern struct cpufreq_governor cpufreq_gov_performance;
|
2007-10-03 04:28:13 +08:00
|
|
|
#endif
|
2007-10-03 04:28:12 +08:00
|
|
|
#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
|
|
|
|
|
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_performance)
|
2008-04-19 04:31:13 +08:00
|
|
|
#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE)
|
|
|
|
|
extern struct cpufreq_governor cpufreq_gov_powersave;
|
|
|
|
|
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_powersave)
|
2005-04-17 06:20:36 +08:00
|
|
|
#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
|
|
|
|
|
extern struct cpufreq_governor cpufreq_gov_userspace;
|
2007-10-03 04:28:12 +08:00
|
|
|
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_userspace)
|
|
|
|
|
#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND)
|
|
|
|
|
extern struct cpufreq_governor cpufreq_gov_ondemand;
|
|
|
|
|
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_ondemand)
|
|
|
|
|
#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE)
|
|
|
|
|
extern struct cpufreq_governor cpufreq_gov_conservative;
|
|
|
|
|
#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_conservative)
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*********************************************************************
|
|
|
|
|
* FREQUENCY TABLE HELPERS *
|
|
|
|
|
*********************************************************************/
|
|
|
|
|
|
2014-03-28 21:41:47 +08:00
|
|
|
/* Special Values of .frequency field */
|
|
|
|
|
#define CPUFREQ_ENTRY_INVALID ~0
|
|
|
|
|
#define CPUFREQ_TABLE_END ~1
|
|
|
|
|
/* Special Values of .flags field */
|
|
|
|
|
#define CPUFREQ_BOOST_FREQ (1 << 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
struct cpufreq_frequency_table {
|
2014-03-28 21:41:47 +08:00
|
|
|
unsigned int flags;
|
2013-03-30 18:55:15 +08:00
|
|
|
unsigned int driver_data; /* driver specific data, not used by core */
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int frequency; /* kHz - doesn't need to be in ascending
|
|
|
|
|
* order */
|
|
|
|
|
};
|
|
|
|
|
|
2014-05-05 21:33:50 +08:00
|
|
|
#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
|
|
|
|
|
|
2014-05-08 00:33:33 +08:00
|
|
|
static inline bool cpufreq_next_valid(struct cpufreq_frequency_table **pos)
|
|
|
|
|
{
|
|
|
|
|
while ((*pos)->frequency != CPUFREQ_TABLE_END)
|
|
|
|
|
if ((*pos)->frequency != CPUFREQ_ENTRY_INVALID)
|
|
|
|
|
return true;
|
|
|
|
|
else
|
|
|
|
|
(*pos)++;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2014-04-26 04:15:23 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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_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; cpufreq_next_valid(&pos); pos++)
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
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);
|
2013-10-03 22:57:55 +08:00
|
|
|
int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
|
|
|
|
|
struct cpufreq_frequency_table *table,
|
|
|
|
|
unsigned int target_freq,
|
|
|
|
|
unsigned int relation,
|
|
|
|
|
unsigned int *index);
|
2013-12-03 13:50:46 +08:00
|
|
|
int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
|
|
|
|
|
unsigned int freq);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-07 01:23:04 +08:00
|
|
|
ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
|
|
|
|
|
|
2013-12-20 22:24:49 +08:00
|
|
|
#ifdef CONFIG_CPU_FREQ
|
|
|
|
|
int cpufreq_boost_trigger_state(int state);
|
|
|
|
|
int cpufreq_boost_supported(void);
|
|
|
|
|
int cpufreq_boost_enabled(void);
|
|
|
|
|
#else
|
|
|
|
|
static inline int cpufreq_boost_trigger_state(int state)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
static inline int cpufreq_boost_supported(void)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
static inline int cpufreq_boost_enabled(void)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2013-08-07 01:23:04 +08:00
|
|
|
/* the following funtion is for cpufreq core use only */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
|
|
|
|
|
|
|
|
|
|
/* the following are really really optional */
|
|
|
|
|
extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
|
2013-10-03 22:57:55 +08:00
|
|
|
extern struct freq_attr *cpufreq_generic_attr[];
|
2013-09-16 21:26:03 +08:00
|
|
|
int cpufreq_table_validate_and_show(struct cpufreq_policy *policy,
|
|
|
|
|
struct cpufreq_frequency_table *table);
|
2013-06-27 15:08:54 +08:00
|
|
|
|
2014-01-09 23:08:43 +08:00
|
|
|
unsigned int cpufreq_generic_get(unsigned int cpu);
|
2013-10-03 22:59:07 +08:00
|
|
|
int cpufreq_generic_init(struct cpufreq_policy *policy,
|
|
|
|
|
struct cpufreq_frequency_table *table,
|
|
|
|
|
unsigned int transition_latency);
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* _LINUX_CPUFREQ_H */
|