drivers/gpu/drm/i915/intel_wakeref.h

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright © 2019 Intel Corporation
   5  */
   6
   7 #ifndef INTEL_WAKEREF_H
   8 #define INTEL_WAKEREF_H
   9
  10 #include <linux/atomic.h>
  11 #include <linux/bitfield.h>
  12 #include <linux/bits.h>
  13 #include <linux/lockdep.h>
  14 #include <linux/mutex.h>
  15 #include <linux/refcount.h>
  16 #include <linux/stackdepot.h>
  17 #include <linux/timer.h>
  18 #include <linux/workqueue.h>
  19
  20 #if IS_ENABLED(CONFIG_DRM_I915_DEBUG)
  21 #define INTEL_WAKEREF_BUG_ON(expr) BUG_ON(expr)
  22 #else
  23 #define INTEL_WAKEREF_BUG_ON(expr) BUILD_BUG_ON_INVALID(expr)
  24 #endif
  25
  26 struct intel_runtime_pm;
  27 struct intel_wakeref;
  28
  29 typedef depot_stack_handle_t intel_wakeref_t;
  30
  31 struct intel_wakeref_ops {
  32         int (*get)(struct intel_wakeref *wf);
  33         int (*put)(struct intel_wakeref *wf);
  34 };
  35
  36 struct intel_wakeref {
  37         atomic_t count;
  38         struct mutex mutex;
  39
  40         intel_wakeref_t wakeref;
  41
  42         struct intel_runtime_pm *rpm;
  43         const struct intel_wakeref_ops *ops;
  44
  45         struct delayed_work work;
  46 };
  47
  48 struct intel_wakeref_lockclass {
  49         struct lock_class_key mutex;
  50         struct lock_class_key work;
  51 };
  52
  53 void __intel_wakeref_init(struct intel_wakeref *wf,
  54                           struct intel_runtime_pm *rpm,
  55                           const struct intel_wakeref_ops *ops,
  56                           struct intel_wakeref_lockclass *key);
  57 #define intel_wakeref_init(wf, rpm, ops) do {                           \
  58         static struct intel_wakeref_lockclass __key;                    \
  59                                                                         \
  60         __intel_wakeref_init((wf), (rpm), (ops), &__key);               \
  61 } while (0)
  62
  63 int __intel_wakeref_get_first(struct intel_wakeref *wf);
  64 void __intel_wakeref_put_last(struct intel_wakeref *wf, unsigned long flags);
  65
  66 /**
  67  * intel_wakeref_get: Acquire the wakeref
  68  * @wf: the wakeref
  69  *
  70  * Acquire a hold on the wakeref. The first user to do so, will acquire
  71  * the runtime pm wakeref and then call the @fn underneath the wakeref
  72  * mutex.
  73  *
  74  * Note that @fn is allowed to fail, in which case the runtime-pm wakeref
  75  * will be released and the acquisition unwound, and an error reported.
  76  *
  77  * Returns: 0 if the wakeref was acquired successfully, or a negative error
  78  * code otherwise.
  79  */
  80 static inline int
  81 intel_wakeref_get(struct intel_wakeref *wf)
  82 {
  83         might_sleep();
  84         if (unlikely(!atomic_inc_not_zero(&wf->count)))
  85                 return __intel_wakeref_get_first(wf);
  86
  87         return 0;
  88 }
  89
  90 /**
  91  * __intel_wakeref_get: Acquire the wakeref, again
  92  * @wf: the wakeref
  93  *
  94  * Increment the wakeref counter, only valid if it is already held by
  95  * the caller.
  96  *
  97  * See intel_wakeref_get().
  98  */
  99 static inline void
 100 __intel_wakeref_get(struct intel_wakeref *wf)
 101 {
 102         INTEL_WAKEREF_BUG_ON(atomic_read(&wf->count) <= 0);
 103         atomic_inc(&wf->count);
 104 }
 105
 106 /**
 107  * intel_wakeref_get_if_in_use: Acquire the wakeref
 108  * @wf: the wakeref
 109  *
 110  * Acquire a hold on the wakeref, but only if the wakeref is already
 111  * active.
 112  *
 113  * Returns: true if the wakeref was acquired, false otherwise.
 114  */
 115 static inline bool
 116 intel_wakeref_get_if_active(struct intel_wakeref *wf)
 117 {
 118         return atomic_inc_not_zero(&wf->count);
 119 }
 120
 121 enum {
 122         INTEL_WAKEREF_PUT_ASYNC_BIT = 0,
 123         __INTEL_WAKEREF_PUT_LAST_BIT__
 124 };
 125
 126 static inline void
 127 intel_wakeref_might_get(struct intel_wakeref *wf)
 128 {
 129         might_lock(&wf->mutex);
 130 }
 131
 132 /**
 133  * intel_wakeref_put_flags: Release the wakeref
 134  * @wf: the wakeref
 135  * @flags: control flags
 136  *
 137  * Release our hold on the wakeref. When there are no more users,
 138  * the runtime pm wakeref will be released after the @fn callback is called
 139  * underneath the wakeref mutex.
 140  *
 141  * Note that @fn is allowed to fail, in which case the runtime-pm wakeref
 142  * is retained and an error reported.
 143  *
 144  * Returns: 0 if the wakeref was released successfully, or a negative error
 145  * code otherwise.
 146  */
 147 static inline void
 148 __intel_wakeref_put(struct intel_wakeref *wf, unsigned long flags)
 149 #define INTEL_WAKEREF_PUT_ASYNC BIT(INTEL_WAKEREF_PUT_ASYNC_BIT)
 150 #define INTEL_WAKEREF_PUT_DELAY \
 151         GENMASK(BITS_PER_LONG - 1, __INTEL_WAKEREF_PUT_LAST_BIT__)
 152 {
 153         INTEL_WAKEREF_BUG_ON(atomic_read(&wf->count) <= 0);
 154         if (unlikely(!atomic_add_unless(&wf->count, -1, 1)))
 155                 __intel_wakeref_put_last(wf, flags);
 156 }
 157
 158 static inline void
 159 intel_wakeref_put(struct intel_wakeref *wf)
 160 {
 161         might_sleep();
 162         __intel_wakeref_put(wf, 0);
 163 }
 164
 165 static inline void
 166 intel_wakeref_put_async(struct intel_wakeref *wf)
 167 {
 168         __intel_wakeref_put(wf, INTEL_WAKEREF_PUT_ASYNC);
 169 }
 170
 171 static inline void
 172 intel_wakeref_put_delay(struct intel_wakeref *wf, unsigned long delay)
 173 {
 174         __intel_wakeref_put(wf,
 175                             INTEL_WAKEREF_PUT_ASYNC |
 176                             FIELD_PREP(INTEL_WAKEREF_PUT_DELAY, delay));
 177 }
 178
 179 static inline void
 180 intel_wakeref_might_put(struct intel_wakeref *wf)
 181 {
 182         might_lock(&wf->mutex);
 183 }
 184
 185 /**
 186  * intel_wakeref_lock: Lock the wakeref (mutex)
 187  * @wf: the wakeref
 188  *
 189  * Locks the wakeref to prevent it being acquired or released. New users
 190  * can still adjust the counter, but the wakeref itself (and callback)
 191  * cannot be acquired or released.
 192  */
 193 static inline void
 194 intel_wakeref_lock(struct intel_wakeref *wf)
 195         __acquires(wf->mutex)
 196 {
 197         mutex_lock(&wf->mutex);
 198 }
 199
 200 /**
 201  * intel_wakeref_unlock: Unlock the wakeref
 202  * @wf: the wakeref
 203  *
 204  * Releases a previously acquired intel_wakeref_lock().
 205  */
 206 static inline void
 207 intel_wakeref_unlock(struct intel_wakeref *wf)
 208         __releases(wf->mutex)
 209 {
 210         mutex_unlock(&wf->mutex);
 211 }
 212
 213 /**
 214  * intel_wakeref_unlock_wait: Wait until the active callback is complete
 215  * @wf: the wakeref
 216  *
 217  * Waits for the active callback (under the @wf->mutex or another CPU) is
 218  * complete.
 219  */
 220 static inline void
 221 intel_wakeref_unlock_wait(struct intel_wakeref *wf)
 222 {
 223         mutex_lock(&wf->mutex);
 224         mutex_unlock(&wf->mutex);
 225         flush_delayed_work(&wf->work);
 226 }
 227
 228 /**
 229  * intel_wakeref_is_active: Query whether the wakeref is currently held
 230  * @wf: the wakeref
 231  *
 232  * Returns: true if the wakeref is currently held.
 233  */
 234 static inline bool
 235 intel_wakeref_is_active(const struct intel_wakeref *wf)
 236 {
 237         return READ_ONCE(wf->wakeref);
 238 }
 239
 240 /**
 241  * __intel_wakeref_defer_park: Defer the current park callback
 242  * @wf: the wakeref
 243  */
 244 static inline void
 245 __intel_wakeref_defer_park(struct intel_wakeref *wf)
 246 {
 247         lockdep_assert_held(&wf->mutex);
 248         INTEL_WAKEREF_BUG_ON(atomic_read(&wf->count));
 249         atomic_set_release(&wf->count, 1);
 250 }
 251
 252 /**
 253  * intel_wakeref_wait_for_idle: Wait until the wakeref is idle
 254  * @wf: the wakeref
 255  *
 256  * Wait for the earlier asynchronous release of the wakeref. Note
 257  * this will wait for any third party as well, so make sure you only wait
 258  * when you have control over the wakeref and trust no one else is acquiring
 259  * it.
 260  *
 261  * Return: 0 on success, error code if killed.
 262  */
 263 int intel_wakeref_wait_for_idle(struct intel_wakeref *wf);
 264
 265 struct intel_wakeref_auto {
 266         struct intel_runtime_pm *rpm;
 267         struct timer_list timer;
 268         intel_wakeref_t wakeref;
 269         spinlock_t lock;
 270         refcount_t count;
 271 };
 272
 273 /**
 274  * intel_wakeref_auto: Delay the runtime-pm autosuspend
 275  * @wf: the wakeref
 276  * @timeout: relative timeout in jiffies
 277  *
 278  * The runtime-pm core uses a suspend delay after the last wakeref
 279  * is released before triggering runtime suspend of the device. That
 280  * delay is configurable via sysfs with little regard to the device
 281  * characteristics. Instead, we want to tune the autosuspend based on our
 282  * HW knowledge. intel_wakeref_auto() delays the sleep by the supplied
 283  * timeout.
 284  *
 285  * Pass @timeout = 0 to cancel a previous autosuspend by executing the
 286  * suspend immediately.
 287  */
 288 void intel_wakeref_auto(struct intel_wakeref_auto *wf, unsigned long timeout);
 289
 290 void intel_wakeref_auto_init(struct intel_wakeref_auto *wf,
 291                              struct intel_runtime_pm *rpm);
 292 void intel_wakeref_auto_fini(struct intel_wakeref_auto *wf);
 293
 294 #endif /* INTEL_WAKEREF_H */