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/pm.h>
  14
  15#include <linux/jiffies.h>
  16
  17/* Runtime PM flag argument bits */
  18#define RPM_ASYNC               0x01    /* Request is asynchronous */
  19#define RPM_NOWAIT              0x02    /* Don't wait for concurrent
  20                                            state change */
  21#define RPM_GET_PUT             0x04    /* Increment/decrement the
  22                                            usage_count */
  23#define RPM_AUTO                0x08    /* Use autosuspend_delay */
  24
  25#ifdef CONFIG_PM_RUNTIME
  26
  27extern struct workqueue_struct *pm_wq;
  28
  29extern int __pm_runtime_idle(struct device *dev, int rpmflags);
  30extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
  31extern int __pm_runtime_resume(struct device *dev, int rpmflags);
  32extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
  33extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
  34extern int pm_runtime_barrier(struct device *dev);
  35extern void pm_runtime_enable(struct device *dev);
  36extern void __pm_runtime_disable(struct device *dev, bool check_resume);
  37extern void pm_runtime_allow(struct device *dev);
  38extern void pm_runtime_forbid(struct device *dev);
  39extern int pm_generic_runtime_idle(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);
  47
  48static inline bool pm_children_suspended(struct device *dev)
  49{
  50        return dev->power.ignore_children
  51                || !atomic_read(&dev->power.child_count);
  52}
  53
  54static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
  55{
  56        dev->power.ignore_children = enable;
  57}
  58
  59static inline void pm_runtime_get_noresume(struct device *dev)
  60{
  61        atomic_inc(&dev->power.usage_count);
  62}
  63
  64static inline void pm_runtime_put_noidle(struct device *dev)
  65{
  66        atomic_add_unless(&dev->power.usage_count, -1, 0);
  67}
  68
  69static inline bool device_run_wake(struct device *dev)
  70{
  71        return dev->power.run_wake;
  72}
  73
  74static inline void device_set_run_wake(struct device *dev, bool enable)
  75{
  76        dev->power.run_wake = enable;
  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_enabled(struct device *dev)
  86{
  87        return !dev->power.disable_depth;
  88}
  89
  90static inline bool pm_runtime_callbacks_present(struct device *dev)
  91{
  92        return !dev->power.no_callbacks;
  93}
  94
  95static inline void pm_runtime_mark_last_busy(struct device *dev)
  96{
  97        ACCESS_ONCE(dev->power.last_busy) = jiffies;
  98}
  99
 100#else /* !CONFIG_PM_RUNTIME */
 101
 102static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
 103{
 104        return -ENOSYS;
 105}
 106static inline int __pm_runtime_suspend(struct device *dev, int rpmflags)
 107{
 108        return -ENOSYS;
 109}
 110static inline int __pm_runtime_resume(struct device *dev, int rpmflags)
 111{
 112        return 1;
 113}
 114static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
 115{
 116        return -ENOSYS;
 117}
 118static inline int __pm_runtime_set_status(struct device *dev,
 119                                            unsigned int status) { return 0; }
 120static inline int pm_runtime_barrier(struct device *dev) { return 0; }
 121static inline void pm_runtime_enable(struct device *dev) {}
 122static inline void __pm_runtime_disable(struct device *dev, bool c) {}
 123static inline void pm_runtime_allow(struct device *dev) {}
 124static inline void pm_runtime_forbid(struct device *dev) {}
 125
 126static inline bool pm_children_suspended(struct device *dev) { return false; }
 127static inline void pm_suspend_ignore_children(struct device *dev, bool en) {}
 128static inline void pm_runtime_get_noresume(struct device *dev) {}
 129static inline void pm_runtime_put_noidle(struct device *dev) {}
 130static inline bool device_run_wake(struct device *dev) { return false; }
 131static inline void device_set_run_wake(struct device *dev, bool enable) {}
 132static inline bool pm_runtime_suspended(struct device *dev) { return false; }
 133static inline bool pm_runtime_enabled(struct device *dev) { return false; }
 134
 135static inline int pm_generic_runtime_idle(struct device *dev) { return 0; }
 136static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
 137static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
 138static inline void pm_runtime_no_callbacks(struct device *dev) {}
 139static inline void pm_runtime_irq_safe(struct device *dev) {}
 140
 141static inline bool pm_runtime_callbacks_present(struct device *dev) { return false; }
 142static inline void pm_runtime_mark_last_busy(struct device *dev) {}
 143static inline void __pm_runtime_use_autosuspend(struct device *dev,
 144                                                bool use) {}
 145static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
 146                                                int delay) {}
 147static inline unsigned long pm_runtime_autosuspend_expiration(
 148                                struct device *dev) { return 0; }
 149
 150#endif /* !CONFIG_PM_RUNTIME */
 151
 152static inline int pm_runtime_idle(struct device *dev)
 153{
 154        return __pm_runtime_idle(dev, 0);
 155}
 156
 157static inline int pm_runtime_suspend(struct device *dev)
 158{
 159        return __pm_runtime_suspend(dev, 0);
 160}
 161
 162static inline int pm_runtime_autosuspend(struct device *dev)
 163{
 164        return __pm_runtime_suspend(dev, RPM_AUTO);
 165}
 166
 167static inline int pm_runtime_resume(struct device *dev)
 168{
 169        return __pm_runtime_resume(dev, 0);
 170}
 171
 172static inline int pm_request_idle(struct device *dev)
 173{
 174        return __pm_runtime_idle(dev, RPM_ASYNC);
 175}
 176
 177static inline int pm_request_resume(struct device *dev)
 178{
 179        return __pm_runtime_resume(dev, RPM_ASYNC);
 180}
 181
 182static inline int pm_request_autosuspend(struct device *dev)
 183{
 184        return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
 185}
 186
 187static inline int pm_runtime_get(struct device *dev)
 188{
 189        return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);
 190}
 191
 192static inline int pm_runtime_get_sync(struct device *dev)
 193{
 194        return __pm_runtime_resume(dev, RPM_GET_PUT);
 195}
 196
 197static inline int pm_runtime_put(struct device *dev)
 198{
 199        return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
 200}
 201
 202static inline int pm_runtime_put_autosuspend(struct device *dev)
 203{
 204        return __pm_runtime_suspend(dev,
 205            RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
 206}
 207
 208static inline int pm_runtime_put_sync(struct device *dev)
 209{
 210        return __pm_runtime_idle(dev, RPM_GET_PUT);
 211}
 212
 213static inline int pm_runtime_put_sync_suspend(struct device *dev)
 214{
 215        return __pm_runtime_suspend(dev, RPM_GET_PUT);
 216}
 217
 218static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
 219{
 220        return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
 221}
 222
 223static inline int pm_runtime_set_active(struct device *dev)
 224{
 225        return __pm_runtime_set_status(dev, RPM_ACTIVE);
 226}
 227
 228static inline void pm_runtime_set_suspended(struct device *dev)
 229{
 230        __pm_runtime_set_status(dev, RPM_SUSPENDED);
 231}
 232
 233static inline void pm_runtime_disable(struct device *dev)
 234{
 235        __pm_runtime_disable(dev, true);
 236}
 237
 238static inline void pm_runtime_use_autosuspend(struct device *dev)
 239{
 240        __pm_runtime_use_autosuspend(dev, true);
 241}
 242
 243static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
 244{
 245        __pm_runtime_use_autosuspend(dev, false);
 246}
 247
 248struct pm_clk_notifier_block {
 249        struct notifier_block nb;
 250        struct dev_power_domain *pwr_domain;
 251        char *con_ids[];
 252};
 253
 254#ifdef CONFIG_PM_RUNTIME_CLK
 255extern int pm_runtime_clk_init(struct device *dev);
 256extern void pm_runtime_clk_destroy(struct device *dev);
 257extern int pm_runtime_clk_add(struct device *dev, const char *con_id);
 258extern void pm_runtime_clk_remove(struct device *dev, const char *con_id);
 259extern int pm_runtime_clk_suspend(struct device *dev);
 260extern int pm_runtime_clk_resume(struct device *dev);
 261#else
 262static inline int pm_runtime_clk_init(struct device *dev)
 263{
 264        return -EINVAL;
 265}
 266static inline void pm_runtime_clk_destroy(struct device *dev)
 267{
 268}
 269static inline int pm_runtime_clk_add(struct device *dev, const char *con_id)
 270{
 271        return -EINVAL;
 272}
 273static inline void pm_runtime_clk_remove(struct device *dev, const char *con_id)
 274{
 275}
 276#define pm_runtime_clock_suspend        NULL
 277#define pm_runtime_clock_resume         NULL
 278#endif
 279
 280#ifdef CONFIG_HAVE_CLK
 281extern void pm_runtime_clk_add_notifier(struct bus_type *bus,
 282                                        struct pm_clk_notifier_block *clknb);
 283#else
 284static inline void pm_runtime_clk_add_notifier(struct bus_type *bus,
 285                                        struct pm_clk_notifier_block *clknb)
 286{
 287}
 288#endif
 289
 290#endif
 291