mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-13 22:25:03 +00:00
4c637b2175
The usual scheme to initialize a cpuidle driver on a SMP is:
cpuidle_register_driver(drv);
for_each_possible_cpu(cpu) {
device = &per_cpu(cpuidle_dev, cpu);
cpuidle_register_device(device);
}
This code is duplicated in each cpuidle driver.
On UP systems, it is done this way:
cpuidle_register_driver(drv);
device = &per_cpu(cpuidle_dev, cpu);
cpuidle_register_device(device);
On UP, the macro 'for_each_cpu' does one iteration:
#define for_each_cpu(cpu, mask) \
for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
Hence, the initialization loop is the same for UP than SMP.
Beside, we saw different bugs / mis-initialization / return code unchecked in
the different drivers, the code is duplicated including bugs. After fixing all
these ones, it appears the initialization pattern is the same for everyone.
Please note, some drivers are doing dev->state_count = drv->state_count. This is
not necessary because it is done by the cpuidle_enable_device function in the
cpuidle framework. This is true, until you have the same states for all your
devices. Otherwise, the 'low level' API should be used instead with the specific
initialization for the driver.
Let's add a wrapper function doing this initialization with a cpumask parameter
for the coupled idle states and use it for all the drivers.
That will save a lot of LOC, consolidate the code, and the modifications in the
future could be done in a single place. Another benefit is the consolidation of
the cpuidle_device variable which is now in the cpuidle framework and no longer
spread accross the different arch specific drivers.
Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
215 lines
6.5 KiB
C
215 lines
6.5 KiB
C
/*
|
|
* cpuidle.h - a generic framework for CPU idle power management
|
|
*
|
|
* (C) 2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
|
|
* Shaohua Li <shaohua.li@intel.com>
|
|
* Adam Belay <abelay@novell.com>
|
|
*
|
|
* This code is licenced under the GPL.
|
|
*/
|
|
|
|
#ifndef _LINUX_CPUIDLE_H
|
|
#define _LINUX_CPUIDLE_H
|
|
|
|
#include <linux/percpu.h>
|
|
#include <linux/list.h>
|
|
#include <linux/kobject.h>
|
|
#include <linux/completion.h>
|
|
#include <linux/hrtimer.h>
|
|
|
|
#define CPUIDLE_STATE_MAX 8
|
|
#define CPUIDLE_NAME_LEN 16
|
|
#define CPUIDLE_DESC_LEN 32
|
|
|
|
struct module;
|
|
|
|
struct cpuidle_device;
|
|
struct cpuidle_driver;
|
|
|
|
|
|
/****************************
|
|
* CPUIDLE DEVICE INTERFACE *
|
|
****************************/
|
|
|
|
struct cpuidle_state_usage {
|
|
unsigned long long disable;
|
|
unsigned long long usage;
|
|
unsigned long long time; /* in US */
|
|
};
|
|
|
|
struct cpuidle_state {
|
|
char name[CPUIDLE_NAME_LEN];
|
|
char desc[CPUIDLE_DESC_LEN];
|
|
|
|
unsigned int flags;
|
|
unsigned int exit_latency; /* in US */
|
|
int power_usage; /* in mW */
|
|
unsigned int target_residency; /* in US */
|
|
bool disabled; /* disabled on all CPUs */
|
|
|
|
int (*enter) (struct cpuidle_device *dev,
|
|
struct cpuidle_driver *drv,
|
|
int index);
|
|
|
|
int (*enter_dead) (struct cpuidle_device *dev, int index);
|
|
};
|
|
|
|
/* Idle State Flags */
|
|
#define CPUIDLE_FLAG_TIME_VALID (0x01) /* is residency time measurable? */
|
|
#define CPUIDLE_FLAG_COUPLED (0x02) /* state applies to multiple cpus */
|
|
#define CPUIDLE_FLAG_TIMER_STOP (0x04) /* timer is stopped on this state */
|
|
|
|
#define CPUIDLE_DRIVER_FLAGS_MASK (0xFFFF0000)
|
|
|
|
struct cpuidle_device {
|
|
unsigned int registered:1;
|
|
unsigned int enabled:1;
|
|
unsigned int cpu;
|
|
|
|
int last_residency;
|
|
int state_count;
|
|
struct cpuidle_state_usage states_usage[CPUIDLE_STATE_MAX];
|
|
struct cpuidle_state_kobj *kobjs[CPUIDLE_STATE_MAX];
|
|
struct cpuidle_driver_kobj *kobj_driver;
|
|
struct list_head device_list;
|
|
struct kobject kobj;
|
|
struct completion kobj_unregister;
|
|
|
|
#ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
|
|
int safe_state_index;
|
|
cpumask_t coupled_cpus;
|
|
struct cpuidle_coupled *coupled;
|
|
#endif
|
|
};
|
|
|
|
DECLARE_PER_CPU(struct cpuidle_device *, cpuidle_devices);
|
|
|
|
/**
|
|
* cpuidle_get_last_residency - retrieves the last state's residency time
|
|
* @dev: the target CPU
|
|
*
|
|
* NOTE: this value is invalid if CPUIDLE_FLAG_TIME_VALID isn't set
|
|
*/
|
|
static inline int cpuidle_get_last_residency(struct cpuidle_device *dev)
|
|
{
|
|
return dev->last_residency;
|
|
}
|
|
|
|
|
|
/****************************
|
|
* CPUIDLE DRIVER INTERFACE *
|
|
****************************/
|
|
|
|
struct cpuidle_driver {
|
|
const char *name;
|
|
struct module *owner;
|
|
int refcnt;
|
|
|
|
/* used by the cpuidle framework to setup the broadcast timer */
|
|
unsigned int bctimer:1;
|
|
/* states array must be ordered in decreasing power consumption */
|
|
struct cpuidle_state states[CPUIDLE_STATE_MAX];
|
|
int state_count;
|
|
int safe_state_index;
|
|
};
|
|
|
|
#ifdef CONFIG_CPU_IDLE
|
|
extern void disable_cpuidle(void);
|
|
extern int cpuidle_idle_call(void);
|
|
extern int cpuidle_register_driver(struct cpuidle_driver *drv);
|
|
extern struct cpuidle_driver *cpuidle_get_driver(void);
|
|
extern struct cpuidle_driver *cpuidle_driver_ref(void);
|
|
extern void cpuidle_driver_unref(void);
|
|
extern void cpuidle_unregister_driver(struct cpuidle_driver *drv);
|
|
extern int cpuidle_register_device(struct cpuidle_device *dev);
|
|
extern void cpuidle_unregister_device(struct cpuidle_device *dev);
|
|
extern int cpuidle_register(struct cpuidle_driver *drv,
|
|
const struct cpumask *const coupled_cpus);
|
|
extern void cpuidle_unregister(struct cpuidle_driver *drv);
|
|
extern void cpuidle_pause_and_lock(void);
|
|
extern void cpuidle_resume_and_unlock(void);
|
|
extern void cpuidle_pause(void);
|
|
extern void cpuidle_resume(void);
|
|
extern int cpuidle_enable_device(struct cpuidle_device *dev);
|
|
extern void cpuidle_disable_device(struct cpuidle_device *dev);
|
|
extern int cpuidle_play_dead(void);
|
|
|
|
extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev);
|
|
extern int cpuidle_register_cpu_driver(struct cpuidle_driver *drv, int cpu);
|
|
extern void cpuidle_unregister_cpu_driver(struct cpuidle_driver *drv, int cpu);
|
|
|
|
#else
|
|
static inline void disable_cpuidle(void) { }
|
|
static inline int cpuidle_idle_call(void) { return -ENODEV; }
|
|
static inline int cpuidle_register_driver(struct cpuidle_driver *drv)
|
|
{return -ENODEV; }
|
|
static inline struct cpuidle_driver *cpuidle_get_driver(void) {return NULL; }
|
|
static inline struct cpuidle_driver *cpuidle_driver_ref(void) {return NULL; }
|
|
static inline void cpuidle_driver_unref(void) {}
|
|
static inline void cpuidle_unregister_driver(struct cpuidle_driver *drv) { }
|
|
static inline int cpuidle_register_device(struct cpuidle_device *dev)
|
|
{return -ENODEV; }
|
|
static inline void cpuidle_unregister_device(struct cpuidle_device *dev) { }
|
|
static inline int cpuidle_register(struct cpuidle_driver *drv,
|
|
const struct cpumask *const coupled_cpus)
|
|
{return -ENODEV; }
|
|
static inline void cpuidle_unregister(struct cpuidle_driver *drv) { }
|
|
static inline void cpuidle_pause_and_lock(void) { }
|
|
static inline void cpuidle_resume_and_unlock(void) { }
|
|
static inline void cpuidle_pause(void) { }
|
|
static inline void cpuidle_resume(void) { }
|
|
static inline int cpuidle_enable_device(struct cpuidle_device *dev)
|
|
{return -ENODEV; }
|
|
static inline void cpuidle_disable_device(struct cpuidle_device *dev) { }
|
|
static inline int cpuidle_play_dead(void) {return -ENODEV; }
|
|
#endif
|
|
|
|
#ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
|
|
void cpuidle_coupled_parallel_barrier(struct cpuidle_device *dev, atomic_t *a);
|
|
#else
|
|
static inline void cpuidle_coupled_parallel_barrier(struct cpuidle_device *dev, atomic_t *a)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/******************************
|
|
* CPUIDLE GOVERNOR INTERFACE *
|
|
******************************/
|
|
|
|
struct cpuidle_governor {
|
|
char name[CPUIDLE_NAME_LEN];
|
|
struct list_head governor_list;
|
|
unsigned int rating;
|
|
|
|
int (*enable) (struct cpuidle_driver *drv,
|
|
struct cpuidle_device *dev);
|
|
void (*disable) (struct cpuidle_driver *drv,
|
|
struct cpuidle_device *dev);
|
|
|
|
int (*select) (struct cpuidle_driver *drv,
|
|
struct cpuidle_device *dev);
|
|
void (*reflect) (struct cpuidle_device *dev, int index);
|
|
|
|
struct module *owner;
|
|
};
|
|
|
|
#ifdef CONFIG_CPU_IDLE
|
|
|
|
extern int cpuidle_register_governor(struct cpuidle_governor *gov);
|
|
extern void cpuidle_unregister_governor(struct cpuidle_governor *gov);
|
|
|
|
#else
|
|
|
|
static inline int cpuidle_register_governor(struct cpuidle_governor *gov)
|
|
{return 0;}
|
|
static inline void cpuidle_unregister_governor(struct cpuidle_governor *gov) { }
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_ARCH_HAS_CPU_RELAX
|
|
#define CPUIDLE_DRIVER_STATE_START 1
|
|
#else
|
|
#define CPUIDLE_DRIVER_STATE_START 0
|
|
#endif
|
|
|
|
#endif /* _LINUX_CPUIDLE_H */
|