[deliverable/linux.git] / include / linux / cpuidle.h

/*
 * 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/module.h>
#include <linux/kobject.h>
#include <linux/completion.h>

#define CPUIDLE_STATE_MAX	8
#define CPUIDLE_NAME_LEN	16

struct cpuidle_device;


/****************************
 * CPUIDLE DEVICE INTERFACE *
 ****************************/

struct cpuidle_state {
	char		name[CPUIDLE_NAME_LEN];
	void		*driver_data;

	unsigned int	flags;
	unsigned int	exit_latency; /* in US */
	unsigned int	power_usage; /* in mW */
	unsigned int	target_residency; /* in US */

	unsigned int	usage;
	unsigned int	time; /* in US */

	int (*enter)	(struct cpuidle_device *dev,
			 struct cpuidle_state *state);
};

/* Idle State Flags */
#define CPUIDLE_FLAG_TIME_VALID	(0x01) /* is residency time measurable? */
#define CPUIDLE_FLAG_CHECK_BM	(0x02) /* BM activity will exit state */
#define CPUIDLE_FLAG_POLL	(0x10) /* no latency, no savings */
#define CPUIDLE_FLAG_SHALLOW	(0x20) /* low latency, minimal savings */
#define CPUIDLE_FLAG_BALANCED	(0x40) /* medium latency, moderate savings */
#define CPUIDLE_FLAG_DEEP	(0x80) /* high latency, large savings */

#define CPUIDLE_DRIVER_FLAGS_MASK (0xFFFF0000)

/**
 * cpuidle_get_statedata - retrieves private driver state data
 * @state: the state
 */
static inline void * cpuidle_get_statedata(struct cpuidle_state *state)
{
	return state->driver_data;
}

/**
 * cpuidle_set_statedata - stores private driver state data
 * @state: the state
 * @data: the private data
 */
static inline void
cpuidle_set_statedata(struct cpuidle_state *state, void *data)
{
	state->driver_data = data;
}

struct cpuidle_state_kobj {
	struct cpuidle_state *state;
	struct completion kobj_unregister;
	struct kobject kobj;
};

struct cpuidle_device {
	unsigned int		enabled:1;
	unsigned int		cpu;

	int			last_residency;
	int			state_count;
	struct cpuidle_state	states[CPUIDLE_STATE_MAX];
	struct cpuidle_state_kobj *kobjs[CPUIDLE_STATE_MAX];
	struct cpuidle_state	*last_state;

	struct list_head 	device_list;
	struct kobject		kobj;
	struct completion	kobj_unregister;
	void			*governor_data;
	struct cpuidle_state	*safe_state;
};

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 {
	char			name[CPUIDLE_NAME_LEN];
	struct module 		*owner;
};

#ifdef CONFIG_CPU_IDLE

extern int cpuidle_register_driver(struct cpuidle_driver *drv);
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 void cpuidle_pause_and_lock(void);
extern void cpuidle_resume_and_unlock(void);
extern int cpuidle_enable_device(struct cpuidle_device *dev);
extern void cpuidle_disable_device(struct cpuidle_device *dev);

#else

static inline int cpuidle_register_driver(struct cpuidle_driver *drv)
{return 0;}
static inline void cpuidle_unregister_driver(struct cpuidle_driver *drv) { }
static inline int cpuidle_register_device(struct cpuidle_device *dev)
{return 0;}
static inline void cpuidle_unregister_device(struct cpuidle_device *dev) { }

static inline void cpuidle_pause_and_lock(void) { }
static inline void cpuidle_resume_and_unlock(void) { }
static inline int cpuidle_enable_device(struct cpuidle_device *dev)
{return 0;}
static inline void cpuidle_disable_device(struct cpuidle_device *dev) { }

#endif

/******************************
 * CPUIDLE GOVERNOR INTERFACE *
 ******************************/

struct cpuidle_governor {
	char			name[CPUIDLE_NAME_LEN];
	struct list_head 	governor_list;
	unsigned int		rating;

	int  (*enable)		(struct cpuidle_device *dev);
	void (*disable)		(struct cpuidle_device *dev);

	int  (*select)		(struct cpuidle_device *dev);
	void (*reflect)		(struct cpuidle_device *dev);

	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 */
Commit	Line	Data
4f86d3a8 LB	1	/*
	2	* cpuidle.h - a generic framework for CPU idle power management
	3	*
	4	* (C) 2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
	5	* Shaohua Li <shaohua.li@intel.com>
	6	* Adam Belay <abelay@novell.com>
	7	*
	8	* This code is licenced under the GPL.
	9	*/
	10
	11	#ifndef _LINUX_CPUIDLE_H
	12	#define _LINUX_CPUIDLE_H
	13
	14	#include <linux/percpu.h>
	15	#include <linux/list.h>
	16	#include <linux/module.h>
	17	#include <linux/kobject.h>
	18	#include <linux/completion.h>
	19
	20	#define CPUIDLE_STATE_MAX 8
	21	#define CPUIDLE_NAME_LEN 16
	22
	23	struct cpuidle_device;
	24
	25
	26	/****************************
	27	* CPUIDLE DEVICE INTERFACE *
	28	****************************/
	29
	30	struct cpuidle_state {
	31	char name[CPUIDLE_NAME_LEN];
	32	void *driver_data;
	33
	34	unsigned int flags;
	35	unsigned int exit_latency; /* in US */
	36	unsigned int power_usage; /* in mW */
	37	unsigned int target_residency; /* in US */
	38
	39	unsigned int usage;
	40	unsigned int time; /* in US */
	41
	42	int (enter) (struct cpuidle_device dev,
	43	struct cpuidle_state *state);
	44	};
	45
	46	/* Idle State Flags */
	47	#define CPUIDLE_FLAG_TIME_VALID (0x01) /* is residency time measurable? */
	48	#define CPUIDLE_FLAG_CHECK_BM (0x02) /* BM activity will exit state */
9a0b8415	49	#define CPUIDLE_FLAG_POLL (0x10) /* no latency, no savings */
	50	#define CPUIDLE_FLAG_SHALLOW (0x20) /* low latency, minimal savings */
	51	#define CPUIDLE_FLAG_BALANCED (0x40) /* medium latency, moderate savings */
	52	#define CPUIDLE_FLAG_DEEP (0x80) /* high latency, large savings */
4f86d3a8 LB	53
	54	#define CPUIDLE_DRIVER_FLAGS_MASK (0xFFFF0000)
	55
	56	/**
	57	* cpuidle_get_statedata - retrieves private driver state data
	58	* @state: the state
	59	*/
	60	static inline void * cpuidle_get_statedata(struct cpuidle_state *state)
	61	{
	62	return state->driver_data;
	63	}
	64
	65	/**
	66	* cpuidle_set_statedata - stores private driver state data
	67	* @state: the state
	68	* @data: the private data
	69	*/
	70	static inline void
	71	cpuidle_set_statedata(struct cpuidle_state state, void data)
	72	{
	73	state->driver_data = data;
	74	}
	75
	76	struct cpuidle_state_kobj {
	77	struct cpuidle_state *state;
	78	struct completion kobj_unregister;
	79	struct kobject kobj;
	80	};
	81
	82	struct cpuidle_device {
b5556a67	83	unsigned int enabled:1;
4f86d3a8 LB	84	unsigned int cpu;
	85
	86	int last_residency;
	87	int state_count;
	88	struct cpuidle_state states[CPUIDLE_STATE_MAX];
	89	struct cpuidle_state_kobj *kobjs[CPUIDLE_STATE_MAX];
	90	struct cpuidle_state *last_state;
	91
	92	struct list_head device_list;
	93	struct kobject kobj;
	94	struct completion kobj_unregister;
	95	void *governor_data;
ddc081a1	96	struct cpuidle_state *safe_state;
4f86d3a8 LB	97	};
	98
	99	DECLARE_PER_CPU(struct cpuidle_device *, cpuidle_devices);
	100
	101	/**
	102	* cpuidle_get_last_residency - retrieves the last state's residency time
	103	* @dev: the target CPU
	104	*
	105	* NOTE: this value is invalid if CPUIDLE_FLAG_TIME_VALID isn't set
	106	*/
	107	static inline int cpuidle_get_last_residency(struct cpuidle_device *dev)
	108	{
	109	return dev->last_residency;
	110	}
	111
	112
	113	/****************************
	114	* CPUIDLE DRIVER INTERFACE *
	115	****************************/
	116
	117	struct cpuidle_driver {
	118	char name[CPUIDLE_NAME_LEN];
	119	struct module *owner;
	120	};
	121
	122	#ifdef CONFIG_CPU_IDLE
	123
	124	extern int cpuidle_register_driver(struct cpuidle_driver *drv);
	125	extern void cpuidle_unregister_driver(struct cpuidle_driver *drv);
	126	extern int cpuidle_register_device(struct cpuidle_device *dev);
	127	extern void cpuidle_unregister_device(struct cpuidle_device *dev);
	128
	129	extern void cpuidle_pause_and_lock(void);
	130	extern void cpuidle_resume_and_unlock(void);
	131	extern int cpuidle_enable_device(struct cpuidle_device *dev);
	132	extern void cpuidle_disable_device(struct cpuidle_device *dev);
	133
	134	#else
	135
	136	static inline int cpuidle_register_driver(struct cpuidle_driver *drv)
	137	{return 0;}
	138	static inline void cpuidle_unregister_driver(struct cpuidle_driver *drv) { }
	139	static inline int cpuidle_register_device(struct cpuidle_device *dev)
	140	{return 0;}
	141	static inline void cpuidle_unregister_device(struct cpuidle_device *dev) { }
	142
	143	static inline void cpuidle_pause_and_lock(void) { }
	144	static inline void cpuidle_resume_and_unlock(void) { }
	145	static inline int cpuidle_enable_device(struct cpuidle_device *dev)
	146	{return 0;}
	147	static inline void cpuidle_disable_device(struct cpuidle_device *dev) { }
	148
	149	#endif
	150
	151	/******************************
	152	* CPUIDLE GOVERNOR INTERFACE *
	153	******************************/
	154
	155	struct cpuidle_governor {
	156	char name[CPUIDLE_NAME_LEN];
	157	struct list_head governor_list;
	158	unsigned int rating;
	159
	160	int (enable) (struct cpuidle_device dev);
161	void (disable) (struct cpuidle_device dev);
162
163	int (select) (struct cpuidle_device dev);
164	void (reflect) (struct cpuidle_device dev);
165
166	struct module *owner;
167	};
168
169	#ifdef CONFIG_CPU_IDLE
170
171	extern int cpuidle_register_governor(struct cpuidle_governor *gov);
172	extern void cpuidle_unregister_governor(struct cpuidle_governor *gov);
173
174	#else
175
176	static inline int cpuidle_register_governor(struct cpuidle_governor *gov)
177	{return 0;}
178	static inline void cpuidle_unregister_governor(struct cpuidle_governor *gov) { }
179
180	#endif
181
9a0b8415	182	#ifdef CONFIG_ARCH_HAS_CPU_RELAX
	183	#define CPUIDLE_DRIVER_STATE_START 1
	184	#else
	185	#define CPUIDLE_DRIVER_STATE_START 0
	186	#endif
	187
4f86d3a8	188	#endif /* _LINUX_CPUIDLE_H */