[mirror_ubuntu-focal-kernel.git] / include / linux / pm_runtime.h

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * pm_runtime.h - Device run-time power management helper functions.
 *
 * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>
 */

#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_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_link *link);

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_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_link *link) {}

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

/**
 * pm_runtime_resume_and_get - Bump up usage counter of a device and resume it.
 * @dev: Target device.
 *
 * Resume @dev synchronously and if that is successful, increment its runtime
 * PM usage counter. Return 0 if the runtime PM usage counter of @dev has been
 * incremented or a negative error code otherwise.
 */
static inline int pm_runtime_resume_and_get(struct device *dev)
{
	int ret;

	ret = __pm_runtime_resume(dev, RPM_GET_PUT);
	if (ret < 0) {
		pm_runtime_put_noidle(dev);
		return ret;
	}

	return 0;
}

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
55716d26	1	/* SPDX-License-Identifier: GPL-2.0-only */
5e928f77 RW	2	/*
	3	* pm_runtime.h - Device run-time power management helper functions.
	4	*
	5	* Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>
5e928f77 RW	6	*/
	7
	8	#ifndef _LINUX_PM_RUNTIME_H
	9	#define _LINUX_PM_RUNTIME_H
	10
	11	#include <linux/device.h>
246359d3	12	#include <linux/notifier.h>
5e928f77 RW	13	#include <linux/pm.h>
5e928f77 RW	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
717e5d45	25	#ifdef CONFIG_PM
28cb5ef1 RW	26	extern struct workqueue_struct *pm_wq;
	27
	28	static inline bool queue_pm_work(struct work_struct *work)
	29	{
	30	return queue_work(pm_wq, work);
	31	}
	32
717e5d45 UH	33	extern int pm_generic_runtime_suspend(struct device *dev);
717e5d45 UH	34	extern int pm_generic_runtime_resume(struct device *dev);
37f20416 UH	35	extern int pm_runtime_force_suspend(struct device *dev);
37f20416 UH	36	extern int pm_runtime_force_resume(struct device *dev);
5e928f77	37
140a6c94 AS	38	extern int __pm_runtime_idle(struct device *dev, int rpmflags);
	39	extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
	40	extern int __pm_runtime_resume(struct device *dev, int rpmflags);
a436b6a1	41	extern int pm_runtime_get_if_in_use(struct device *dev);
5e928f77	42	extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
5e928f77 RW	43	extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
	44	extern int pm_runtime_barrier(struct device *dev);
	45	extern void pm_runtime_enable(struct device *dev);
	46	extern void __pm_runtime_disable(struct device *dev, bool check_resume);
53823639 RW	47	extern void pm_runtime_allow(struct device *dev);
53823639 RW	48	extern void pm_runtime_forbid(struct device *dev);
7490e442	49	extern void pm_runtime_no_callbacks(struct device *dev);
c7b61de5	50	extern void pm_runtime_irq_safe(struct device *dev);
15bcb91d AS	51	extern void __pm_runtime_use_autosuspend(struct device *dev, bool use);
15bcb91d AS	52	extern void pm_runtime_set_autosuspend_delay(struct device *dev, int delay);
8234f673	53	extern u64 pm_runtime_autosuspend_expiration(struct device *dev);
00dc9ad1 RW	54	extern void pm_runtime_update_max_time_suspended(struct device *dev,
00dc9ad1 RW	55	s64 delta_ns);
e823407f	56	extern void pm_runtime_set_memalloc_noio(struct device *dev, bool enable);
b06c0b2f RW	57	extern void pm_runtime_get_suppliers(struct device *dev);
b06c0b2f RW	58	extern void pm_runtime_put_suppliers(struct device *dev);
baa8809f	59	extern void pm_runtime_new_link(struct device *dev);
22d62e49	60	extern void pm_runtime_drop_link(struct device_link *link);
5e928f77	61
372a12ed UH	62	static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
	63	{
	64	dev->power.ignore_children = enable;
	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
d690b2cd RW	77	static inline bool pm_runtime_suspended(struct device *dev)
d690b2cd RW	78	{
f08f5a0a RW	79	return dev->power.runtime_status == RPM_SUSPENDED
f08f5a0a RW	80	&& !dev->power.disable_depth;
d690b2cd RW	81	}
d690b2cd RW	82
fbadc58d SL	83	static inline bool pm_runtime_active(struct device *dev)
	84	{
	85	return dev->power.runtime_status == RPM_ACTIVE
	86	\|\| dev->power.disable_depth;
	87	}
	88
f3393b62 KH	89	static inline bool pm_runtime_status_suspended(struct device *dev)
	90	{
	91	return dev->power.runtime_status == RPM_SUSPENDED;
	92	}
	93
4b31db8a RW	94	static inline bool pm_runtime_enabled(struct device *dev)
	95	{
	96	return !dev->power.disable_depth;
	97	}
	98
cb8f51bd RW	99	static inline bool pm_runtime_callbacks_present(struct device *dev)
	100	{
	101	return !dev->power.no_callbacks;
	102	}
	103
15bcb91d AS	104	static inline void pm_runtime_mark_last_busy(struct device *dev)
15bcb91d AS	105	{
15efb47d	106	WRITE_ONCE(dev->power.last_busy, ktime_get_mono_fast_ns());
15bcb91d AS	107	}
15bcb91d AS	108
3fb1581e KK	109	static inline bool pm_runtime_is_irq_safe(struct device *dev)
	110	{
	111	return dev->power.irq_safe;
	112	}
	113
8a62ffe2 VG	114	extern u64 pm_runtime_suspended_time(struct device *dev);
8a62ffe2 VG	115
d30d819d RW	116	#else /* !CONFIG_PM */
	117
	118	static inline bool queue_pm_work(struct work_struct *work) { return false; }
	119
	120	static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
	121	static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
	122	static inline int pm_runtime_force_suspend(struct device *dev) { return 0; }
	123	static inline int pm_runtime_force_resume(struct device *dev) { return 0; }
5e928f77	124
140a6c94 AS	125	static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
	126	{
	127	return -ENOSYS;
	128	}
	129	static inline int __pm_runtime_suspend(struct device *dev, int rpmflags)
	130	{
	131	return -ENOSYS;
	132	}
	133	static inline int __pm_runtime_resume(struct device *dev, int rpmflags)
	134	{
	135	return 1;
	136	}
5e928f77 RW	137	static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
	138	{
	139	return -ENOSYS;
	140	}
a436b6a1 RW	141	static inline int pm_runtime_get_if_in_use(struct device *dev)
	142	{
	143	return -EINVAL;
	144	}
5e928f77 RW	145	static inline int __pm_runtime_set_status(struct device *dev,
	146	unsigned int status) { return 0; }
	147	static inline int pm_runtime_barrier(struct device *dev) { return 0; }
	148	static inline void pm_runtime_enable(struct device *dev) {}
	149	static inline void __pm_runtime_disable(struct device *dev, bool c) {}
53823639 RW	150	static inline void pm_runtime_allow(struct device *dev) {}
53823639 RW	151	static inline void pm_runtime_forbid(struct device *dev) {}
5e928f77	152
372a12ed	153	static inline void pm_suspend_ignore_children(struct device *dev, bool enable) {}
5e928f77 RW	154	static inline void pm_runtime_get_noresume(struct device *dev) {}
5e928f77 RW	155	static inline void pm_runtime_put_noidle(struct device *dev) {}
d690b2cd	156	static inline bool pm_runtime_suspended(struct device *dev) { return false; }
fbadc58d	157	static inline bool pm_runtime_active(struct device *dev) { return true; }
f3393b62	158	static inline bool pm_runtime_status_suspended(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) {}
3fb1581e	163	static inline bool pm_runtime_is_irq_safe(struct device *dev) { return false; }
2f60ba70	164
cb8f51bd	165	static inline bool pm_runtime_callbacks_present(struct device *dev) { return false; }
15bcb91d AS	166	static inline void pm_runtime_mark_last_busy(struct device *dev) {}
	167	static inline void __pm_runtime_use_autosuspend(struct device *dev,
	168	bool use) {}
	169	static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
	170	int delay) {}
8234f673	171	static inline u64 pm_runtime_autosuspend_expiration(
15bcb91d	172	struct device *dev) { return 0; }
e823407f ML	173	static inline void pm_runtime_set_memalloc_noio(struct device *dev,
e823407f ML	174	bool enable){}
b06c0b2f RW	175	static inline void pm_runtime_get_suppliers(struct device *dev) {}
b06c0b2f RW	176	static inline void pm_runtime_put_suppliers(struct device *dev) {}
baa8809f	177	static inline void pm_runtime_new_link(struct device *dev) {}
22d62e49	178	static inline void pm_runtime_drop_link(struct device_link *link) {}
15bcb91d	179
d30d819d	180	#endif /* !CONFIG_PM */
5e928f77	181
140a6c94 AS	182	static inline int pm_runtime_idle(struct device *dev)
	183	{
	184	return __pm_runtime_idle(dev, 0);
	185	}
	186
	187	static inline int pm_runtime_suspend(struct device *dev)
	188	{
	189	return __pm_runtime_suspend(dev, 0);
	190	}
	191
15bcb91d AS	192	static inline int pm_runtime_autosuspend(struct device *dev)
	193	{
	194	return __pm_runtime_suspend(dev, RPM_AUTO);
	195	}
	196
140a6c94 AS	197	static inline int pm_runtime_resume(struct device *dev)
	198	{
	199	return __pm_runtime_resume(dev, 0);
	200	}
	201
	202	static inline int pm_request_idle(struct device *dev)
	203	{
	204	return __pm_runtime_idle(dev, RPM_ASYNC);
	205	}
	206
	207	static inline int pm_request_resume(struct device *dev)
	208	{
	209	return __pm_runtime_resume(dev, RPM_ASYNC);
	210	}
	211
5fc62aad ML	212	static inline int pm_request_autosuspend(struct device *dev)
	213	{
	214	return __pm_runtime_suspend(dev, RPM_ASYNC \| RPM_AUTO);
	215	}
	216
5e928f77 RW	217	static inline int pm_runtime_get(struct device *dev)
5e928f77 RW	218	{
140a6c94	219	return __pm_runtime_resume(dev, RPM_GET_PUT \| RPM_ASYNC);
5e928f77 RW	220	}
	221
	222	static inline int pm_runtime_get_sync(struct device *dev)
	223	{
140a6c94	224	return __pm_runtime_resume(dev, RPM_GET_PUT);
5e928f77 RW	225	}
5e928f77 RW	226
6be790b4 ZQ	227	/**
	228	* pm_runtime_resume_and_get - Bump up usage counter of a device and resume it.
	229	* @dev: Target device.
	230	*
	231	* Resume @dev synchronously and if that is successful, increment its runtime
	232	* PM usage counter. Return 0 if the runtime PM usage counter of @dev has been
	233	* incremented or a negative error code otherwise.
	234	*/
	235	static inline int pm_runtime_resume_and_get(struct device *dev)
	236	{
	237	int ret;
	238
	239	ret = __pm_runtime_resume(dev, RPM_GET_PUT);
	240	if (ret < 0) {
	241	pm_runtime_put_noidle(dev);
	242	return ret;
	243	}
	244
	245	return 0;
	246	}
	247
5e928f77 RW	248	static inline int pm_runtime_put(struct device *dev)
5e928f77 RW	249	{
140a6c94	250	return __pm_runtime_idle(dev, RPM_GET_PUT \| RPM_ASYNC);
5e928f77 RW	251	}
5e928f77 RW	252
15bcb91d AS	253	static inline int pm_runtime_put_autosuspend(struct device *dev)
	254	{
	255	return __pm_runtime_suspend(dev,
	256	RPM_GET_PUT \| RPM_ASYNC \| RPM_AUTO);
	257	}
	258
5e928f77 RW	259	static inline int pm_runtime_put_sync(struct device *dev)
5e928f77 RW	260	{
140a6c94	261	return __pm_runtime_idle(dev, RPM_GET_PUT);
5e928f77 RW	262	}
5e928f77 RW	263
c7b61de5 AS	264	static inline int pm_runtime_put_sync_suspend(struct device *dev)
	265	{
	266	return __pm_runtime_suspend(dev, RPM_GET_PUT);
	267	}
	268
15bcb91d AS	269	static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
	270	{
	271	return __pm_runtime_suspend(dev, RPM_GET_PUT \| RPM_AUTO);
	272	}
	273
5e928f77 RW	274	static inline int pm_runtime_set_active(struct device *dev)
	275	{
	276	return __pm_runtime_set_status(dev, RPM_ACTIVE);
	277	}
	278
b1a60995	279	static inline int pm_runtime_set_suspended(struct device *dev)
5e928f77	280	{
b1a60995	281	return __pm_runtime_set_status(dev, RPM_SUSPENDED);
5e928f77 RW	282	}
	283
	284	static inline void pm_runtime_disable(struct device *dev)
	285	{
	286	__pm_runtime_disable(dev, true);
	287	}
	288
15bcb91d AS	289	static inline void pm_runtime_use_autosuspend(struct device *dev)
	290	{
	291	__pm_runtime_use_autosuspend(dev, true);
	292	}
	293
	294	static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
	295	{
	296	__pm_runtime_use_autosuspend(dev, false);
	297	}
	298
5e928f77	299	#endif