Subversion Repositories Kolibri OS

Rev

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