[linux-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/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 struct workqueue_struct *pm_wq;

static inline bool queue_pm_work(struct work_struct *work)
{
	return queue_work(pm_wq, work);
}

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);

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_runtime_get_if_in_use(struct device *dev);
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 u64 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);
extern void pm_runtime_clean_up_links(struct device *dev);
extern void pm_runtime_get_suppliers(struct device *dev);
extern void pm_runtime_put_suppliers(struct device *dev);
extern void pm_runtime_new_link(struct device *dev);
extern void pm_runtime_drop_link(struct device *dev);

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 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)
{
	WRITE_ONCE(dev->power.last_busy, ktime_get_mono_fast_ns());
}

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

extern u64 pm_runtime_suspended_time(struct device *dev);

#else /* !CONFIG_PM */

static inline bool queue_pm_work(struct work_struct *work) { 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 int pm_runtime_force_suspend(struct device *dev) { return 0; }
static inline int pm_runtime_force_resume(struct device *dev) { return 0; }

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_get_if_in_use(struct device *dev)
{
	return -EINVAL;
}
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 void pm_suspend_ignore_children(struct device *dev, bool enable) {}
static inline void pm_runtime_get_noresume(struct device *dev) {}
static inline void pm_runtime_put_noidle(struct device *dev) {}
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 void pm_runtime_no_callbacks(struct device *dev) {}
static inline void pm_runtime_irq_safe(struct device *dev) {}
static inline bool pm_runtime_is_irq_safe(struct device *dev) { return false; }

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 u64 pm_runtime_autosuspend_expiration(
				struct device *dev) { return 0; }
static inline void pm_runtime_set_memalloc_noio(struct device *dev,
						bool enable){}
static inline void pm_runtime_clean_up_links(struct device *dev) {}
static inline void pm_runtime_get_suppliers(struct device *dev) {}
static inline void pm_runtime_put_suppliers(struct device *dev) {}
static inline void pm_runtime_new_link(struct device *dev) {}
static inline void pm_runtime_drop_link(struct device *dev) {}

#endif /* !CONFIG_PM */

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