sync: reorder sync_fence_release
[linux-2.6.git] / drivers / base / power / generic_ops.c
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  */
22 int 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 }
35 EXPORT_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  */
45 int 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 }
54 EXPORT_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  */
64 int 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 }
73 EXPORT_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  */
83 int 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_suspend_noirq - Generic suspend_noirq callback for subsystems.
96  * @dev: Device to suspend.
97  */
98 int pm_generic_suspend_noirq(struct device *dev)
99 {
100         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
101
102         return pm && pm->suspend_noirq ? pm->suspend_noirq(dev) : 0;
103 }
104 EXPORT_SYMBOL_GPL(pm_generic_suspend_noirq);
105
106 /**
107  * pm_generic_suspend_late - Generic suspend_late callback for subsystems.
108  * @dev: Device to suspend.
109  */
110 int pm_generic_suspend_late(struct device *dev)
111 {
112         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
113
114         return pm && pm->suspend_late ? pm->suspend_late(dev) : 0;
115 }
116 EXPORT_SYMBOL_GPL(pm_generic_suspend_late);
117
118 /**
119  * pm_generic_suspend - Generic suspend callback for subsystems.
120  * @dev: Device to suspend.
121  */
122 int pm_generic_suspend(struct device *dev)
123 {
124         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
125
126         return pm && pm->suspend ? pm->suspend(dev) : 0;
127 }
128 EXPORT_SYMBOL_GPL(pm_generic_suspend);
129
130 /**
131  * pm_generic_freeze_noirq - Generic freeze_noirq callback for subsystems.
132  * @dev: Device to freeze.
133  */
134 int pm_generic_freeze_noirq(struct device *dev)
135 {
136         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
137
138         return pm && pm->freeze_noirq ? pm->freeze_noirq(dev) : 0;
139 }
140 EXPORT_SYMBOL_GPL(pm_generic_freeze_noirq);
141
142 /**
143  * pm_generic_freeze_late - Generic freeze_late callback for subsystems.
144  * @dev: Device to freeze.
145  */
146 int pm_generic_freeze_late(struct device *dev)
147 {
148         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
149
150         return pm && pm->freeze_late ? pm->freeze_late(dev) : 0;
151 }
152 EXPORT_SYMBOL_GPL(pm_generic_freeze_late);
153
154 /**
155  * pm_generic_freeze - Generic freeze callback for subsystems.
156  * @dev: Device to freeze.
157  */
158 int pm_generic_freeze(struct device *dev)
159 {
160         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
161
162         return pm && pm->freeze ? pm->freeze(dev) : 0;
163 }
164 EXPORT_SYMBOL_GPL(pm_generic_freeze);
165
166 /**
167  * pm_generic_poweroff_noirq - Generic poweroff_noirq callback for subsystems.
168  * @dev: Device to handle.
169  */
170 int pm_generic_poweroff_noirq(struct device *dev)
171 {
172         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
173
174         return pm && pm->poweroff_noirq ? pm->poweroff_noirq(dev) : 0;
175 }
176 EXPORT_SYMBOL_GPL(pm_generic_poweroff_noirq);
177
178 /**
179  * pm_generic_poweroff_late - Generic poweroff_late callback for subsystems.
180  * @dev: Device to handle.
181  */
182 int pm_generic_poweroff_late(struct device *dev)
183 {
184         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
185
186         return pm && pm->poweroff_late ? pm->poweroff_late(dev) : 0;
187 }
188 EXPORT_SYMBOL_GPL(pm_generic_poweroff_late);
189
190 /**
191  * pm_generic_poweroff - Generic poweroff callback for subsystems.
192  * @dev: Device to handle.
193  */
194 int pm_generic_poweroff(struct device *dev)
195 {
196         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
197
198         return pm && pm->poweroff ? pm->poweroff(dev) : 0;
199 }
200 EXPORT_SYMBOL_GPL(pm_generic_poweroff);
201
202 /**
203  * pm_generic_thaw_noirq - Generic thaw_noirq callback for subsystems.
204  * @dev: Device to thaw.
205  */
206 int pm_generic_thaw_noirq(struct device *dev)
207 {
208         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
209
210         return pm && pm->thaw_noirq ? pm->thaw_noirq(dev) : 0;
211 }
212 EXPORT_SYMBOL_GPL(pm_generic_thaw_noirq);
213
214 /**
215  * pm_generic_thaw_early - Generic thaw_early callback for subsystems.
216  * @dev: Device to thaw.
217  */
218 int pm_generic_thaw_early(struct device *dev)
219 {
220         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
221
222         return pm && pm->thaw_early ? pm->thaw_early(dev) : 0;
223 }
224 EXPORT_SYMBOL_GPL(pm_generic_thaw_early);
225
226 /**
227  * pm_generic_thaw - Generic thaw callback for subsystems.
228  * @dev: Device to thaw.
229  */
230 int pm_generic_thaw(struct device *dev)
231 {
232         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
233
234         return pm && pm->thaw ? pm->thaw(dev) : 0;
235 }
236 EXPORT_SYMBOL_GPL(pm_generic_thaw);
237
238 /**
239  * pm_generic_resume_noirq - Generic resume_noirq callback for subsystems.
240  * @dev: Device to resume.
241  */
242 int pm_generic_resume_noirq(struct device *dev)
243 {
244         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
245
246         return pm && pm->resume_noirq ? pm->resume_noirq(dev) : 0;
247 }
248 EXPORT_SYMBOL_GPL(pm_generic_resume_noirq);
249
250 /**
251  * pm_generic_resume_early - Generic resume_early callback for subsystems.
252  * @dev: Device to resume.
253  */
254 int pm_generic_resume_early(struct device *dev)
255 {
256         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
257
258         return pm && pm->resume_early ? pm->resume_early(dev) : 0;
259 }
260 EXPORT_SYMBOL_GPL(pm_generic_resume_early);
261
262 /**
263  * pm_generic_resume - Generic resume callback for subsystems.
264  * @dev: Device to resume.
265  */
266 int pm_generic_resume(struct device *dev)
267 {
268         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
269
270         return pm && pm->resume ? pm->resume(dev) : 0;
271 }
272 EXPORT_SYMBOL_GPL(pm_generic_resume);
273
274 /**
275  * pm_generic_restore_noirq - Generic restore_noirq callback for subsystems.
276  * @dev: Device to restore.
277  */
278 int pm_generic_restore_noirq(struct device *dev)
279 {
280         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
281
282         return pm && pm->restore_noirq ? pm->restore_noirq(dev) : 0;
283 }
284 EXPORT_SYMBOL_GPL(pm_generic_restore_noirq);
285
286 /**
287  * pm_generic_restore_early - Generic restore_early callback for subsystems.
288  * @dev: Device to resume.
289  */
290 int pm_generic_restore_early(struct device *dev)
291 {
292         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
293
294         return pm && pm->restore_early ? pm->restore_early(dev) : 0;
295 }
296 EXPORT_SYMBOL_GPL(pm_generic_restore_early);
297
298 /**
299  * pm_generic_restore - Generic restore callback for subsystems.
300  * @dev: Device to restore.
301  */
302 int pm_generic_restore(struct device *dev)
303 {
304         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
305
306         return pm && pm->restore ? pm->restore(dev) : 0;
307 }
308 EXPORT_SYMBOL_GPL(pm_generic_restore);
309
310 /**
311  * pm_generic_complete - Generic routine competing a device power transition.
312  * @dev: Device to handle.
313  *
314  * Complete a device power transition during a system-wide power transition.
315  */
316 void pm_generic_complete(struct device *dev)
317 {
318         struct device_driver *drv = dev->driver;
319
320         if (drv && drv->pm && drv->pm->complete)
321                 drv->pm->complete(dev);
322
323         /*
324          * Let runtime PM try to suspend devices that haven't been in use before
325          * going into the system-wide sleep state we're resuming from.
326          */
327         pm_runtime_idle(dev);
328 }
329 #endif /* CONFIG_PM_SLEEP */