[net-next-2.6.git] / include / linux / pm_runtime.h

/*
 * pm_runtime.h - Device run-time power management helper functions.
 *
 * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>
 *
 * This file is released under the GPLv2.
 */

#ifndef _LINUX_PM_RUNTIME_H
#define _LINUX_PM_RUNTIME_H

#include <linux/device.h>
#include <linux/pm.h>

#include <linux/jiffies.h>

/* Runtime PM flag argument bits */
#define RPM_ASYNC		0x01	/* Request is asynchronous */
#define RPM_NOWAIT		0x02	/* Don't wait for concurrent
					    state change */
#define RPM_GET_PUT		0x04	/* Increment/decrement the
					    usage_count */
#define RPM_AUTO		0x08	/* Use autosuspend_delay */

#ifdef CONFIG_PM_RUNTIME

extern struct workqueue_struct *pm_wq;

extern int __pm_runtime_idle(struct device *dev, int rpmflags);
extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
extern int __pm_runtime_resume(struct device *dev, int rpmflags);
extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
extern int pm_runtime_barrier(struct device *dev);
extern void pm_runtime_enable(struct device *dev);
extern void __pm_runtime_disable(struct device *dev, bool check_resume);
extern void pm_runtime_allow(struct device *dev);
extern void pm_runtime_forbid(struct device *dev);
extern int pm_generic_runtime_idle(struct device *dev);
extern int pm_generic_runtime_suspend(struct device *dev);
extern int pm_generic_runtime_resume(struct device *dev);
extern void pm_runtime_no_callbacks(struct device *dev);
extern void __pm_runtime_use_autosuspend(struct device *dev, bool use);
extern void pm_runtime_set_autosuspend_delay(struct device *dev, int delay);
extern unsigned long pm_runtime_autosuspend_expiration(struct device *dev);

static inline bool pm_children_suspended(struct device *dev)
{
	return dev->power.ignore_children
		|| !atomic_read(&dev->power.child_count);
}

static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
{
	dev->power.ignore_children = enable;
}

static inline void pm_runtime_get_noresume(struct device *dev)
{
	atomic_inc(&dev->power.usage_count);
}

static inline void pm_runtime_put_noidle(struct device *dev)
{
	atomic_add_unless(&dev->power.usage_count, -1, 0);
}

static inline bool device_run_wake(struct device *dev)
{
	return dev->power.run_wake;
}

static inline void device_set_run_wake(struct device *dev, bool enable)
{
	dev->power.run_wake = enable;
}

static inline bool pm_runtime_suspended(struct device *dev)
{
	return dev->power.runtime_status == RPM_SUSPENDED;
}

static inline void pm_runtime_mark_last_busy(struct device *dev)
{
	ACCESS_ONCE(dev->power.last_busy) = jiffies;
}

#else /* !CONFIG_PM_RUNTIME */

static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
{
	return -ENOSYS;
}
static inline int __pm_runtime_suspend(struct device *dev, int rpmflags)
{
	return -ENOSYS;
}
static inline int __pm_runtime_resume(struct device *dev, int rpmflags)
{
	return 1;
}
static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
{
	return -ENOSYS;
}
static inline int __pm_runtime_set_status(struct device *dev,
					    unsigned int status) { return 0; }
static inline int pm_runtime_barrier(struct device *dev) { return 0; }
static inline void pm_runtime_enable(struct device *dev) {}
static inline void __pm_runtime_disable(struct device *dev, bool c) {}
static inline void pm_runtime_allow(struct device *dev) {}
static inline void pm_runtime_forbid(struct device *dev) {}

static inline bool pm_children_suspended(struct device *dev) { return false; }
static inline void pm_suspend_ignore_children(struct device *dev, bool en) {}
static inline void pm_runtime_get_noresume(struct device *dev) {}
static inline void pm_runtime_put_noidle(struct device *dev) {}
static inline bool device_run_wake(struct device *dev) { return false; }
static inline void device_set_run_wake(struct device *dev, bool enable) {}
static inline bool pm_runtime_suspended(struct device *dev) { return false; }

static inline int pm_generic_runtime_idle(struct device *dev) { return 0; }
static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
static inline void pm_runtime_no_callbacks(struct device *dev) {}

static inline void pm_runtime_mark_last_busy(struct device *dev) {}
static inline void __pm_runtime_use_autosuspend(struct device *dev,
						bool use) {}
static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
						int delay) {}
static inline unsigned long pm_runtime_autosuspend_expiration(
				struct device *dev) { return 0; }

#endif /* !CONFIG_PM_RUNTIME */

static inline int pm_runtime_idle(struct device *dev)
{
	return __pm_runtime_idle(dev, 0);
}

static inline int pm_runtime_suspend(struct device *dev)
{
	return __pm_runtime_suspend(dev, 0);
}

static inline int pm_runtime_autosuspend(struct device *dev)
{
	return __pm_runtime_suspend(dev, RPM_AUTO);
}

static inline int pm_runtime_resume(struct device *dev)
{
	return __pm_runtime_resume(dev, 0);
}

static inline int pm_request_idle(struct device *dev)
{
	return __pm_runtime_idle(dev, RPM_ASYNC);
}

static inline int pm_request_resume(struct device *dev)
{
	return __pm_runtime_resume(dev, RPM_ASYNC);
}

static inline int pm_request_autosuspend(struct device *dev)
{
	return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
}

static inline int pm_runtime_get(struct device *dev)
{
	return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);
}

static inline int pm_runtime_get_sync(struct device *dev)
{
	return __pm_runtime_resume(dev, RPM_GET_PUT);
}

static inline int pm_runtime_put(struct device *dev)
{
	return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
}

static inline int pm_runtime_put_autosuspend(struct device *dev)
{
	return __pm_runtime_suspend(dev,
	    RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
}

static inline int pm_runtime_put_sync(struct device *dev)
{
	return __pm_runtime_idle(dev, RPM_GET_PUT);
}

static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
{
	return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
}

static inline int pm_runtime_set_active(struct device *dev)
{
	return __pm_runtime_set_status(dev, RPM_ACTIVE);
}

static inline void pm_runtime_set_suspended(struct device *dev)
{
	__pm_runtime_set_status(dev, RPM_SUSPENDED);
}

static inline void pm_runtime_disable(struct device *dev)
{
	__pm_runtime_disable(dev, true);
}

static inline void pm_runtime_use_autosuspend(struct device *dev)
{
	__pm_runtime_use_autosuspend(dev, true);
}

static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
{
	__pm_runtime_use_autosuspend(dev, false);
}

#endif
Commit	Line	Data
5e928f77 RW	1	/*
	2	* pm_runtime.h - Device run-time power management helper functions.
	3	*
	4	* Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>
	5	*
	6	* This file is released under the GPLv2.
	7	*/
	8
	9	#ifndef _LINUX_PM_RUNTIME_H
	10	#define _LINUX_PM_RUNTIME_H
	11
	12	#include <linux/device.h>
	13	#include <linux/pm.h>
	14
15bcb91d AS	15	#include <linux/jiffies.h>
15bcb91d AS	16
3f9af051 AS	17	/* Runtime PM flag argument bits */
	18	#define RPM_ASYNC 0x01 /* Request is asynchronous */
	19	#define RPM_NOWAIT 0x02 /* Don't wait for concurrent
	20	state change */
140a6c94 AS	21	#define RPM_GET_PUT 0x04 /* Increment/decrement the
140a6c94 AS	22	usage_count */
15bcb91d	23	#define RPM_AUTO 0x08 /* Use autosuspend_delay */
3f9af051	24
5e928f77 RW	25	#ifdef CONFIG_PM_RUNTIME
	26
	27	extern struct workqueue_struct *pm_wq;
	28
140a6c94 AS	29	extern int __pm_runtime_idle(struct device *dev, int rpmflags);
	30	extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
	31	extern int __pm_runtime_resume(struct device *dev, int rpmflags);
5e928f77	32	extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
5e928f77 RW	33	extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
	34	extern int pm_runtime_barrier(struct device *dev);
	35	extern void pm_runtime_enable(struct device *dev);
	36	extern void __pm_runtime_disable(struct device *dev, bool check_resume);
53823639 RW	37	extern void pm_runtime_allow(struct device *dev);
53823639 RW	38	extern void pm_runtime_forbid(struct device *dev);
2f60ba70 RW	39	extern int pm_generic_runtime_idle(struct device *dev);
	40	extern int pm_generic_runtime_suspend(struct device *dev);
	41	extern int pm_generic_runtime_resume(struct device *dev);
7490e442	42	extern void pm_runtime_no_callbacks(struct device *dev);
15bcb91d AS	43	extern void __pm_runtime_use_autosuspend(struct device *dev, bool use);
	44	extern void pm_runtime_set_autosuspend_delay(struct device *dev, int delay);
	45	extern unsigned long pm_runtime_autosuspend_expiration(struct device *dev);
5e928f77 RW	46
	47	static inline bool pm_children_suspended(struct device *dev)
	48	{
	49	return dev->power.ignore_children
	50	\|\| !atomic_read(&dev->power.child_count);
	51	}
	52
	53	static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
	54	{
	55	dev->power.ignore_children = enable;
	56	}
	57
	58	static inline void pm_runtime_get_noresume(struct device *dev)
	59	{
	60	atomic_inc(&dev->power.usage_count);
	61	}
	62
	63	static inline void pm_runtime_put_noidle(struct device *dev)
	64	{
	65	atomic_add_unless(&dev->power.usage_count, -1, 0);
	66	}
	67
7a1a8eb5 RW	68	static inline bool device_run_wake(struct device *dev)
	69	{
	70	return dev->power.run_wake;
	71	}
	72
	73	static inline void device_set_run_wake(struct device *dev, bool enable)
	74	{
	75	dev->power.run_wake = enable;
	76	}
	77
d690b2cd RW	78	static inline bool pm_runtime_suspended(struct device *dev)
	79	{
	80	return dev->power.runtime_status == RPM_SUSPENDED;
	81	}
	82
15bcb91d AS	83	static inline void pm_runtime_mark_last_busy(struct device *dev)
	84	{
	85	ACCESS_ONCE(dev->power.last_busy) = jiffies;
	86	}
	87
5e928f77 RW	88	#else /* !CONFIG_PM_RUNTIME */
5e928f77 RW	89
140a6c94 AS	90	static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
	91	{
	92	return -ENOSYS;
	93	}
	94	static inline int __pm_runtime_suspend(struct device *dev, int rpmflags)
	95	{
	96	return -ENOSYS;
	97	}
	98	static inline int __pm_runtime_resume(struct device *dev, int rpmflags)
	99	{
	100	return 1;
	101	}
5e928f77 RW	102	static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
	103	{
	104	return -ENOSYS;
	105	}
5e928f77 RW	106	static inline int __pm_runtime_set_status(struct device *dev,
	107	unsigned int status) { return 0; }
	108	static inline int pm_runtime_barrier(struct device *dev) { return 0; }
	109	static inline void pm_runtime_enable(struct device *dev) {}
	110	static inline void __pm_runtime_disable(struct device *dev, bool c) {}
53823639 RW	111	static inline void pm_runtime_allow(struct device *dev) {}
53823639 RW	112	static inline void pm_runtime_forbid(struct device *dev) {}
5e928f77 RW	113
	114	static inline bool pm_children_suspended(struct device *dev) { return false; }
	115	static inline void pm_suspend_ignore_children(struct device *dev, bool en) {}
	116	static inline void pm_runtime_get_noresume(struct device *dev) {}
	117	static inline void pm_runtime_put_noidle(struct device *dev) {}
7a1a8eb5 RW	118	static inline bool device_run_wake(struct device *dev) { return false; }
7a1a8eb5 RW	119	static inline void device_set_run_wake(struct device *dev, bool enable) {}
d690b2cd	120	static inline bool pm_runtime_suspended(struct device *dev) { return false; }
5e928f77	121
2f60ba70 RW	122	static inline int pm_generic_runtime_idle(struct device *dev) { return 0; }
	123	static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
	124	static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
7490e442	125	static inline void pm_runtime_no_callbacks(struct device *dev) {}
2f60ba70	126
15bcb91d AS	127	static inline void pm_runtime_mark_last_busy(struct device *dev) {}
	128	static inline void __pm_runtime_use_autosuspend(struct device *dev,
	129	bool use) {}
	130	static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
	131	int delay) {}
	132	static inline unsigned long pm_runtime_autosuspend_expiration(
	133	struct device *dev) { return 0; }
	134
5e928f77 RW	135	#endif /* !CONFIG_PM_RUNTIME */
5e928f77 RW	136
140a6c94 AS	137	static inline int pm_runtime_idle(struct device *dev)
	138	{
	139	return __pm_runtime_idle(dev, 0);
	140	}
	141
	142	static inline int pm_runtime_suspend(struct device *dev)
	143	{
	144	return __pm_runtime_suspend(dev, 0);
	145	}
	146
15bcb91d AS	147	static inline int pm_runtime_autosuspend(struct device *dev)
	148	{
	149	return __pm_runtime_suspend(dev, RPM_AUTO);
	150	}
	151
140a6c94 AS	152	static inline int pm_runtime_resume(struct device *dev)
	153	{
	154	return __pm_runtime_resume(dev, 0);
	155	}
	156
	157	static inline int pm_request_idle(struct device *dev)
	158	{
	159	return __pm_runtime_idle(dev, RPM_ASYNC);
	160	}
	161
	162	static inline int pm_request_resume(struct device *dev)
	163	{
	164	return __pm_runtime_resume(dev, RPM_ASYNC);
	165	}
	166
5fc62aad ML	167	static inline int pm_request_autosuspend(struct device *dev)
	168	{
	169	return __pm_runtime_suspend(dev, RPM_ASYNC \| RPM_AUTO);
	170	}
	171
5e928f77 RW	172	static inline int pm_runtime_get(struct device *dev)
5e928f77 RW	173	{
140a6c94	174	return __pm_runtime_resume(dev, RPM_GET_PUT \| RPM_ASYNC);
5e928f77 RW	175	}
	176
	177	static inline int pm_runtime_get_sync(struct device *dev)
	178	{
140a6c94	179	return __pm_runtime_resume(dev, RPM_GET_PUT);
5e928f77 RW	180	}
	181
	182	static inline int pm_runtime_put(struct device *dev)
	183	{
140a6c94	184	return __pm_runtime_idle(dev, RPM_GET_PUT \| RPM_ASYNC);
5e928f77 RW	185	}
5e928f77 RW	186
15bcb91d AS	187	static inline int pm_runtime_put_autosuspend(struct device *dev)
	188	{
	189	return __pm_runtime_suspend(dev,
	190	RPM_GET_PUT \| RPM_ASYNC \| RPM_AUTO);
	191	}
	192
5e928f77 RW	193	static inline int pm_runtime_put_sync(struct device *dev)
5e928f77 RW	194	{
140a6c94	195	return __pm_runtime_idle(dev, RPM_GET_PUT);
5e928f77 RW	196	}
5e928f77 RW	197
15bcb91d AS	198	static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
	199	{
	200	return __pm_runtime_suspend(dev, RPM_GET_PUT \| RPM_AUTO);
	201	}
	202
5e928f77 RW	203	static inline int pm_runtime_set_active(struct device *dev)
	204	{
	205	return __pm_runtime_set_status(dev, RPM_ACTIVE);
	206	}
	207
	208	static inline void pm_runtime_set_suspended(struct device *dev)
	209	{
	210	__pm_runtime_set_status(dev, RPM_SUSPENDED);
	211	}
	212
	213	static inline void pm_runtime_disable(struct device *dev)
	214	{
	215	__pm_runtime_disable(dev, true);
	216	}
	217
15bcb91d AS	218	static inline void pm_runtime_use_autosuspend(struct device *dev)
	219	{
	220	__pm_runtime_use_autosuspend(dev, true);
	221	}
	222
	223	static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
	224	{
	225	__pm_runtime_use_autosuspend(dev, false);
	226	}
	227
5e928f77	228	#endif