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