[mirror_ubuntu-bionic-kernel.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);
#else
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; }
#endif

#ifdef CONFIG_PM_RUNTIME

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