Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/*
2 * drivers/base/power/generic_ops.c - Generic PM callbacks for subsystems
3 *
4 * Copyright (c) 2010 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
5 *
6 * This file is released under the GPLv2.
7 */
8
9#include <linux/pm.h>
10#include <linux/pm_runtime.h>
11#include <linux/export.h>
12
13#ifdef CONFIG_PM_RUNTIME
14/**
15 * pm_generic_runtime_idle - Generic runtime idle callback for subsystems.
16 * @dev: Device to handle.
17 *
18 * If PM operations are defined for the @dev's driver and they include
19 * ->runtime_idle(), execute it and return its error code, if nonzero.
20 * Otherwise, execute pm_runtime_suspend() for the device and return 0.
21 */
22int pm_generic_runtime_idle(struct device *dev)
23{
24 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
25
26 if (pm && pm->runtime_idle) {
27 int ret = pm->runtime_idle(dev);
28 if (ret)
29 return ret;
30 }
31
32 pm_runtime_suspend(dev);
33 return 0;
34}
35EXPORT_SYMBOL_GPL(pm_generic_runtime_idle);
36
37/**
38 * pm_generic_runtime_suspend - Generic runtime suspend callback for subsystems.
39 * @dev: Device to suspend.
40 *
41 * If PM operations are defined for the @dev's driver and they include
42 * ->runtime_suspend(), execute it and return its error code. Otherwise,
43 * return 0.
44 */
45int pm_generic_runtime_suspend(struct device *dev)
46{
47 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
48 int ret;
49
50 ret = pm && pm->runtime_suspend ? pm->runtime_suspend(dev) : 0;
51
52 return ret;
53}
54EXPORT_SYMBOL_GPL(pm_generic_runtime_suspend);
55
56/**
57 * pm_generic_runtime_resume - Generic runtime resume callback for subsystems.
58 * @dev: Device to resume.
59 *
60 * If PM operations are defined for the @dev's driver and they include
61 * ->runtime_resume(), execute it and return its error code. Otherwise,
62 * return 0.
63 */
64int pm_generic_runtime_resume(struct device *dev)
65{
66 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
67 int ret;
68
69 ret = pm && pm->runtime_resume ? pm->runtime_resume(dev) : 0;
70
71 return ret;
72}
73EXPORT_SYMBOL_GPL(pm_generic_runtime_resume);
74#endif /* CONFIG_PM_RUNTIME */
75
76#ifdef CONFIG_PM_SLEEP
77/**
78 * pm_generic_prepare - Generic routine preparing a device for power transition.
79 * @dev: Device to prepare.
80 *
81 * Prepare a device for a system-wide power transition.
82 */
83int pm_generic_prepare(struct device *dev)
84{
85 struct device_driver *drv = dev->driver;
86 int ret = 0;
87
88 if (drv && drv->pm && drv->pm->prepare)
89 ret = drv->pm->prepare(dev);
90
91 return ret;
92}
93
94/**
95 * __pm_generic_call - Generic suspend/freeze/poweroff/thaw subsystem callback.
96 * @dev: Device to handle.
97 * @event: PM transition of the system under way.
98 * @bool: Whether or not this is the "noirq" stage.
99 *
100 * If the device has not been suspended at run time, execute the
101 * suspend/freeze/poweroff/thaw callback provided by its driver, if defined, and
102 * return its error code. Otherwise, return zero.
103 */
104static int __pm_generic_call(struct device *dev, int event, bool noirq)
105{
106 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
107 int (*callback)(struct device *);
108
109 if (!pm || pm_runtime_suspended(dev))
110 return 0;
111
112 switch (event) {
113 case PM_EVENT_SUSPEND:
114 callback = noirq ? pm->suspend_noirq : pm->suspend;
115 break;
116 case PM_EVENT_FREEZE:
117 callback = noirq ? pm->freeze_noirq : pm->freeze;
118 break;
119 case PM_EVENT_HIBERNATE:
120 callback = noirq ? pm->poweroff_noirq : pm->poweroff;
121 break;
122 case PM_EVENT_THAW:
123 callback = noirq ? pm->thaw_noirq : pm->thaw;
124 break;
125 default:
126 callback = NULL;
127 break;
128 }
129
130 return callback ? callback(dev) : 0;
131}
132
133/**
134 * pm_generic_suspend_noirq - Generic suspend_noirq callback for subsystems.
135 * @dev: Device to suspend.
136 */
137int pm_generic_suspend_noirq(struct device *dev)
138{
139 return __pm_generic_call(dev, PM_EVENT_SUSPEND, true);
140}
141EXPORT_SYMBOL_GPL(pm_generic_suspend_noirq);
142
143/**
144 * pm_generic_suspend - Generic suspend callback for subsystems.
145 * @dev: Device to suspend.
146 */
147int pm_generic_suspend(struct device *dev)
148{
149 return __pm_generic_call(dev, PM_EVENT_SUSPEND, false);
150}
151EXPORT_SYMBOL_GPL(pm_generic_suspend);
152
153/**
154 * pm_generic_freeze_noirq - Generic freeze_noirq callback for subsystems.
155 * @dev: Device to freeze.
156 */
157int pm_generic_freeze_noirq(struct device *dev)
158{
159 return __pm_generic_call(dev, PM_EVENT_FREEZE, true);
160}
161EXPORT_SYMBOL_GPL(pm_generic_freeze_noirq);
162
163/**
164 * pm_generic_freeze - Generic freeze callback for subsystems.
165 * @dev: Device to freeze.
166 */
167int pm_generic_freeze(struct device *dev)
168{
169 return __pm_generic_call(dev, PM_EVENT_FREEZE, false);
170}
171EXPORT_SYMBOL_GPL(pm_generic_freeze);
172
173/**
174 * pm_generic_poweroff_noirq - Generic poweroff_noirq callback for subsystems.
175 * @dev: Device to handle.
176 */
177int pm_generic_poweroff_noirq(struct device *dev)
178{
179 return __pm_generic_call(dev, PM_EVENT_HIBERNATE, true);
180}
181EXPORT_SYMBOL_GPL(pm_generic_poweroff_noirq);
182
183/**
184 * pm_generic_poweroff - Generic poweroff callback for subsystems.
185 * @dev: Device to handle.
186 */
187int pm_generic_poweroff(struct device *dev)
188{
189 return __pm_generic_call(dev, PM_EVENT_HIBERNATE, false);
190}
191EXPORT_SYMBOL_GPL(pm_generic_poweroff);
192
193/**
194 * pm_generic_thaw_noirq - Generic thaw_noirq callback for subsystems.
195 * @dev: Device to thaw.
196 */
197int pm_generic_thaw_noirq(struct device *dev)
198{
199 return __pm_generic_call(dev, PM_EVENT_THAW, true);
200}
201EXPORT_SYMBOL_GPL(pm_generic_thaw_noirq);
202
203/**
204 * pm_generic_thaw - Generic thaw callback for subsystems.
205 * @dev: Device to thaw.
206 */
207int pm_generic_thaw(struct device *dev)
208{
209 return __pm_generic_call(dev, PM_EVENT_THAW, false);
210}
211EXPORT_SYMBOL_GPL(pm_generic_thaw);
212
213/**
214 * __pm_generic_resume - Generic resume/restore callback for subsystems.
215 * @dev: Device to handle.
216 * @event: PM transition of the system under way.
217 * @bool: Whether or not this is the "noirq" stage.
218 *
219 * Execute the resume/resotre callback provided by the @dev's driver, if
220 * defined. If it returns 0, change the device's runtime PM status to 'active'.
221 * Return the callback's error code.
222 */
223static int __pm_generic_resume(struct device *dev, int event, bool noirq)
224{
225 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
226 int (*callback)(struct device *);
227 int ret;
228
229 if (!pm)
230 return 0;
231
232 switch (event) {
233 case PM_EVENT_RESUME:
234 callback = noirq ? pm->resume_noirq : pm->resume;
235 break;
236 case PM_EVENT_RESTORE:
237 callback = noirq ? pm->restore_noirq : pm->restore;
238 break;
239 default:
240 callback = NULL;
241 break;
242 }
243
244 if (!callback)
245 return 0;
246
247 ret = callback(dev);
248 if (!ret && !noirq && pm_runtime_enabled(dev)) {
249 pm_runtime_disable(dev);
250 pm_runtime_set_active(dev);
251 pm_runtime_enable(dev);
252 }
253
254 return ret;
255}
256
257/**
258 * pm_generic_resume_noirq - Generic resume_noirq callback for subsystems.
259 * @dev: Device to resume.
260 */
261int pm_generic_resume_noirq(struct device *dev)
262{
263 return __pm_generic_resume(dev, PM_EVENT_RESUME, true);
264}
265EXPORT_SYMBOL_GPL(pm_generic_resume_noirq);
266
267/**
268 * pm_generic_resume - Generic resume callback for subsystems.
269 * @dev: Device to resume.
270 */
271int pm_generic_resume(struct device *dev)
272{
273 return __pm_generic_resume(dev, PM_EVENT_RESUME, false);
274}
275EXPORT_SYMBOL_GPL(pm_generic_resume);
276
277/**
278 * pm_generic_restore_noirq - Generic restore_noirq callback for subsystems.
279 * @dev: Device to restore.
280 */
281int pm_generic_restore_noirq(struct device *dev)
282{
283 return __pm_generic_resume(dev, PM_EVENT_RESTORE, true);
284}
285EXPORT_SYMBOL_GPL(pm_generic_restore_noirq);
286
287/**
288 * pm_generic_restore - Generic restore callback for subsystems.
289 * @dev: Device to restore.
290 */
291int pm_generic_restore(struct device *dev)
292{
293 return __pm_generic_resume(dev, PM_EVENT_RESTORE, false);
294}
295EXPORT_SYMBOL_GPL(pm_generic_restore);
296
297/**
298 * pm_generic_complete - Generic routine competing a device power transition.
299 * @dev: Device to handle.
300 *
301 * Complete a device power transition during a system-wide power transition.
302 */
303void pm_generic_complete(struct device *dev)
304{
305 struct device_driver *drv = dev->driver;
306
307 if (drv && drv->pm && drv->pm->complete)
308 drv->pm->complete(dev);
309
310 /*
311 * Let runtime PM try to suspend devices that haven't been in use before
312 * going into the system-wide sleep state we're resuming from.
313 */
314 pm_runtime_idle(dev);
315}
316#endif /* CONFIG_PM_SLEEP */
317
318struct dev_pm_ops generic_subsys_pm_ops = {
319#ifdef CONFIG_PM_SLEEP
320 .prepare = pm_generic_prepare,
321 .suspend = pm_generic_suspend,
322 .suspend_noirq = pm_generic_suspend_noirq,
323 .resume = pm_generic_resume,
324 .resume_noirq = pm_generic_resume_noirq,
325 .freeze = pm_generic_freeze,
326 .freeze_noirq = pm_generic_freeze_noirq,
327 .thaw = pm_generic_thaw,
328 .thaw_noirq = pm_generic_thaw_noirq,
329 .poweroff = pm_generic_poweroff,
330 .poweroff_noirq = pm_generic_poweroff_noirq,
331 .restore = pm_generic_restore,
332 .restore_noirq = pm_generic_restore_noirq,
333 .complete = pm_generic_complete,
334#endif
335#ifdef CONFIG_PM_RUNTIME
336 .runtime_suspend = pm_generic_runtime_suspend,
337 .runtime_resume = pm_generic_runtime_resume,
338 .runtime_idle = pm_generic_runtime_idle,
339#endif
340};
341EXPORT_SYMBOL_GPL(generic_subsys_pm_ops);