[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/pm.h>

#ifdef CONFIG_PM_RUNTIME

extern struct workqueue_struct *pm_wq;

extern int pm_runtime_idle(struct device *dev);
extern int pm_runtime_suspend(struct device *dev);
extern int pm_runtime_resume(struct device *dev);
extern int pm_request_idle(struct device *dev);
extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
extern int pm_request_resume(struct device *dev);
extern int __pm_runtime_get(struct device *dev, bool sync);
extern int __pm_runtime_put(struct device *dev, bool sync);
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);

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

#else /* !CONFIG_PM_RUNTIME */

static inline int pm_runtime_idle(struct device *dev) { return -ENOSYS; }
static inline int pm_runtime_suspend(struct device *dev) { return -ENOSYS; }
static inline int pm_runtime_resume(struct device *dev) { return 0; }
static inline int pm_request_idle(struct device *dev) { return -ENOSYS; }
static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
{
	return -ENOSYS;
}
static inline int pm_request_resume(struct device *dev) { return 0; }
static inline int __pm_runtime_get(struct device *dev, bool sync) { return 1; }
static inline int __pm_runtime_put(struct device *dev, bool sync) { return 0; }
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) {}

#endif /* !CONFIG_PM_RUNTIME */

static inline int pm_runtime_get(struct device *dev)
{
	return __pm_runtime_get(dev, false);
}

static inline int pm_runtime_get_sync(struct device *dev)
{
	return __pm_runtime_get(dev, true);
}

static inline int pm_runtime_put(struct device *dev)
{
	return __pm_runtime_put(dev, false);
}

static inline int pm_runtime_put_sync(struct device *dev)
{
	return __pm_runtime_put(dev, true);
}

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
	15	#ifdef CONFIG_PM_RUNTIME
	16
	17	extern struct workqueue_struct *pm_wq;
	18
	19	extern int pm_runtime_idle(struct device *dev);
	20	extern int pm_runtime_suspend(struct device *dev);
	21	extern int pm_runtime_resume(struct device *dev);
	22	extern int pm_request_idle(struct device *dev);
	23	extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
	24	extern int pm_request_resume(struct device *dev);
	25	extern int __pm_runtime_get(struct device *dev, bool sync);
	26	extern int __pm_runtime_put(struct device *dev, bool sync);
	27	extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
	28	extern int pm_runtime_barrier(struct device *dev);
	29	extern void pm_runtime_enable(struct device *dev);
	30	extern void __pm_runtime_disable(struct device *dev, bool check_resume);
53823639 RW	31	extern void pm_runtime_allow(struct device *dev);
53823639 RW	32	extern void pm_runtime_forbid(struct device *dev);
5e928f77 RW	33
	34	static inline bool pm_children_suspended(struct device *dev)
	35	{
	36	return dev->power.ignore_children
	37	\|\| !atomic_read(&dev->power.child_count);
	38	}
	39
	40	static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
	41	{
	42	dev->power.ignore_children = enable;
	43	}
	44
	45	static inline void pm_runtime_get_noresume(struct device *dev)
	46	{
	47	atomic_inc(&dev->power.usage_count);
	48	}
	49
	50	static inline void pm_runtime_put_noidle(struct device *dev)
	51	{
	52	atomic_add_unless(&dev->power.usage_count, -1, 0);
	53	}
	54
7a1a8eb5 RW	55	static inline bool device_run_wake(struct device *dev)
	56	{
	57	return dev->power.run_wake;
	58	}
	59
	60	static inline void device_set_run_wake(struct device *dev, bool enable)
	61	{
	62	dev->power.run_wake = enable;
	63	}
	64
5e928f77 RW	65	#else /* !CONFIG_PM_RUNTIME */
	66
	67	static inline int pm_runtime_idle(struct device *dev) { return -ENOSYS; }
	68	static inline int pm_runtime_suspend(struct device *dev) { return -ENOSYS; }
	69	static inline int pm_runtime_resume(struct device *dev) { return 0; }
	70	static inline int pm_request_idle(struct device *dev) { return -ENOSYS; }
	71	static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
	72	{
	73	return -ENOSYS;
	74	}
	75	static inline int pm_request_resume(struct device *dev) { return 0; }
	76	static inline int __pm_runtime_get(struct device *dev, bool sync) { return 1; }
	77	static inline int __pm_runtime_put(struct device *dev, bool sync) { return 0; }
	78	static inline int __pm_runtime_set_status(struct device *dev,
	79	unsigned int status) { return 0; }
	80	static inline int pm_runtime_barrier(struct device *dev) { return 0; }
	81	static inline void pm_runtime_enable(struct device *dev) {}
	82	static inline void __pm_runtime_disable(struct device *dev, bool c) {}
53823639 RW	83	static inline void pm_runtime_allow(struct device *dev) {}
53823639 RW	84	static inline void pm_runtime_forbid(struct device *dev) {}
5e928f77 RW	85
	86	static inline bool pm_children_suspended(struct device *dev) { return false; }
	87	static inline void pm_suspend_ignore_children(struct device *dev, bool en) {}
	88	static inline void pm_runtime_get_noresume(struct device *dev) {}
	89	static inline void pm_runtime_put_noidle(struct device *dev) {}
7a1a8eb5 RW	90	static inline bool device_run_wake(struct device *dev) { return false; }
7a1a8eb5 RW	91	static inline void device_set_run_wake(struct device *dev, bool enable) {}
5e928f77 RW	92
	93	#endif /* !CONFIG_PM_RUNTIME */
	94
	95	static inline int pm_runtime_get(struct device *dev)
	96	{
	97	return __pm_runtime_get(dev, false);
	98	}
	99
	100	static inline int pm_runtime_get_sync(struct device *dev)
	101	{
	102	return __pm_runtime_get(dev, true);
	103	}
	104
	105	static inline int pm_runtime_put(struct device *dev)
	106	{
	107	return __pm_runtime_put(dev, false);
	108	}
	109
	110	static inline int pm_runtime_put_sync(struct device *dev)
	111	{
	112	return __pm_runtime_put(dev, true);
	113	}
	114
	115	static inline int pm_runtime_set_active(struct device *dev)
	116	{
	117	return __pm_runtime_set_status(dev, RPM_ACTIVE);
	118	}
	119
	120	static inline void pm_runtime_set_suspended(struct device *dev)
	121	{
	122	__pm_runtime_set_status(dev, RPM_SUSPENDED);
	123	}
	124
	125	static inline void pm_runtime_disable(struct device *dev)
	126	{
	127	__pm_runtime_disable(dev, true);
	128	}
	129
	130	#endif