1
2
3
4
5
6
7
8#ifndef _LINUX_PM_RUNTIME_H
9#define _LINUX_PM_RUNTIME_H
10
11#include <linux/device.h>
12#include <linux/notifier.h>
13#include <linux/pm.h>
14
15#include <linux/jiffies.h>
16
17
18#define RPM_ASYNC 0x01
19#define RPM_NOWAIT 0x02
20
21#define RPM_GET_PUT 0x04
22
23#define RPM_AUTO 0x08
24
25#ifdef CONFIG_PM
26extern struct workqueue_struct *pm_wq;
27
28static inline bool queue_pm_work(struct work_struct *work)
29{
30 return queue_work(pm_wq, work);
31}
32
33extern int pm_generic_runtime_suspend(struct device *dev);
34extern int pm_generic_runtime_resume(struct device *dev);
35extern int pm_runtime_force_suspend(struct device *dev);
36extern int pm_runtime_force_resume(struct device *dev);
37
38extern int __pm_runtime_idle(struct device *dev, int rpmflags);
39extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
40extern int __pm_runtime_resume(struct device *dev, int rpmflags);
41extern int pm_runtime_get_if_active(struct device *dev, bool ign_usage_count);
42extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
43extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
44extern int pm_runtime_barrier(struct device *dev);
45extern void pm_runtime_enable(struct device *dev);
46extern void __pm_runtime_disable(struct device *dev, bool check_resume);
47extern void pm_runtime_allow(struct device *dev);
48extern void pm_runtime_forbid(struct device *dev);
49extern void pm_runtime_no_callbacks(struct device *dev);
50extern void pm_runtime_irq_safe(struct device *dev);
51extern void __pm_runtime_use_autosuspend(struct device *dev, bool use);
52extern void pm_runtime_set_autosuspend_delay(struct device *dev, int delay);
53extern u64 pm_runtime_autosuspend_expiration(struct device *dev);
54extern void pm_runtime_update_max_time_suspended(struct device *dev,
55 s64 delta_ns);
56extern void pm_runtime_set_memalloc_noio(struct device *dev, bool enable);
57extern void pm_runtime_clean_up_links(struct device *dev);
58extern void pm_runtime_get_suppliers(struct device *dev);
59extern void pm_runtime_put_suppliers(struct device *dev);
60extern void pm_runtime_new_link(struct device *dev);
61extern void pm_runtime_drop_link(struct device *dev);
62
63
64
65
66
67
68
69
70static inline int pm_runtime_get_if_in_use(struct device *dev)
71{
72 return pm_runtime_get_if_active(dev, false);
73}
74
75
76
77
78
79
80
81
82
83
84static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
85{
86 dev->power.ignore_children = enable;
87}
88
89
90
91
92
93static inline void pm_runtime_get_noresume(struct device *dev)
94{
95 atomic_inc(&dev->power.usage_count);
96}
97
98
99
100
101
102
103
104static inline void pm_runtime_put_noidle(struct device *dev)
105{
106 atomic_add_unless(&dev->power.usage_count, -1, 0);
107}
108
109
110
111
112
113
114
115
116
117
118
119
120
121static inline bool pm_runtime_suspended(struct device *dev)
122{
123 return dev->power.runtime_status == RPM_SUSPENDED
124 && !dev->power.disable_depth;
125}
126
127
128
129
130
131
132
133
134
135
136
137
138
139static inline bool pm_runtime_active(struct device *dev)
140{
141 return dev->power.runtime_status == RPM_ACTIVE
142 || dev->power.disable_depth;
143}
144
145
146
147
148
149
150
151
152
153
154
155
156static inline bool pm_runtime_status_suspended(struct device *dev)
157{
158 return dev->power.runtime_status == RPM_SUSPENDED;
159}
160
161
162
163
164
165
166
167
168
169
170
171static inline bool pm_runtime_enabled(struct device *dev)
172{
173 return !dev->power.disable_depth;
174}
175
176
177
178
179
180
181
182
183static inline bool pm_runtime_has_no_callbacks(struct device *dev)
184{
185 return dev->power.no_callbacks;
186}
187
188
189
190
191
192
193
194
195static inline void pm_runtime_mark_last_busy(struct device *dev)
196{
197 WRITE_ONCE(dev->power.last_busy, ktime_get_mono_fast_ns());
198}
199
200
201
202
203
204
205
206
207
208static inline bool pm_runtime_is_irq_safe(struct device *dev)
209{
210 return dev->power.irq_safe;
211}
212
213extern u64 pm_runtime_suspended_time(struct device *dev);
214
215#else
216
217static inline bool queue_pm_work(struct work_struct *work) { return false; }
218
219static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
220static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
221static inline int pm_runtime_force_suspend(struct device *dev) { return 0; }
222static inline int pm_runtime_force_resume(struct device *dev) { return 0; }
223
224static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
225{
226 return -ENOSYS;
227}
228static inline int __pm_runtime_suspend(struct device *dev, int rpmflags)
229{
230 return -ENOSYS;
231}
232static inline int __pm_runtime_resume(struct device *dev, int rpmflags)
233{
234 return 1;
235}
236static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
237{
238 return -ENOSYS;
239}
240static inline int pm_runtime_get_if_in_use(struct device *dev)
241{
242 return -EINVAL;
243}
244static inline int pm_runtime_get_if_active(struct device *dev,
245 bool ign_usage_count)
246{
247 return -EINVAL;
248}
249static inline int __pm_runtime_set_status(struct device *dev,
250 unsigned int status) { return 0; }
251static inline int pm_runtime_barrier(struct device *dev) { return 0; }
252static inline void pm_runtime_enable(struct device *dev) {}
253static inline void __pm_runtime_disable(struct device *dev, bool c) {}
254static inline void pm_runtime_allow(struct device *dev) {}
255static inline void pm_runtime_forbid(struct device *dev) {}
256
257static inline void pm_suspend_ignore_children(struct device *dev, bool enable) {}
258static inline void pm_runtime_get_noresume(struct device *dev) {}
259static inline void pm_runtime_put_noidle(struct device *dev) {}
260static inline bool pm_runtime_suspended(struct device *dev) { return false; }
261static inline bool pm_runtime_active(struct device *dev) { return true; }
262static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }
263static inline bool pm_runtime_enabled(struct device *dev) { return false; }
264
265static inline void pm_runtime_no_callbacks(struct device *dev) {}
266static inline void pm_runtime_irq_safe(struct device *dev) {}
267static inline bool pm_runtime_is_irq_safe(struct device *dev) { return false; }
268
269static inline bool pm_runtime_callbacks_present(struct device *dev) { return false; }
270static inline void pm_runtime_mark_last_busy(struct device *dev) {}
271static inline void __pm_runtime_use_autosuspend(struct device *dev,
272 bool use) {}
273static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
274 int delay) {}
275static inline u64 pm_runtime_autosuspend_expiration(
276 struct device *dev) { return 0; }
277static inline void pm_runtime_set_memalloc_noio(struct device *dev,
278 bool enable){}
279static inline void pm_runtime_clean_up_links(struct device *dev) {}
280static inline void pm_runtime_get_suppliers(struct device *dev) {}
281static inline void pm_runtime_put_suppliers(struct device *dev) {}
282static inline void pm_runtime_new_link(struct device *dev) {}
283static inline void pm_runtime_drop_link(struct device *dev) {}
284
285#endif
286
287
288
289
290
291
292
293
294
295static inline int pm_runtime_idle(struct device *dev)
296{
297 return __pm_runtime_idle(dev, 0);
298}
299
300
301
302
303
304static inline int pm_runtime_suspend(struct device *dev)
305{
306 return __pm_runtime_suspend(dev, 0);
307}
308
309
310
311
312
313
314
315
316static inline int pm_runtime_autosuspend(struct device *dev)
317{
318 return __pm_runtime_suspend(dev, RPM_AUTO);
319}
320
321
322
323
324
325static inline int pm_runtime_resume(struct device *dev)
326{
327 return __pm_runtime_resume(dev, 0);
328}
329
330
331
332
333
334
335
336
337static inline int pm_request_idle(struct device *dev)
338{
339 return __pm_runtime_idle(dev, RPM_ASYNC);
340}
341
342
343
344
345
346static inline int pm_request_resume(struct device *dev)
347{
348 return __pm_runtime_resume(dev, RPM_ASYNC);
349}
350
351
352
353
354
355
356
357
358static inline int pm_request_autosuspend(struct device *dev)
359{
360 return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
361}
362
363
364
365
366
367
368
369
370static inline int pm_runtime_get(struct device *dev)
371{
372 return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);
373}
374
375
376
377
378
379
380
381
382
383
384
385
386static inline int pm_runtime_get_sync(struct device *dev)
387{
388 return __pm_runtime_resume(dev, RPM_GET_PUT);
389}
390
391
392
393
394
395
396
397
398static inline int pm_runtime_put(struct device *dev)
399{
400 return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
401}
402
403
404
405
406
407
408
409
410static inline int pm_runtime_put_autosuspend(struct device *dev)
411{
412 return __pm_runtime_suspend(dev,
413 RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
414}
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429static inline int pm_runtime_put_sync(struct device *dev)
430{
431 return __pm_runtime_idle(dev, RPM_GET_PUT);
432}
433
434
435
436
437
438
439
440
441
442
443
444
445static inline int pm_runtime_put_sync_suspend(struct device *dev)
446{
447 return __pm_runtime_suspend(dev, RPM_GET_PUT);
448}
449
450
451
452
453
454
455
456
457
458
459
460
461
462static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
463{
464 return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
465}
466
467
468
469
470
471
472
473
474
475
476static inline int pm_runtime_set_active(struct device *dev)
477{
478 return __pm_runtime_set_status(dev, RPM_ACTIVE);
479}
480
481
482
483
484
485
486
487
488
489
490static inline int pm_runtime_set_suspended(struct device *dev)
491{
492 return __pm_runtime_set_status(dev, RPM_SUSPENDED);
493}
494
495
496
497
498
499
500
501
502
503
504
505static inline void pm_runtime_disable(struct device *dev)
506{
507 __pm_runtime_disable(dev, true);
508}
509
510
511
512
513
514
515
516
517
518static inline void pm_runtime_use_autosuspend(struct device *dev)
519{
520 __pm_runtime_use_autosuspend(dev, true);
521}
522
523
524
525
526
527
528
529
530
531static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
532{
533 __pm_runtime_use_autosuspend(dev, false);
534}
535
536#endif
537