LXR linux/include/linux/pm

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