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