linux/include/linux/pm_runtime.h
<<
>>
Prefs
   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_RUNTIME
  27
  28extern struct workqueue_struct *pm_wq;
  29
  30extern int __pm_runtime_idle(struct device *dev, int rpmflags);
  31extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
  32extern int __pm_runtime_resume(struct device *dev, int rpmflags);
  33extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
  34extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
  35extern int pm_runtime_barrier(struct device *dev);
  36extern void pm_runtime_enable(struct device *dev);
  37extern void __pm_runtime_disable(struct device *dev, bool check_resume);
  38extern void pm_runtime_allow(struct device *dev);
  39extern void pm_runtime_forbid(struct device *dev);
  40extern int pm_generic_runtime_idle(struct device *dev);
  41extern int pm_generic_runtime_suspend(struct device *dev);
  42extern int pm_generic_runtime_resume(struct device *dev);
  43extern void pm_runtime_no_callbacks(struct device *dev);
  44extern void pm_runtime_irq_safe(struct device *dev);
  45extern void __pm_runtime_use_autosuspend(struct device *dev, bool use);
  46extern void pm_runtime_set_autosuspend_delay(struct device *dev, int delay);
  47extern unsigned long pm_runtime_autosuspend_expiration(struct device *dev);
  48extern void pm_runtime_update_max_time_suspended(struct device *dev,
  49                                                 s64 delta_ns);
  50extern void pm_runtime_set_memalloc_noio(struct device *dev, bool enable);
  51
  52static inline bool pm_children_suspended(struct device *dev)
  53{
  54        return dev->power.ignore_children
  55                || !atomic_read(&dev->power.child_count);
  56}
  57
  58static inline void pm_runtime_get_noresume(struct device *dev)
  59{
  60        atomic_inc(&dev->power.usage_count);
  61}
  62
  63static inline void pm_runtime_put_noidle(struct device *dev)
  64{
  65        atomic_add_unless(&dev->power.usage_count, -1, 0);
  66}
  67
  68static inline bool device_run_wake(struct device *dev)
  69{
  70        return dev->power.run_wake;
  71}
  72
  73static inline void device_set_run_wake(struct device *dev, bool enable)
  74{
  75        dev->power.run_wake = enable;
  76}
  77
  78static inline bool pm_runtime_suspended(struct device *dev)
  79{
  80        return dev->power.runtime_status == RPM_SUSPENDED
  81                && !dev->power.disable_depth;
  82}
  83
  84static inline bool pm_runtime_active(struct device *dev)
  85{
  86        return dev->power.runtime_status == RPM_ACTIVE
  87                || dev->power.disable_depth;
  88}
  89
  90static inline bool pm_runtime_status_suspended(struct device *dev)
  91{
  92        return dev->power.runtime_status == RPM_SUSPENDED;
  93}
  94
  95static inline bool pm_runtime_enabled(struct device *dev)
  96{
  97        return !dev->power.disable_depth;
  98}
  99
 100static inline bool pm_runtime_callbacks_present(struct device *dev)
 101{
 102        return !dev->power.no_callbacks;
 103}
 104
 105static inline void pm_runtime_mark_last_busy(struct device *dev)
 106{
 107        ACCESS_ONCE(dev->power.last_busy) = jiffies;
 108}
 109
 110#else /* !CONFIG_PM_RUNTIME */
 111
 112static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
 113{
 114        return -ENOSYS;
 115}
 116static inline int __pm_runtime_suspend(struct device *dev, int rpmflags)
 117{
 118        return -ENOSYS;
 119}
 120static inline int __pm_runtime_resume(struct device *dev, int rpmflags)
 121{
 122        return 1;
 123}
 124static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
 125{
 126        return -ENOSYS;
 127}
 128static inline int __pm_runtime_set_status(struct device *dev,
 129                                            unsigned int status) { return 0; }
 130static inline int pm_runtime_barrier(struct device *dev) { return 0; }
 131static inline void pm_runtime_enable(struct device *dev) {}
 132static inline void __pm_runtime_disable(struct device *dev, bool c) {}
 133static inline void pm_runtime_allow(struct device *dev) {}
 134static inline void pm_runtime_forbid(struct device *dev) {}
 135
 136static inline bool pm_children_suspended(struct device *dev) { return false; }
 137static inline void pm_runtime_get_noresume(struct device *dev) {}
 138static inline void pm_runtime_put_noidle(struct device *dev) {}
 139static inline bool device_run_wake(struct device *dev) { return false; }
 140static inline void device_set_run_wake(struct device *dev, bool enable) {}
 141static inline bool pm_runtime_suspended(struct device *dev) { return false; }
 142static inline bool pm_runtime_active(struct device *dev) { return true; }
 143static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }
 144static inline bool pm_runtime_enabled(struct device *dev) { return false; }
 145
 146static inline int pm_generic_runtime_idle(struct device *dev) { return 0; }
 147static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
 148static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
 149static inline void pm_runtime_no_callbacks(struct device *dev) {}
 150static inline void pm_runtime_irq_safe(struct device *dev) {}
 151
 152static inline bool pm_runtime_callbacks_present(struct device *dev) { return false; }
 153static inline void pm_runtime_mark_last_busy(struct device *dev) {}
 154static inline void __pm_runtime_use_autosuspend(struct device *dev,
 155                                                bool use) {}
 156static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
 157                                                int delay) {}
 158static inline unsigned long pm_runtime_autosuspend_expiration(
 159                                struct device *dev) { return 0; }
 160static inline void pm_runtime_set_memalloc_noio(struct device *dev,
 161                                                bool enable){}
 162
 163#endif /* !CONFIG_PM_RUNTIME */
 164
 165static inline int pm_runtime_idle(struct device *dev)
 166{
 167        return __pm_runtime_idle(dev, 0);
 168}
 169
 170static inline int pm_runtime_suspend(struct device *dev)
 171{
 172        return __pm_runtime_suspend(dev, 0);
 173}
 174
 175static inline int pm_runtime_autosuspend(struct device *dev)
 176{
 177        return __pm_runtime_suspend(dev, RPM_AUTO);
 178}
 179
 180static inline int pm_runtime_resume(struct device *dev)
 181{
 182        return __pm_runtime_resume(dev, 0);
 183}
 184
 185static inline int pm_request_idle(struct device *dev)
 186{
 187        return __pm_runtime_idle(dev, RPM_ASYNC);
 188}
 189
 190static inline int pm_request_resume(struct device *dev)
 191{
 192        return __pm_runtime_resume(dev, RPM_ASYNC);
 193}
 194
 195static inline int pm_request_autosuspend(struct device *dev)
 196{
 197        return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
 198}
 199
 200static inline int pm_runtime_get(struct device *dev)
 201{
 202        return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);
 203}
 204
 205static inline int pm_runtime_get_sync(struct device *dev)
 206{
 207        return __pm_runtime_resume(dev, RPM_GET_PUT);
 208}
 209
 210static inline int pm_runtime_put(struct device *dev)
 211{
 212        return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
 213}
 214
 215static inline int pm_runtime_put_autosuspend(struct device *dev)
 216{
 217        return __pm_runtime_suspend(dev,
 218            RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
 219}
 220
 221static inline int pm_runtime_put_sync(struct device *dev)
 222{
 223        return __pm_runtime_idle(dev, RPM_GET_PUT);
 224}
 225
 226static inline int pm_runtime_put_sync_suspend(struct device *dev)
 227{
 228        return __pm_runtime_suspend(dev, RPM_GET_PUT);
 229}
 230
 231static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
 232{
 233        return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
 234}
 235
 236static inline int pm_runtime_set_active(struct device *dev)
 237{
 238        return __pm_runtime_set_status(dev, RPM_ACTIVE);
 239}
 240
 241static inline void pm_runtime_set_suspended(struct device *dev)
 242{
 243        __pm_runtime_set_status(dev, RPM_SUSPENDED);
 244}
 245
 246static inline void pm_runtime_disable(struct device *dev)
 247{
 248        __pm_runtime_disable(dev, true);
 249}
 250
 251static inline void pm_runtime_use_autosuspend(struct device *dev)
 252{
 253        __pm_runtime_use_autosuspend(dev, true);
 254}
 255
 256static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
 257{
 258        __pm_runtime_use_autosuspend(dev, false);
 259}
 260
 261#endif
 262
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.