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