Subversion Repositories Kolibri OS

Rev

Rev 6082 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * pm_runtime.h - Device run-time power management helper functions.
  3.  *
  4.  * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>
  5.  *
  6.  * This file is released under the GPLv2.
  7.  */
  8.  
  9. #ifndef _LINUX_PM_RUNTIME_H
  10. #define _LINUX_PM_RUNTIME_H
  11.  
  12. #include <linux/device.h>
  13. #include <linux/notifier.h>
  14. #include <linux/pm.h>
  15.  
  16. #include <linux/jiffies.h>
  17.  
  18. /* Runtime PM flag argument bits */
  19. #define RPM_ASYNC               0x01    /* Request is asynchronous */
  20. #define RPM_NOWAIT              0x02    /* Don't wait for concurrent
  21.                                             state change */
  22. #define RPM_GET_PUT             0x04    /* Increment/decrement the
  23.                                             usage_count */
  24. #define RPM_AUTO                0x08    /* Use autosuspend_delay */
  25.  
  26. #ifdef CONFIG_PM
  27. extern struct workqueue_struct *pm_wq;
  28.  
  29. static inline bool queue_pm_work(struct work_struct *work)
  30. {
  31.         return queue_work(pm_wq, work);
  32. }
  33.  
  34. extern int pm_generic_runtime_suspend(struct device *dev);
  35. extern int pm_generic_runtime_resume(struct device *dev);
  36. extern int pm_runtime_force_suspend(struct device *dev);
  37. extern int pm_runtime_force_resume(struct device *dev);
  38.  
  39. extern int __pm_runtime_idle(struct device *dev, int rpmflags);
  40. extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
  41. extern int __pm_runtime_resume(struct device *dev, int rpmflags);
  42. extern int pm_runtime_get_if_in_use(struct device *dev);
  43. extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
  44. extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
  45. extern int pm_runtime_barrier(struct device *dev);
  46. extern void pm_runtime_enable(struct device *dev);
  47. extern void __pm_runtime_disable(struct device *dev, bool check_resume);
  48. extern void pm_runtime_allow(struct device *dev);
  49. extern void pm_runtime_forbid(struct device *dev);
  50. extern void pm_runtime_no_callbacks(struct device *dev);
  51. extern void pm_runtime_irq_safe(struct device *dev);
  52. extern void __pm_runtime_use_autosuspend(struct device *dev, bool use);
  53. extern void pm_runtime_set_autosuspend_delay(struct device *dev, int delay);
  54. extern unsigned long pm_runtime_autosuspend_expiration(struct device *dev);
  55. extern void pm_runtime_update_max_time_suspended(struct device *dev,
  56.                                                  s64 delta_ns);
  57. extern void pm_runtime_set_memalloc_noio(struct device *dev, bool enable);
  58.  
  59. static inline bool pm_children_suspended(struct device *dev)
  60. {
  61.         return dev->power.ignore_children
  62.                 || !atomic_read(&dev->power.child_count);
  63. }
  64.  
  65. static inline void pm_runtime_get_noresume(struct device *dev)
  66. {
  67.         atomic_inc(&dev->power.usage_count);
  68. }
  69.  
  70. static inline void pm_runtime_put_noidle(struct device *dev)
  71. {
  72.         atomic_add_unless(&dev->power.usage_count, -1, 0);
  73. }
  74.  
  75. static inline bool device_run_wake(struct device *dev)
  76. {
  77.         return dev->power.run_wake;
  78. }
  79.  
  80. static inline void device_set_run_wake(struct device *dev, bool enable)
  81. {
  82.         dev->power.run_wake = enable;
  83. }
  84.  
  85. static inline bool pm_runtime_suspended(struct device *dev)
  86. {
  87.         return dev->power.runtime_status == RPM_SUSPENDED
  88.                 && !dev->power.disable_depth;
  89. }
  90.  
  91. static inline bool pm_runtime_active(struct device *dev)
  92. {
  93.         return dev->power.runtime_status == RPM_ACTIVE
  94.                 || dev->power.disable_depth;
  95. }
  96.  
  97. static inline bool pm_runtime_status_suspended(struct device *dev)
  98. {
  99.         return dev->power.runtime_status == RPM_SUSPENDED;
  100. }
  101.  
  102. static inline bool pm_runtime_enabled(struct device *dev)
  103. {
  104.         return !dev->power.disable_depth;
  105. }
  106.  
  107. static inline bool pm_runtime_callbacks_present(struct device *dev)
  108. {
  109.         return !dev->power.no_callbacks;
  110. }
  111.  
  112. static inline void pm_runtime_mark_last_busy(struct device *dev)
  113. {
  114.         ACCESS_ONCE(dev->power.last_busy) = jiffies;
  115. }
  116.  
  117. static inline bool pm_runtime_is_irq_safe(struct device *dev)
  118. {
  119.         return dev->power.irq_safe;
  120. }
  121.  
  122. #else /* !CONFIG_PM */
  123.  
  124. static inline bool queue_pm_work(struct work_struct *work) { return false; }
  125.  
  126. static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
  127. static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
  128. static inline int pm_runtime_force_suspend(struct device *dev) { return 0; }
  129. static inline int pm_runtime_force_resume(struct device *dev) { return 0; }
  130.  
  131. static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
  132. {
  133.         return -ENOSYS;
  134. }
  135. static inline int __pm_runtime_suspend(struct device *dev, int rpmflags)
  136. {
  137.         return -ENOSYS;
  138. }
  139. static inline int __pm_runtime_resume(struct device *dev, int rpmflags)
  140. {
  141.         return 1;
  142. }
  143. static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
  144. {
  145.         return -ENOSYS;
  146. }
  147. static inline int pm_runtime_get_if_in_use(struct device *dev)
  148. {
  149.         return -EINVAL;
  150. }
  151. static inline int __pm_runtime_set_status(struct device *dev,
  152.                                             unsigned int status) { return 0; }
  153. static inline int pm_runtime_barrier(struct device *dev) { return 0; }
  154. static inline void pm_runtime_enable(struct device *dev) {}
  155. static inline void __pm_runtime_disable(struct device *dev, bool c) {}
  156. static inline void pm_runtime_allow(struct device *dev) {}
  157. static inline void pm_runtime_forbid(struct device *dev) {}
  158.  
  159. static inline bool pm_children_suspended(struct device *dev) { return false; }
  160. static inline void pm_runtime_get_noresume(struct device *dev) {}
  161. static inline void pm_runtime_put_noidle(struct device *dev) {}
  162. static inline bool device_run_wake(struct device *dev) { return false; }
  163. static inline void device_set_run_wake(struct device *dev, bool enable) {}
  164. static inline bool pm_runtime_suspended(struct device *dev) { return false; }
  165. static inline bool pm_runtime_active(struct device *dev) { return true; }
  166. static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }
  167. static inline bool pm_runtime_enabled(struct device *dev) { return false; }
  168.  
  169. static inline void pm_runtime_no_callbacks(struct device *dev) {}
  170. static inline void pm_runtime_irq_safe(struct device *dev) {}
  171. static inline bool pm_runtime_is_irq_safe(struct device *dev) { return false; }
  172.  
  173. static inline bool pm_runtime_callbacks_present(struct device *dev) { return false; }
  174. static inline void pm_runtime_mark_last_busy(struct device *dev) {}
  175. static inline void __pm_runtime_use_autosuspend(struct device *dev,
  176.                                                 bool use) {}
  177. static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
  178.                                                 int delay) {}
  179. static inline unsigned long pm_runtime_autosuspend_expiration(
  180.                                 struct device *dev) { return 0; }
  181. static inline void pm_runtime_set_memalloc_noio(struct device *dev,
  182.                                                 bool enable){}
  183.  
  184. #endif /* !CONFIG_PM */
  185.  
  186. static inline int pm_runtime_idle(struct device *dev)
  187. {
  188.         return __pm_runtime_idle(dev, 0);
  189. }
  190.  
  191. static inline int pm_runtime_suspend(struct device *dev)
  192. {
  193.         return __pm_runtime_suspend(dev, 0);
  194. }
  195.  
  196. static inline int pm_runtime_autosuspend(struct device *dev)
  197. {
  198.         return __pm_runtime_suspend(dev, RPM_AUTO);
  199. }
  200.  
  201. static inline int pm_runtime_resume(struct device *dev)
  202. {
  203.         return __pm_runtime_resume(dev, 0);
  204. }
  205.  
  206. static inline int pm_request_idle(struct device *dev)
  207. {
  208.         return __pm_runtime_idle(dev, RPM_ASYNC);
  209. }
  210.  
  211. static inline int pm_request_resume(struct device *dev)
  212. {
  213.         return __pm_runtime_resume(dev, RPM_ASYNC);
  214. }
  215.  
  216. static inline int pm_request_autosuspend(struct device *dev)
  217. {
  218.         return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
  219. }
  220.  
  221. static inline int pm_runtime_get(struct device *dev)
  222. {
  223.         return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);
  224. }
  225.  
  226. static inline int pm_runtime_get_sync(struct device *dev)
  227. {
  228.         return __pm_runtime_resume(dev, RPM_GET_PUT);
  229. }
  230.  
  231. static inline int pm_runtime_put(struct device *dev)
  232. {
  233.         return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
  234. }
  235.  
  236. static inline int pm_runtime_put_autosuspend(struct device *dev)
  237. {
  238.         return __pm_runtime_suspend(dev,
  239.             RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
  240. }
  241.  
  242. static inline int pm_runtime_put_sync(struct device *dev)
  243. {
  244.         return __pm_runtime_idle(dev, RPM_GET_PUT);
  245. }
  246.  
  247. static inline int pm_runtime_put_sync_suspend(struct device *dev)
  248. {
  249.         return __pm_runtime_suspend(dev, RPM_GET_PUT);
  250. }
  251.  
  252. static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
  253. {
  254.         return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
  255. }
  256.  
  257. static inline int pm_runtime_set_active(struct device *dev)
  258. {
  259.         return __pm_runtime_set_status(dev, RPM_ACTIVE);
  260. }
  261.  
  262. static inline void pm_runtime_set_suspended(struct device *dev)
  263. {
  264.         __pm_runtime_set_status(dev, RPM_SUSPENDED);
  265. }
  266.  
  267. static inline void pm_runtime_disable(struct device *dev)
  268. {
  269.         __pm_runtime_disable(dev, true);
  270. }
  271.  
  272. static inline void pm_runtime_use_autosuspend(struct device *dev)
  273. {
  274.         __pm_runtime_use_autosuspend(dev, true);
  275. }
  276.  
  277. static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
  278. {
  279.         __pm_runtime_use_autosuspend(dev, false);
  280. }
  281.  
  282. #endif
  283.