← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/base/power/generic_ops.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/base/power/generic_ops.c
8
8
 
9
9
#include <linux/pm.h>
10
10
#include <linux/pm_runtime.h>
 
11
#include <linux/export.h>
11
12
 
12
13
#ifdef CONFIG_PM_RUNTIME
13
14
/**
94
95
 * __pm_generic_call - Generic suspend/freeze/poweroff/thaw subsystem callback.
95
96
 * @dev: Device to handle.
96
97
 * @event: PM transition of the system under way.
 
98
 * @bool: Whether or not this is the "noirq" stage.
97
99
 *
98
100
 * If the device has not been suspended at run time, execute the
99
101
 * suspend/freeze/poweroff/thaw callback provided by its driver, if defined, and
100
102
 * return its error code.  Otherwise, return zero.
101
103
 */
102
 
static int __pm_generic_call(struct device *dev, int event)
 
104
static int __pm_generic_call(struct device *dev, int event, bool noirq)
103
105
{
104
106
        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
105
107
        int (*callback)(struct device *);
109
111
 
110
112
        switch (event) {
111
113
        case PM_EVENT_SUSPEND:
112
 
                callback = pm->suspend;
 
114
                callback = noirq ? pm->suspend_noirq : pm->suspend;
113
115
                break;
114
116
        case PM_EVENT_FREEZE:
115
 
                callback = pm->freeze;
 
117
                callback = noirq ? pm->freeze_noirq : pm->freeze;
116
118
                break;
117
119
        case PM_EVENT_HIBERNATE:
118
 
                callback = pm->poweroff;
 
120
                callback = noirq ? pm->poweroff_noirq : pm->poweroff;
119
121
                break;
120
122
        case PM_EVENT_THAW:
121
 
                callback = pm->thaw;
 
123
                callback = noirq ? pm->thaw_noirq : pm->thaw;
122
124
                break;
123
125
        default:
124
126
                callback = NULL;
129
131
}
130
132
 
131
133
/**
 
134
 * pm_generic_suspend_noirq - Generic suspend_noirq callback for subsystems.
 
135
 * @dev: Device to suspend.
 
136
 */
 
137
int pm_generic_suspend_noirq(struct device *dev)
 
138
{
 
139
        return __pm_generic_call(dev, PM_EVENT_SUSPEND, true);
 
140
}
 
141
EXPORT_SYMBOL_GPL(pm_generic_suspend_noirq);
 
142
 
 
143
/**
132
144
 * pm_generic_suspend - Generic suspend callback for subsystems.
133
145
 * @dev: Device to suspend.
134
146
 */
135
147
int pm_generic_suspend(struct device *dev)
136
148
{
137
 
        return __pm_generic_call(dev, PM_EVENT_SUSPEND);
 
149
        return __pm_generic_call(dev, PM_EVENT_SUSPEND, false);
138
150
}
139
151
EXPORT_SYMBOL_GPL(pm_generic_suspend);
140
152
 
141
153
/**
 
154
 * pm_generic_freeze_noirq - Generic freeze_noirq callback for subsystems.
 
155
 * @dev: Device to freeze.
 
156
 */
 
157
int pm_generic_freeze_noirq(struct device *dev)
 
158
{
 
159
        return __pm_generic_call(dev, PM_EVENT_FREEZE, true);
 
160
}
 
161
EXPORT_SYMBOL_GPL(pm_generic_freeze_noirq);
 
162
 
 
163
/**
142
164
 * pm_generic_freeze - Generic freeze callback for subsystems.
143
165
 * @dev: Device to freeze.
144
166
 */
145
167
int pm_generic_freeze(struct device *dev)
146
168
{
147
 
        return __pm_generic_call(dev, PM_EVENT_FREEZE);
 
169
        return __pm_generic_call(dev, PM_EVENT_FREEZE, false);
148
170
}
149
171
EXPORT_SYMBOL_GPL(pm_generic_freeze);
150
172
 
151
173
/**
 
174
 * pm_generic_poweroff_noirq - Generic poweroff_noirq callback for subsystems.
 
175
 * @dev: Device to handle.
 
176
 */
 
177
int pm_generic_poweroff_noirq(struct device *dev)
 
178
{
 
179
        return __pm_generic_call(dev, PM_EVENT_HIBERNATE, true);
 
180
}
 
181
EXPORT_SYMBOL_GPL(pm_generic_poweroff_noirq);
 
182
 
 
183
/**
152
184
 * pm_generic_poweroff - Generic poweroff callback for subsystems.
153
185
 * @dev: Device to handle.
154
186
 */
155
187
int pm_generic_poweroff(struct device *dev)
156
188
{
157
 
        return __pm_generic_call(dev, PM_EVENT_HIBERNATE);
 
189
        return __pm_generic_call(dev, PM_EVENT_HIBERNATE, false);
158
190
}
159
191
EXPORT_SYMBOL_GPL(pm_generic_poweroff);
160
192
 
161
193
/**
 
194
 * pm_generic_thaw_noirq - Generic thaw_noirq callback for subsystems.
 
195
 * @dev: Device to thaw.
 
196
 */
 
197
int pm_generic_thaw_noirq(struct device *dev)
 
198
{
 
199
        return __pm_generic_call(dev, PM_EVENT_THAW, true);
 
200
}
 
201
EXPORT_SYMBOL_GPL(pm_generic_thaw_noirq);
 
202
 
 
203
/**
162
204
 * pm_generic_thaw - Generic thaw callback for subsystems.
163
205
 * @dev: Device to thaw.
164
206
 */
165
207
int pm_generic_thaw(struct device *dev)
166
208
{
167
 
        return __pm_generic_call(dev, PM_EVENT_THAW);
 
209
        return __pm_generic_call(dev, PM_EVENT_THAW, false);
168
210
}
169
211
EXPORT_SYMBOL_GPL(pm_generic_thaw);
170
212
 
172
214
 * __pm_generic_resume - Generic resume/restore callback for subsystems.
173
215
 * @dev: Device to handle.
174
216
 * @event: PM transition of the system under way.
 
217
 * @bool: Whether or not this is the "noirq" stage.
175
218
 *
176
219
 * Execute the resume/resotre callback provided by the @dev's driver, if
177
220
 * defined.  If it returns 0, change the device's runtime PM status to 'active'.
178
221
 * Return the callback's error code.
179
222
 */
180
 
static int __pm_generic_resume(struct device *dev, int event)
 
223
static int __pm_generic_resume(struct device *dev, int event, bool noirq)
181
224
{
182
225
        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
183
226
        int (*callback)(struct device *);
188
231
 
189
232
        switch (event) {
190
233
        case PM_EVENT_RESUME:
191
 
                callback = pm->resume;
 
234
                callback = noirq ? pm->resume_noirq : pm->resume;
192
235
                break;
193
236
        case PM_EVENT_RESTORE:
194
 
                callback = pm->restore;
 
237
                callback = noirq ? pm->restore_noirq : pm->restore;
195
238
                break;
196
239
        default:
197
240
                callback = NULL;
202
245
                return 0;
203
246
 
204
247
        ret = callback(dev);
205
 
        if (!ret && pm_runtime_enabled(dev)) {
 
248
        if (!ret && !noirq && pm_runtime_enabled(dev)) {
206
249
                pm_runtime_disable(dev);
207
250
                pm_runtime_set_active(dev);
208
251
                pm_runtime_enable(dev);
212
255
}
213
256
 
214
257
/**
 
258
 * pm_generic_resume_noirq - Generic resume_noirq callback for subsystems.
 
259
 * @dev: Device to resume.
 
260
 */
 
261
int pm_generic_resume_noirq(struct device *dev)
 
262
{
 
263
        return __pm_generic_resume(dev, PM_EVENT_RESUME, true);
 
264
}
 
265
EXPORT_SYMBOL_GPL(pm_generic_resume_noirq);
 
266
 
 
267
/**
215
268
 * pm_generic_resume - Generic resume callback for subsystems.
216
269
 * @dev: Device to resume.
217
270
 */
218
271
int pm_generic_resume(struct device *dev)
219
272
{
220
 
        return __pm_generic_resume(dev, PM_EVENT_RESUME);
 
273
        return __pm_generic_resume(dev, PM_EVENT_RESUME, false);
221
274
}
222
275
EXPORT_SYMBOL_GPL(pm_generic_resume);
223
276
 
224
277
/**
 
278
 * pm_generic_restore_noirq - Generic restore_noirq callback for subsystems.
 
279
 * @dev: Device to restore.
 
280
 */
 
281
int pm_generic_restore_noirq(struct device *dev)
 
282
{
 
283
        return __pm_generic_resume(dev, PM_EVENT_RESTORE, true);
 
284
}
 
285
EXPORT_SYMBOL_GPL(pm_generic_restore_noirq);
 
286
 
 
287
/**
225
288
 * pm_generic_restore - Generic restore callback for subsystems.
226
289
 * @dev: Device to restore.
227
290
 */
228
291
int pm_generic_restore(struct device *dev)
229
292
{
230
 
        return __pm_generic_resume(dev, PM_EVENT_RESTORE);
 
293
        return __pm_generic_resume(dev, PM_EVENT_RESTORE, false);
231
294
}
232
295
EXPORT_SYMBOL_GPL(pm_generic_restore);
233
296
 
256
319
#ifdef CONFIG_PM_SLEEP
257
320
        .prepare = pm_generic_prepare,
258
321
        .suspend = pm_generic_suspend,
 
322
        .suspend_noirq = pm_generic_suspend_noirq,
259
323
        .resume = pm_generic_resume,
 
324
        .resume_noirq = pm_generic_resume_noirq,
260
325
        .freeze = pm_generic_freeze,
 
326
        .freeze_noirq = pm_generic_freeze_noirq,
261
327
        .thaw = pm_generic_thaw,
 
328
        .thaw_noirq = pm_generic_thaw_noirq,
262
329
        .poweroff = pm_generic_poweroff,
 
330
        .poweroff_noirq = pm_generic_poweroff_noirq,
263
331
        .restore = pm_generic_restore,
 
332
        .restore_noirq = pm_generic_restore_noirq,
264
333
        .complete = pm_generic_complete,
265
334
#endif
266
335
#ifdef CONFIG_PM_RUNTIME