[mirror_ubuntu-jammy-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/pm.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 */

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

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

#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 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; }

#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_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_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_sync(struct device *dev)
{
	return __pm_runtime_idle(dev, RPM_GET_PUT);
}

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

#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
3f9af051 AS	15	/* Runtime PM flag argument bits */
	16	#define RPM_ASYNC 0x01 /* Request is asynchronous */
	17	#define RPM_NOWAIT 0x02 /* Don't wait for concurrent
	18	state change */
140a6c94 AS	19	#define RPM_GET_PUT 0x04 /* Increment/decrement the
140a6c94 AS	20	usage_count */
3f9af051	21
5e928f77 RW	22	#ifdef CONFIG_PM_RUNTIME
	23
	24	extern struct workqueue_struct *pm_wq;
	25
140a6c94 AS	26	extern int __pm_runtime_idle(struct device *dev, int rpmflags);
	27	extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
	28	extern int __pm_runtime_resume(struct device *dev, int rpmflags);
5e928f77	29	extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
5e928f77 RW	30	extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
	31	extern int pm_runtime_barrier(struct device *dev);
	32	extern void pm_runtime_enable(struct device *dev);
	33	extern void __pm_runtime_disable(struct device *dev, bool check_resume);
53823639 RW	34	extern void pm_runtime_allow(struct device *dev);
53823639 RW	35	extern void pm_runtime_forbid(struct device *dev);
2f60ba70 RW	36	extern int pm_generic_runtime_idle(struct device *dev);
	37	extern int pm_generic_runtime_suspend(struct device *dev);
	38	extern int pm_generic_runtime_resume(struct device *dev);
5e928f77 RW	39
	40	static inline bool pm_children_suspended(struct device *dev)
	41	{
	42	return dev->power.ignore_children
	43	\|\| !atomic_read(&dev->power.child_count);
	44	}
	45
	46	static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
	47	{
	48	dev->power.ignore_children = enable;
	49	}
	50
	51	static inline void pm_runtime_get_noresume(struct device *dev)
	52	{
	53	atomic_inc(&dev->power.usage_count);
	54	}
	55
	56	static inline void pm_runtime_put_noidle(struct device *dev)
	57	{
	58	atomic_add_unless(&dev->power.usage_count, -1, 0);
	59	}
	60
7a1a8eb5 RW	61	static inline bool device_run_wake(struct device *dev)
	62	{
	63	return dev->power.run_wake;
	64	}
	65
	66	static inline void device_set_run_wake(struct device *dev, bool enable)
	67	{
	68	dev->power.run_wake = enable;
	69	}
	70
d690b2cd RW	71	static inline bool pm_runtime_suspended(struct device *dev)
	72	{
	73	return dev->power.runtime_status == RPM_SUSPENDED;
	74	}
	75
5e928f77 RW	76	#else /* !CONFIG_PM_RUNTIME */
5e928f77 RW	77
140a6c94 AS	78	static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
	79	{
	80	return -ENOSYS;
	81	}
	82	static inline int __pm_runtime_suspend(struct device *dev, int rpmflags)
	83	{
	84	return -ENOSYS;
	85	}
	86	static inline int __pm_runtime_resume(struct device *dev, int rpmflags)
	87	{
	88	return 1;
	89	}
5e928f77 RW	90	static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
	91	{
	92	return -ENOSYS;
	93	}
5e928f77 RW	94	static inline int __pm_runtime_set_status(struct device *dev,
	95	unsigned int status) { return 0; }
	96	static inline int pm_runtime_barrier(struct device *dev) { return 0; }
	97	static inline void pm_runtime_enable(struct device *dev) {}
	98	static inline void __pm_runtime_disable(struct device *dev, bool c) {}
53823639 RW	99	static inline void pm_runtime_allow(struct device *dev) {}
53823639 RW	100	static inline void pm_runtime_forbid(struct device *dev) {}
5e928f77 RW	101
	102	static inline bool pm_children_suspended(struct device *dev) { return false; }
	103	static inline void pm_suspend_ignore_children(struct device *dev, bool en) {}
	104	static inline void pm_runtime_get_noresume(struct device *dev) {}
	105	static inline void pm_runtime_put_noidle(struct device *dev) {}
7a1a8eb5 RW	106	static inline bool device_run_wake(struct device *dev) { return false; }
7a1a8eb5 RW	107	static inline void device_set_run_wake(struct device *dev, bool enable) {}
d690b2cd	108	static inline bool pm_runtime_suspended(struct device *dev) { return false; }
5e928f77	109
2f60ba70 RW	110	static inline int pm_generic_runtime_idle(struct device *dev) { return 0; }
	111	static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
	112	static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
	113
5e928f77 RW	114	#endif /* !CONFIG_PM_RUNTIME */
5e928f77 RW	115
140a6c94 AS	116	static inline int pm_runtime_idle(struct device *dev)
	117	{
	118	return __pm_runtime_idle(dev, 0);
	119	}
	120
	121	static inline int pm_runtime_suspend(struct device *dev)
	122	{
	123	return __pm_runtime_suspend(dev, 0);
	124	}
	125
	126	static inline int pm_runtime_resume(struct device *dev)
	127	{
	128	return __pm_runtime_resume(dev, 0);
	129	}
	130
	131	static inline int pm_request_idle(struct device *dev)
	132	{
	133	return __pm_runtime_idle(dev, RPM_ASYNC);
	134	}
	135
	136	static inline int pm_request_resume(struct device *dev)
	137	{
	138	return __pm_runtime_resume(dev, RPM_ASYNC);
	139	}
	140
5e928f77 RW	141	static inline int pm_runtime_get(struct device *dev)
5e928f77 RW	142	{
140a6c94	143	return __pm_runtime_resume(dev, RPM_GET_PUT \| RPM_ASYNC);
5e928f77 RW	144	}
	145
	146	static inline int pm_runtime_get_sync(struct device *dev)
	147	{
140a6c94	148	return __pm_runtime_resume(dev, RPM_GET_PUT);
5e928f77 RW	149	}
	150
	151	static inline int pm_runtime_put(struct device *dev)
	152	{
140a6c94	153	return __pm_runtime_idle(dev, RPM_GET_PUT \| RPM_ASYNC);
5e928f77 RW	154	}
	155
	156	static inline int pm_runtime_put_sync(struct device *dev)
	157	{
140a6c94	158	return __pm_runtime_idle(dev, RPM_GET_PUT);
5e928f77 RW	159	}
	160
	161	static inline int pm_runtime_set_active(struct device *dev)
	162	{
	163	return __pm_runtime_set_status(dev, RPM_ACTIVE);
	164	}
	165
	166	static inline void pm_runtime_set_suspended(struct device *dev)
	167	{
	168	__pm_runtime_set_status(dev, RPM_SUSPENDED);
	169	}
	170
	171	static inline void pm_runtime_disable(struct device *dev)
	172	{
	173	__pm_runtime_disable(dev, true);
	174	}
	175
	176	#endif