drivers/gpu/drm/i915/selftests/i915_gem.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright © 2018 Intel Corporation
   5  */
   6
   7 #include <linux/random.h>
   8
   9 #include "gem/selftests/igt_gem_utils.h"
  10 #include "gem/selftests/mock_context.h"
  11 #include "gt/intel_gt.h"
  12 #include "gt/intel_gt_pm.h"
  13
  14 #include "i915_selftest.h"
  15
  16 #include "igt_flush_test.h"
  17 #include "mock_drm.h"
  18
  19 static int switch_to_context(struct i915_gem_context *ctx)
  20 {
  21         struct i915_gem_engines_iter it;
  22         struct intel_context *ce;
  23         int err = 0;
  24
  25         for_each_gem_engine(ce, i915_gem_context_lock_engines(ctx), it) {
  26                 struct i915_request *rq;
  27
  28                 rq = intel_context_create_request(ce);
  29                 if (IS_ERR(rq)) {
  30                         err = PTR_ERR(rq);
  31                         break;
  32                 }
  33
  34                 i915_request_add(rq);
  35         }
  36         i915_gem_context_unlock_engines(ctx);
  37
  38         return err;
  39 }
  40
  41 static void trash_stolen(struct drm_i915_private *i915)
  42 {
  43         struct i915_ggtt *ggtt = &i915->ggtt;
  44         const u64 slot = ggtt->error_capture.start;
  45         const resource_size_t size = resource_size(&i915->dsm);
  46         unsigned long page;
  47         u32 prng = 0x12345678;
  48
  49         /* XXX: fsck. needs some more thought... */
  50         if (!i915_ggtt_has_aperture(ggtt))
  51                 return;
  52
  53         for (page = 0; page < size; page += PAGE_SIZE) {
  54                 const dma_addr_t dma = i915->dsm.start + page;
  55                 u32 __iomem *s;
  56                 int x;
  57
  58                 ggtt->vm.insert_page(&ggtt->vm, dma, slot, I915_CACHE_NONE, 0);
  59
  60                 s = io_mapping_map_atomic_wc(&ggtt->iomap, slot);
  61                 for (x = 0; x < PAGE_SIZE / sizeof(u32); x++) {
  62                         prng = next_pseudo_random32(prng);
  63                         iowrite32(prng, &s[x]);
  64                 }
  65                 io_mapping_unmap_atomic(s);
  66         }
  67
  68         ggtt->vm.clear_range(&ggtt->vm, slot, PAGE_SIZE);
  69 }
  70
  71 static void simulate_hibernate(struct drm_i915_private *i915)
  72 {
  73         intel_wakeref_t wakeref;
  74
  75         wakeref = intel_runtime_pm_get(&i915->runtime_pm);
  76
  77         /*
  78          * As a final sting in the tail, invalidate stolen. Under a real S4,
  79          * stolen is lost and needs to be refilled on resume. However, under
  80          * CI we merely do S4-device testing (as full S4 is too unreliable
  81          * for automated testing across a cluster), so to simulate the effect
  82          * of stolen being trashed across S4, we trash it ourselves.
  83          */
  84         trash_stolen(i915);
  85
  86         intel_runtime_pm_put(&i915->runtime_pm, wakeref);
  87 }
  88
  89 static int pm_prepare(struct drm_i915_private *i915)
  90 {
  91         i915_gem_suspend(i915);
  92
  93         return 0;
  94 }
  95
  96 static void pm_suspend(struct drm_i915_private *i915)
  97 {
  98         intel_wakeref_t wakeref;
  99
 100         with_intel_runtime_pm(&i915->runtime_pm, wakeref) {
 101                 i915_gem_suspend_gtt_mappings(i915);
 102                 i915_gem_suspend_late(i915);
 103         }
 104 }
 105
 106 static void pm_hibernate(struct drm_i915_private *i915)
 107 {
 108         intel_wakeref_t wakeref;
 109
 110         with_intel_runtime_pm(&i915->runtime_pm, wakeref) {
 111                 i915_gem_suspend_gtt_mappings(i915);
 112
 113                 i915_gem_freeze(i915);
 114                 i915_gem_freeze_late(i915);
 115         }
 116 }
 117
 118 static void pm_resume(struct drm_i915_private *i915)
 119 {
 120         intel_wakeref_t wakeref;
 121
 122         /*
 123          * Both suspend and hibernate follow the same wakeup path and assume
 124          * that runtime-pm just works.
 125          */
 126         with_intel_runtime_pm(&i915->runtime_pm, wakeref) {
 127                 i915_gem_restore_gtt_mappings(i915);
 128                 i915_gem_restore_fences(&i915->ggtt);
 129
 130                 i915_gem_resume(i915);
 131         }
 132 }
 133
 134 static int igt_gem_suspend(void *arg)
 135 {
 136         struct drm_i915_private *i915 = arg;
 137         struct i915_gem_context *ctx;
 138         struct file *file;
 139         int err;
 140
 141         file = mock_file(i915);
 142         if (IS_ERR(file))
 143                 return PTR_ERR(file);
 144
 145         err = -ENOMEM;
 146         ctx = live_context(i915, file);
 147         if (!IS_ERR(ctx))
 148                 err = switch_to_context(ctx);
 149         if (err)
 150                 goto out;
 151
 152         err = pm_prepare(i915);
 153         if (err)
 154                 goto out;
 155
 156         pm_suspend(i915);
 157
 158         /* Here be dragons! Note that with S3RST any S3 may become S4! */
 159         simulate_hibernate(i915);
 160
 161         pm_resume(i915);
 162
 163         err = switch_to_context(ctx);
 164 out:
 165         fput(file);
 166         return err;
 167 }
 168
 169 static int igt_gem_hibernate(void *arg)
 170 {
 171         struct drm_i915_private *i915 = arg;
 172         struct i915_gem_context *ctx;
 173         struct file *file;
 174         int err;
 175
 176         file = mock_file(i915);
 177         if (IS_ERR(file))
 178                 return PTR_ERR(file);
 179
 180         err = -ENOMEM;
 181         ctx = live_context(i915, file);
 182         if (!IS_ERR(ctx))
 183                 err = switch_to_context(ctx);
 184         if (err)
 185                 goto out;
 186
 187         err = pm_prepare(i915);
 188         if (err)
 189                 goto out;
 190
 191         pm_hibernate(i915);
 192
 193         /* Here be dragons! */
 194         simulate_hibernate(i915);
 195
 196         pm_resume(i915);
 197
 198         err = switch_to_context(ctx);
 199 out:
 200         fput(file);
 201         return err;
 202 }
 203
 204 int i915_gem_live_selftests(struct drm_i915_private *i915)
 205 {
 206         static const struct i915_subtest tests[] = {
 207                 SUBTEST(igt_gem_suspend),
 208                 SUBTEST(igt_gem_hibernate),
 209         };
 210
 211         if (intel_gt_is_wedged(&i915->gt))
 212                 return 0;
 213
 214         return i915_live_subtests(tests, i915);
 215 }