[deliverable/linux.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/notifier.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_irq_safe(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
		&& !dev->power.disable_depth;
}

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

static inline bool pm_runtime_enabled(struct device *dev)
{
	return !dev->power.disable_depth;
}

static inline bool pm_runtime_callbacks_present(struct device *dev)
{
	return !dev->power.no_callbacks;
}

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 bool pm_runtime_status_suspended(struct device *dev) { return false; }
static inline bool pm_runtime_enabled(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_irq_safe(struct device *dev) {}

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