drivers/gpu/drm/i915/gt/intel_engine_pm.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright © 2019 Intel Corporation
   5  */
   6
   7 #include "i915_drv.h"
   8
   9 #include "intel_engine.h"
  10 #include "intel_engine_pm.h"
  11 #include "intel_gt_pm.h"
  12
  13 static int __engine_unpark(struct intel_wakeref *wf)
  14 {
  15         struct intel_engine_cs *engine =
  16                 container_of(wf, typeof(*engine), wakeref);
  17         void *map;
  18
  19         GEM_TRACE("%s\n", engine->name);
  20
  21         intel_gt_pm_get(engine->i915);
  22
  23         /* Pin the default state for fast resets from atomic context. */
  24         map = NULL;
  25         if (engine->default_state)
  26                 map = i915_gem_object_pin_map(engine->default_state,
  27                                               I915_MAP_WB);
  28         if (!IS_ERR_OR_NULL(map))
  29                 engine->pinned_default_state = map;
  30
  31         if (engine->unpark)
  32                 engine->unpark(engine);
  33
  34         intel_engine_init_hangcheck(engine);
  35         return 0;
  36 }
  37
  38 void intel_engine_pm_get(struct intel_engine_cs *engine)
  39 {
  40         intel_wakeref_get(&engine->i915->runtime_pm, &engine->wakeref, __engine_unpark);
  41 }
  42
  43 void intel_engine_park(struct intel_engine_cs *engine)
  44 {
  45         /*
  46          * We are committed now to parking this engine, make sure there
  47          * will be no more interrupts arriving later and the engine
  48          * is truly idle.
  49          */
  50         if (wait_for(intel_engine_is_idle(engine), 10)) {
  51                 struct drm_printer p = drm_debug_printer(__func__);
  52
  53                 dev_err(engine->i915->drm.dev,
  54                         "%s is not idle before parking\n",
  55                         engine->name);
  56                 intel_engine_dump(engine, &p, NULL);
  57         }
  58 }
  59
  60 static bool switch_to_kernel_context(struct intel_engine_cs *engine)
  61 {
  62         struct i915_request *rq;
  63
  64         /* Already inside the kernel context, safe to power down. */
  65         if (engine->wakeref_serial == engine->serial)
  66                 return true;
  67
  68         /* GPU is pointing to the void, as good as in the kernel context. */
  69         if (i915_reset_failed(engine->i915))
  70                 return true;
  71
  72         /*
  73          * Note, we do this without taking the timeline->mutex. We cannot
  74          * as we may be called while retiring the kernel context and so
  75          * already underneath the timeline->mutex. Instead we rely on the
  76          * exclusive property of the __engine_park that prevents anyone
  77          * else from creating a request on this engine. This also requires
  78          * that the ring is empty and we avoid any waits while constructing
  79          * the context, as they assume protection by the timeline->mutex.
  80          * This should hold true as we can only park the engine after
  81          * retiring the last request, thus all rings should be empty and
  82          * all timelines idle.
  83          */
  84         rq = __i915_request_create(engine->kernel_context, GFP_NOWAIT);
  85         if (IS_ERR(rq))
  86                 /* Context switch failed, hope for the best! Maybe reset? */
  87                 return true;
  88
  89         /* Check again on the next retirement. */
  90         engine->wakeref_serial = engine->serial + 1;
  91
  92         i915_request_add_barriers(rq);
  93         __i915_request_commit(rq);
  94
  95         return false;
  96 }
  97
  98 static int __engine_park(struct intel_wakeref *wf)
  99 {
 100         struct intel_engine_cs *engine =
 101                 container_of(wf, typeof(*engine), wakeref);
 102
 103         engine->saturated = 0;
 104
 105         /*
 106          * If one and only one request is completed between pm events,
 107          * we know that we are inside the kernel context and it is
 108          * safe to power down. (We are paranoid in case that runtime
 109          * suspend causes corruption to the active context image, and
 110          * want to avoid that impacting userspace.)
 111          */
 112         if (!switch_to_kernel_context(engine))
 113                 return -EBUSY;
 114
 115         GEM_TRACE("%s\n", engine->name);
 116
 117         intel_engine_disarm_breadcrumbs(engine);
 118
 119         /* Must be reset upon idling, or we may miss the busy wakeup. */
 120         GEM_BUG_ON(engine->execlists.queue_priority_hint != INT_MIN);
 121
 122         if (engine->park)
 123                 engine->park(engine);
 124
 125         if (engine->pinned_default_state) {
 126                 i915_gem_object_unpin_map(engine->default_state);
 127                 engine->pinned_default_state = NULL;
 128         }
 129
 130         engine->execlists.no_priolist = false;
 131
 132         intel_gt_pm_put(engine->i915);
 133         return 0;
 134 }
 135
 136 void intel_engine_pm_put(struct intel_engine_cs *engine)
 137 {
 138         intel_wakeref_put(&engine->i915->runtime_pm, &engine->wakeref, __engine_park);
 139 }
 140
 141 void intel_engine_init__pm(struct intel_engine_cs *engine)
 142 {
 143         intel_wakeref_init(&engine->wakeref);
 144 }
 145
 146 int intel_engines_resume(struct drm_i915_private *i915)
 147 {
 148         struct intel_engine_cs *engine;
 149         enum intel_engine_id id;
 150         int err = 0;
 151
 152         intel_gt_pm_get(i915);
 153         for_each_engine(engine, i915, id) {
 154                 intel_engine_pm_get(engine);
 155                 engine->serial++; /* kernel context lost */
 156                 err = engine->resume(engine);
 157                 intel_engine_pm_put(engine);
 158                 if (err) {
 159                         dev_err(i915->drm.dev,
 160                                 "Failed to restart %s (%d)\n",
 161                                 engine->name, err);
 162                         break;
 163                 }
 164         }
 165         intel_gt_pm_put(i915);
 166
 167         return err;
 168 }