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