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