[linux-2.6-block.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_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);
}

struct pm_clk_notifier_block {
	struct notifier_block nb;
	struct dev_pm_domain *pm_domain;
	char *con_ids[];
};

#ifdef CONFIG_PM_CLK
extern int pm_clk_init(struct device *dev);
extern void pm_clk_destroy(struct device *dev);
extern int pm_clk_add(struct device *dev, const char *con_id);
extern void pm_clk_remove(struct device *dev, const char *con_id);
extern int pm_clk_suspend(struct device *dev);
extern int pm_clk_resume(struct device *dev);
#else
static inline int pm_clk_init(struct device *dev)
{
	return -EINVAL;
}
static inline void pm_clk_destroy(struct device *dev)
{
}
static inline int pm_clk_add(struct device *dev, const char *con_id)
{
	return -EINVAL;
}
static inline void pm_clk_remove(struct device *dev, const char *con_id)
{
}
#define pm_clk_suspend	NULL
#define pm_clk_resume	NULL
#endif

#ifdef CONFIG_HAVE_CLK
extern void pm_clk_add_notifier(struct bus_type *bus,
					struct pm_clk_notifier_block *clknb);
#else
static inline void pm_clk_add_notifier(struct bus_type *bus,
					struct pm_clk_notifier_block *clknb)
{
}
#endif

#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);
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);
5e928f77 RW	47
	48	static inline bool pm_children_suspended(struct device *dev)
	49	{
	50	return dev->power.ignore_children
	51	\|\| !atomic_read(&dev->power.child_count);
	52	}
	53
	54	static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
	55	{
	56	dev->power.ignore_children = enable;
	57	}
	58
	59	static inline void pm_runtime_get_noresume(struct device *dev)
	60	{
	61	atomic_inc(&dev->power.usage_count);
	62	}
	63
	64	static inline void pm_runtime_put_noidle(struct device *dev)
	65	{
	66	atomic_add_unless(&dev->power.usage_count, -1, 0);
	67	}
	68
7a1a8eb5 RW	69	static inline bool device_run_wake(struct device *dev)
	70	{
	71	return dev->power.run_wake;
	72	}
	73
	74	static inline void device_set_run_wake(struct device *dev, bool enable)
	75	{
	76	dev->power.run_wake = enable;
	77	}
	78
d690b2cd RW	79	static inline bool pm_runtime_suspended(struct device *dev)
d690b2cd RW	80	{
f08f5a0a RW	81	return dev->power.runtime_status == RPM_SUSPENDED
f08f5a0a RW	82	&& !dev->power.disable_depth;
d690b2cd RW	83	}
d690b2cd RW	84
f3393b62 KH	85	static inline bool pm_runtime_status_suspended(struct device *dev)
	86	{
	87	return dev->power.runtime_status == RPM_SUSPENDED;
	88	}
	89
4b31db8a RW	90	static inline bool pm_runtime_enabled(struct device *dev)
	91	{
	92	return !dev->power.disable_depth;
	93	}
	94
cb8f51bd RW	95	static inline bool pm_runtime_callbacks_present(struct device *dev)
	96	{
	97	return !dev->power.no_callbacks;
	98	}
	99
15bcb91d AS	100	static inline void pm_runtime_mark_last_busy(struct device *dev)
	101	{
	102	ACCESS_ONCE(dev->power.last_busy) = jiffies;
	103	}
	104
5e928f77 RW	105	#else /* !CONFIG_PM_RUNTIME */
5e928f77 RW	106
140a6c94 AS	107	static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
	108	{
	109	return -ENOSYS;
	110	}
	111	static inline int __pm_runtime_suspend(struct device *dev, int rpmflags)
	112	{
	113	return -ENOSYS;
	114	}
	115	static inline int __pm_runtime_resume(struct device *dev, int rpmflags)
	116	{
	117	return 1;
	118	}
5e928f77 RW	119	static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
	120	{
	121	return -ENOSYS;
	122	}
5e928f77 RW	123	static inline int __pm_runtime_set_status(struct device *dev,
	124	unsigned int status) { return 0; }
	125	static inline int pm_runtime_barrier(struct device *dev) { return 0; }
	126	static inline void pm_runtime_enable(struct device *dev) {}
	127	static inline void __pm_runtime_disable(struct device *dev, bool c) {}
53823639 RW	128	static inline void pm_runtime_allow(struct device *dev) {}
53823639 RW	129	static inline void pm_runtime_forbid(struct device *dev) {}
5e928f77 RW	130
	131	static inline bool pm_children_suspended(struct device *dev) { return false; }
	132	static inline void pm_suspend_ignore_children(struct device *dev, bool en) {}
	133	static inline void pm_runtime_get_noresume(struct device *dev) {}
	134	static inline void pm_runtime_put_noidle(struct device *dev) {}
7a1a8eb5 RW	135	static inline bool device_run_wake(struct device *dev) { return false; }
7a1a8eb5 RW	136	static inline void device_set_run_wake(struct device *dev, bool enable) {}
d690b2cd	137	static inline bool pm_runtime_suspended(struct device *dev) { return false; }
f3393b62	138	static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }
4b31db8a	139	static inline bool pm_runtime_enabled(struct device *dev) { return false; }
5e928f77	140
2f60ba70 RW	141	static inline int pm_generic_runtime_idle(struct device *dev) { return 0; }
	142	static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
	143	static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
7490e442	144	static inline void pm_runtime_no_callbacks(struct device *dev) {}
c7b61de5	145	static inline void pm_runtime_irq_safe(struct device *dev) {}
2f60ba70	146
cb8f51bd	147	static inline bool pm_runtime_callbacks_present(struct device *dev) { return false; }
15bcb91d AS	148	static inline void pm_runtime_mark_last_busy(struct device *dev) {}
	149	static inline void __pm_runtime_use_autosuspend(struct device *dev,
	150	bool use) {}
	151	static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
	152	int delay) {}
	153	static inline unsigned long pm_runtime_autosuspend_expiration(
	154	struct device *dev) { return 0; }
	155
5e928f77 RW	156	#endif /* !CONFIG_PM_RUNTIME */
5e928f77 RW	157
140a6c94 AS	158	static inline int pm_runtime_idle(struct device *dev)
	159	{
	160	return __pm_runtime_idle(dev, 0);
	161	}
	162
	163	static inline int pm_runtime_suspend(struct device *dev)
	164	{
	165	return __pm_runtime_suspend(dev, 0);
	166	}
	167
15bcb91d AS	168	static inline int pm_runtime_autosuspend(struct device *dev)
	169	{
	170	return __pm_runtime_suspend(dev, RPM_AUTO);
	171	}
	172
140a6c94 AS	173	static inline int pm_runtime_resume(struct device *dev)
	174	{
	175	return __pm_runtime_resume(dev, 0);
	176	}
	177
	178	static inline int pm_request_idle(struct device *dev)
	179	{
	180	return __pm_runtime_idle(dev, RPM_ASYNC);
	181	}
	182
	183	static inline int pm_request_resume(struct device *dev)
	184	{
	185	return __pm_runtime_resume(dev, RPM_ASYNC);
	186	}
	187
5fc62aad ML	188	static inline int pm_request_autosuspend(struct device *dev)
	189	{
	190	return __pm_runtime_suspend(dev, RPM_ASYNC \| RPM_AUTO);
	191	}
	192
5e928f77 RW	193	static inline int pm_runtime_get(struct device *dev)
5e928f77 RW	194	{
140a6c94	195	return __pm_runtime_resume(dev, RPM_GET_PUT \| RPM_ASYNC);
5e928f77 RW	196	}
	197
	198	static inline int pm_runtime_get_sync(struct device *dev)
	199	{
140a6c94	200	return __pm_runtime_resume(dev, RPM_GET_PUT);
5e928f77 RW	201	}
	202
	203	static inline int pm_runtime_put(struct device *dev)
	204	{
140a6c94	205	return __pm_runtime_idle(dev, RPM_GET_PUT \| RPM_ASYNC);
5e928f77 RW	206	}
5e928f77 RW	207
15bcb91d AS	208	static inline int pm_runtime_put_autosuspend(struct device *dev)
	209	{
	210	return __pm_runtime_suspend(dev,
	211	RPM_GET_PUT \| RPM_ASYNC \| RPM_AUTO);
	212	}
	213
5e928f77 RW	214	static inline int pm_runtime_put_sync(struct device *dev)
5e928f77 RW	215	{
140a6c94	216	return __pm_runtime_idle(dev, RPM_GET_PUT);
5e928f77 RW	217	}
5e928f77 RW	218
c7b61de5 AS	219	static inline int pm_runtime_put_sync_suspend(struct device *dev)
	220	{
	221	return __pm_runtime_suspend(dev, RPM_GET_PUT);
	222	}
	223
15bcb91d AS	224	static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
	225	{
	226	return __pm_runtime_suspend(dev, RPM_GET_PUT \| RPM_AUTO);
	227	}
	228
5e928f77 RW	229	static inline int pm_runtime_set_active(struct device *dev)
	230	{
	231	return __pm_runtime_set_status(dev, RPM_ACTIVE);
	232	}
	233
	234	static inline void pm_runtime_set_suspended(struct device *dev)
	235	{
	236	__pm_runtime_set_status(dev, RPM_SUSPENDED);
	237	}
	238
	239	static inline void pm_runtime_disable(struct device *dev)
	240	{
	241	__pm_runtime_disable(dev, true);
	242	}
	243
15bcb91d AS	244	static inline void pm_runtime_use_autosuspend(struct device *dev)
	245	{
	246	__pm_runtime_use_autosuspend(dev, true);
	247	}
	248
	249	static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
	250	{
	251	__pm_runtime_use_autosuspend(dev, false);
	252	}
	253
85eb8c8d RW	254	struct pm_clk_notifier_block {
85eb8c8d RW	255	struct notifier_block nb;
564b905a	256	struct dev_pm_domain *pm_domain;
85eb8c8d RW	257	char *con_ids[];
	258	};
	259
b7b95920	260	#ifdef CONFIG_PM_CLK
3d5c3036 RW	261	extern int pm_clk_init(struct device *dev);
	262	extern void pm_clk_destroy(struct device *dev);
	263	extern int pm_clk_add(struct device dev, const char con_id);
	264	extern void pm_clk_remove(struct device dev, const char con_id);
	265	extern int pm_clk_suspend(struct device *dev);
	266	extern int pm_clk_resume(struct device *dev);
85eb8c8d	267	#else
3d5c3036	268	static inline int pm_clk_init(struct device *dev)
85eb8c8d RW	269	{
	270	return -EINVAL;
	271	}
3d5c3036	272	static inline void pm_clk_destroy(struct device *dev)
85eb8c8d RW	273	{
85eb8c8d RW	274	}
3d5c3036	275	static inline int pm_clk_add(struct device dev, const char con_id)
85eb8c8d RW	276	{
	277	return -EINVAL;
	278	}
3d5c3036	279	static inline void pm_clk_remove(struct device dev, const char con_id)
85eb8c8d RW	280	{
85eb8c8d RW	281	}
3d5c3036 RW	282	#define pm_clk_suspend NULL
3d5c3036 RW	283	#define pm_clk_resume NULL
85eb8c8d RW	284	#endif
	285
	286	#ifdef CONFIG_HAVE_CLK
3d5c3036	287	extern void pm_clk_add_notifier(struct bus_type *bus,
85eb8c8d RW	288	struct pm_clk_notifier_block *clknb);
85eb8c8d RW	289	#else
3d5c3036	290	static inline void pm_clk_add_notifier(struct bus_type *bus,
85eb8c8d RW	291	struct pm_clk_notifier_block *clknb)
	292	{
	293	}
	294	#endif
	295
5e928f77	296	#endif