pm_runtime.h 7.32 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
/*
 * 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>
13
#include <linux/notifier.h>
14 15
#include <linux/pm.h>

16 17
#include <linux/jiffies.h>

18 19 20 21
/* Runtime PM flag argument bits */
#define RPM_ASYNC		0x01	/* Request is asynchronous */
#define RPM_NOWAIT		0x02	/* Don't wait for concurrent
					    state change */
22 23
#define RPM_GET_PUT		0x04	/* Increment/decrement the
					    usage_count */
24
#define RPM_AUTO		0x08	/* Use autosuspend_delay */
25

26 27 28 29
#ifdef CONFIG_PM_RUNTIME

extern struct workqueue_struct *pm_wq;

30 31 32
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);
33 34 35 36 37
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);
38 39
extern void pm_runtime_allow(struct device *dev);
extern void pm_runtime_forbid(struct device *dev);
40 41 42
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);
43
extern void pm_runtime_no_callbacks(struct device *dev);
44
extern void pm_runtime_irq_safe(struct device *dev);
45 46 47
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);
48 49
extern void pm_runtime_update_max_time_suspended(struct device *dev,
						 s64 delta_ns);
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

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

67 68 69 70 71 72 73 74 75 76
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;
}

77 78
static inline bool pm_runtime_suspended(struct device *dev)
{
79 80
	return dev->power.runtime_status == RPM_SUSPENDED
		&& !dev->power.disable_depth;
81 82
}

83 84 85 86 87
static inline bool pm_runtime_status_suspended(struct device *dev)
{
	return dev->power.runtime_status == RPM_SUSPENDED;
}

88 89 90 91 92
static inline bool pm_runtime_enabled(struct device *dev)
{
	return !dev->power.disable_depth;
}

93 94 95 96 97
static inline bool pm_runtime_callbacks_present(struct device *dev)
{
	return !dev->power.no_callbacks;
}

98 99 100 101 102
static inline void pm_runtime_mark_last_busy(struct device *dev)
{
	ACCESS_ONCE(dev->power.last_busy) = jiffies;
}

103 104
#else /* !CONFIG_PM_RUNTIME */

105 106 107 108 109 110 111 112 113 114 115 116
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;
}
117 118 119 120 121 122 123 124 125
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) {}
126 127
static inline void pm_runtime_allow(struct device *dev) {}
static inline void pm_runtime_forbid(struct device *dev) {}
128 129 130 131

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) {}
132 133
static inline bool device_run_wake(struct device *dev) { return false; }
static inline void device_set_run_wake(struct device *dev, bool enable) {}
134
static inline bool pm_runtime_suspended(struct device *dev) { return false; }
135
static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }
136
static inline bool pm_runtime_enabled(struct device *dev) { return false; }
137

138 139 140
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; }
141
static inline void pm_runtime_no_callbacks(struct device *dev) {}
142
static inline void pm_runtime_irq_safe(struct device *dev) {}
143

144
static inline bool pm_runtime_callbacks_present(struct device *dev) { return false; }
145 146 147 148 149 150 151 152
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; }

153 154
#endif /* !CONFIG_PM_RUNTIME */

155 156 157 158 159 160 161 162 163 164
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);
}

165 166 167 168 169
static inline int pm_runtime_autosuspend(struct device *dev)
{
	return __pm_runtime_suspend(dev, RPM_AUTO);
}

170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
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);
}

185 186 187 188 189
static inline int pm_request_autosuspend(struct device *dev)
{
	return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
}

190 191
static inline int pm_runtime_get(struct device *dev)
{
192
	return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);
193 194 195 196
}

static inline int pm_runtime_get_sync(struct device *dev)
{
197
	return __pm_runtime_resume(dev, RPM_GET_PUT);
198 199 200 201
}

static inline int pm_runtime_put(struct device *dev)
{
202
	return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
203 204
}

205 206 207 208 209 210
static inline int pm_runtime_put_autosuspend(struct device *dev)
{
	return __pm_runtime_suspend(dev,
	    RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
}

211 212
static inline int pm_runtime_put_sync(struct device *dev)
{
213
	return __pm_runtime_idle(dev, RPM_GET_PUT);
214 215
}

216 217 218 219 220
static inline int pm_runtime_put_sync_suspend(struct device *dev)
{
	return __pm_runtime_suspend(dev, RPM_GET_PUT);
}

221 222 223 224 225
static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
{
	return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
}

226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
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);
}

241 242 243 244 245 246 247 248 249 250
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);
}

251
#endif