[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
extern int pm_generic_runtime_suspend(struct device *dev);
extern int pm_generic_runtime_resume(struct device *dev);
extern int pm_runtime_force_suspend(struct device *dev);
extern int pm_runtime_force_resume(struct device *dev);
#else
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 int pm_runtime_force_suspend(struct device *dev) { return 0; }
static inline int pm_runtime_force_resume(struct device *dev) { return 0; }
#endif

#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 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_suspended_if_enabled(struct device *dev)
{
	return pm_runtime_status_suspended(dev) && dev->power.disable_depth == 1;
}

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

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