[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_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);
extern void pm_runtime_update_max_time_suspended(struct device *dev,
						 s64 delta_ns);
extern void pm_runtime_set_memalloc_noio(struct device *dev, bool enable);

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

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_active(struct device *dev)
{
	return dev->power.runtime_status == RPM_ACTIVE
		|| 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_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_active(struct device *dev) { return true; }
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_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; }
static inline void pm_runtime_set_memalloc_noio(struct device *dev,
						bool enable){}

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