struct intel_engine_cs *engine;
        struct i915_gem_context **ctx;
        enum intel_engine_id id;
-       intel_wakeref_t wakeref;
        struct igt_live_test t;
        struct drm_file *file;
        unsigned long n;
                return PTR_ERR(file);
 
        mutex_lock(&i915->drm.struct_mutex);
-       wakeref = intel_runtime_pm_get(&i915->runtime_pm);
 
        ctx = kcalloc(nctx, sizeof(*ctx), GFP_KERNEL);
        if (!ctx) {
        }
 
 out_unlock:
-       intel_runtime_pm_put(&i915->runtime_pm, wakeref);
        mutex_unlock(&i915->drm.struct_mutex);
        mock_file_free(i915, file);
        return err;
                dw = 0;
                while (!time_after(jiffies, end_time)) {
                        struct i915_gem_context *ctx;
-                       intel_wakeref_t wakeref;
 
                        ctx = live_context(i915, file);
                        if (IS_ERR(ctx)) {
                                }
                        }
 
-                       with_intel_runtime_pm(&i915->runtime_pm, wakeref)
-                               err = gpu_fill(obj, ctx, engine, dw);
+                       err = gpu_fill(obj, ctx, engine, dw);
                        if (err) {
                                pr_err("Failed to fill dword %lu [%lu/%lu] with gpu (%s) in ctx %u [full-ppgtt? %s], err=%d\n",
                                       ndwords, dw, max_dwords(obj),
                ncontexts = 0;
                while (!time_after(jiffies, end_time)) {
                        struct i915_gem_context *ctx;
-                       intel_wakeref_t wakeref;
 
                        ctx = kernel_context(i915);
                        if (IS_ERR(ctx)) {
                                }
                        }
 
-                       err = 0;
-                       with_intel_runtime_pm(&i915->runtime_pm, wakeref)
-                               err = gpu_fill(obj, ctx, engine, dw);
+                       err = gpu_fill(obj, ctx, engine, dw);
                        if (err) {
                                pr_err("Failed to fill dword %lu [%lu/%lu] with gpu (%s) in ctx %u [full-ppgtt? %s], err=%d\n",
                                       ndwords, dw, max_dwords(obj),
        struct i915_gem_context *ctx;
        struct intel_context *ce;
        struct intel_sseu pg_sseu;
-       intel_wakeref_t wakeref;
        struct drm_file *file;
        int ret;
 
                goto out_unlock;
        }
 
-       wakeref = intel_runtime_pm_get(&i915->runtime_pm);
-
        ce = i915_gem_context_get_engine(ctx, RCS0);
        if (IS_ERR(ce)) {
                ret = PTR_ERR(ce);
-               goto out_rpm;
+               goto out_put;
        }
 
        ret = intel_context_pin(ce);
        intel_context_unpin(ce);
 out_context:
        intel_context_put(ce);
-out_rpm:
-       intel_runtime_pm_put(&i915->runtime_pm, wakeref);
+out_put:
        i915_gem_object_put(obj);
 
 out_unlock:
                unsigned int id;
 
                for_each_engine(engine, i915, id) {
-                       intel_wakeref_t wakeref;
-
                        if (!intel_engine_can_store_dword(engine))
                                continue;
 
                                        i915_gem_object_set_readonly(obj);
                        }
 
-                       err = 0;
-                       with_intel_runtime_pm(&i915->runtime_pm, wakeref)
-                               err = gpu_fill(obj, ctx, engine, dw);
+                       err = gpu_fill(obj, ctx, engine, dw);
                        if (err) {
                                pr_err("Failed to fill dword %lu [%lu/%lu] with gpu (%s) in ctx %u [full-ppgtt? %s], err=%d\n",
                                       ndwords, dw, max_dwords(obj),
        struct drm_i915_private *i915 = arg;
        struct i915_gem_context *ctx_a, *ctx_b;
        struct intel_engine_cs *engine;
-       intel_wakeref_t wakeref;
        struct igt_live_test t;
        struct drm_file *file;
        I915_RND_STATE(prng);
        GEM_BUG_ON(ctx_b->vm->total != vm_total);
        vm_total -= I915_GTT_PAGE_SIZE;
 
-       wakeref = intel_runtime_pm_get(&i915->runtime_pm);
-
        count = 0;
        for_each_engine(engine, i915, id) {
                IGT_TIMEOUT(end_time);
                                err = read_from_scratch(ctx_b, engine,
                                                        offset, &value);
                        if (err)
-                               goto out_rpm;
+                               goto out_unlock;
 
                        if (value) {
                                pr_err("%s: Read %08x from scratch (offset 0x%08x_%08x), after %lu reads!\n",
                                       lower_32_bits(offset),
                                       this);
                                err = -EINVAL;
-                               goto out_rpm;
+                               goto out_unlock;
                        }
 
                        this++;
        pr_info("Checked %lu scratch offsets across %d engines\n",
                count, RUNTIME_INFO(i915)->num_engines);
 
-out_rpm:
-       intel_runtime_pm_put(&i915->runtime_pm, wakeref);
 out_unlock:
        if (igt_live_test_end(&t))
                err = -EIO;