LXR linux/include/linux/pm

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