drivers/gpu/drm/ttm/tests/ttm_kunit_helpers.c

   1 // SPDX-License-Identifier: GPL-2.0 AND MIT
   2 /*
   3  * Copyright © 2023 Intel Corporation
   4  */
   5 #include <drm/ttm/ttm_tt.h>
   6
   7 #include "ttm_kunit_helpers.h"
   8
   9 static const struct ttm_place sys_place = {
  10         .fpfn = 0,
  11         .lpfn = 0,
  12         .mem_type = TTM_PL_SYSTEM,
  13         .flags = TTM_PL_FLAG_FALLBACK,
  14 };
  15
  16 static const struct ttm_place mock1_place = {
  17         .fpfn = 0,
  18         .lpfn = 0,
  19         .mem_type = TTM_PL_MOCK1,
  20         .flags = TTM_PL_FLAG_FALLBACK,
  21 };
  22
  23 static const struct ttm_place mock2_place = {
  24         .fpfn = 0,
  25         .lpfn = 0,
  26         .mem_type = TTM_PL_MOCK2,
  27         .flags = TTM_PL_FLAG_FALLBACK,
  28 };
  29
  30 static struct ttm_placement sys_placement = {
  31         .num_placement = 1,
  32         .placement = &sys_place,
  33 };
  34
  35 static struct ttm_placement bad_placement = {
  36         .num_placement = 1,
  37         .placement = &mock1_place,
  38 };
  39
  40 static struct ttm_placement mock_placement = {
  41         .num_placement = 1,
  42         .placement = &mock2_place,
  43 };
  44
  45 static struct ttm_tt *ttm_tt_simple_create(struct ttm_buffer_object *bo, u32 page_flags)
  46 {
  47         struct ttm_tt *tt;
  48
  49         tt = kzalloc(sizeof(*tt), GFP_KERNEL);
  50         ttm_tt_init(tt, bo, page_flags, ttm_cached, 0);
  51
  52         return tt;
  53 }
  54
  55 static void ttm_tt_simple_destroy(struct ttm_device *bdev, struct ttm_tt *ttm)
  56 {
  57         kfree(ttm);
  58 }
  59
  60 static int mock_move(struct ttm_buffer_object *bo, bool evict,
  61                      struct ttm_operation_ctx *ctx,
  62                      struct ttm_resource *new_mem,
  63                      struct ttm_place *hop)
  64 {
  65         struct ttm_resource *old_mem = bo->resource;
  66
  67         if (!old_mem || (old_mem->mem_type == TTM_PL_SYSTEM && !bo->ttm)) {
  68                 ttm_bo_move_null(bo, new_mem);
  69                 return 0;
  70         }
  71
  72         if (bo->resource->mem_type == TTM_PL_VRAM &&
  73             new_mem->mem_type == TTM_PL_SYSTEM) {
  74                 hop->mem_type = TTM_PL_TT;
  75                 hop->flags = TTM_PL_FLAG_TEMPORARY;
  76                 hop->fpfn = 0;
  77                 hop->lpfn = 0;
  78                 return -EMULTIHOP;
  79         }
  80
  81         if ((old_mem->mem_type == TTM_PL_SYSTEM &&
  82              new_mem->mem_type == TTM_PL_TT) ||
  83             (old_mem->mem_type == TTM_PL_TT &&
  84              new_mem->mem_type == TTM_PL_SYSTEM)) {
  85                 ttm_bo_move_null(bo, new_mem);
  86                 return 0;
  87         }
  88
  89         return ttm_bo_move_memcpy(bo, ctx, new_mem);
  90 }
  91
  92 static void mock_evict_flags(struct ttm_buffer_object *bo,
  93                              struct ttm_placement *placement)
  94 {
  95         switch (bo->resource->mem_type) {
  96         case TTM_PL_VRAM:
  97         case TTM_PL_SYSTEM:
  98                 *placement = sys_placement;
  99                 break;
 100         case TTM_PL_TT:
 101                 *placement = mock_placement;
 102                 break;
 103         case TTM_PL_MOCK1:
 104                 /* Purge objects coming from this domain */
 105                 break;
 106         }
 107 }
 108
 109 static void bad_evict_flags(struct ttm_buffer_object *bo,
 110                             struct ttm_placement *placement)
 111 {
 112         *placement = bad_placement;
 113 }
 114
 115 static int ttm_device_kunit_init_with_funcs(struct ttm_test_devices *priv,
 116                                             struct ttm_device *ttm,
 117                                             bool use_dma_alloc,
 118                                             bool use_dma32,
 119                                             struct ttm_device_funcs *funcs)
 120 {
 121         struct drm_device *drm = priv->drm;
 122         int err;
 123
 124         err = ttm_device_init(ttm, funcs, drm->dev,
 125                               drm->anon_inode->i_mapping,
 126                               drm->vma_offset_manager,
 127                               use_dma_alloc, use_dma32);
 128
 129         return err;
 130 }
 131
 132 struct ttm_device_funcs ttm_dev_funcs = {
 133         .ttm_tt_create = ttm_tt_simple_create,
 134         .ttm_tt_destroy = ttm_tt_simple_destroy,
 135         .move = mock_move,
 136         .eviction_valuable = ttm_bo_eviction_valuable,
 137         .evict_flags = mock_evict_flags,
 138 };
 139 EXPORT_SYMBOL_GPL(ttm_dev_funcs);
 140
 141 int ttm_device_kunit_init(struct ttm_test_devices *priv,
 142                           struct ttm_device *ttm,
 143                           bool use_dma_alloc,
 144                           bool use_dma32)
 145 {
 146         return ttm_device_kunit_init_with_funcs(priv, ttm, use_dma_alloc,
 147                                                 use_dma32, &ttm_dev_funcs);
 148 }
 149 EXPORT_SYMBOL_GPL(ttm_device_kunit_init);
 150
 151 struct ttm_device_funcs ttm_dev_funcs_bad_evict = {
 152         .ttm_tt_create = ttm_tt_simple_create,
 153         .ttm_tt_destroy = ttm_tt_simple_destroy,
 154         .move = mock_move,
 155         .eviction_valuable = ttm_bo_eviction_valuable,
 156         .evict_flags = bad_evict_flags,
 157 };
 158 EXPORT_SYMBOL_GPL(ttm_dev_funcs_bad_evict);
 159
 160 int ttm_device_kunit_init_bad_evict(struct ttm_test_devices *priv,
 161                                     struct ttm_device *ttm,
 162                                     bool use_dma_alloc,
 163                                     bool use_dma32)
 164 {
 165         return ttm_device_kunit_init_with_funcs(priv, ttm, use_dma_alloc,
 166                                                 use_dma32, &ttm_dev_funcs_bad_evict);
 167 }
 168 EXPORT_SYMBOL_GPL(ttm_device_kunit_init_bad_evict);
 169
 170 struct ttm_buffer_object *ttm_bo_kunit_init(struct kunit *test,
 171                                             struct ttm_test_devices *devs,
 172                                             size_t size,
 173                                             struct dma_resv *obj)
 174 {
 175         struct drm_gem_object gem_obj = { };
 176         struct ttm_buffer_object *bo;
 177         int err;
 178
 179         bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL);
 180         KUNIT_ASSERT_NOT_NULL(test, bo);
 181
 182         bo->base = gem_obj;
 183
 184         if (obj)
 185                 bo->base.resv = obj;
 186
 187         err = drm_gem_object_init(devs->drm, &bo->base, size);
 188         KUNIT_ASSERT_EQ(test, err, 0);
 189
 190         bo->bdev = devs->ttm_dev;
 191         bo->destroy = dummy_ttm_bo_destroy;
 192
 193         kref_init(&bo->kref);
 194
 195         return bo;
 196 }
 197 EXPORT_SYMBOL_GPL(ttm_bo_kunit_init);
 198
 199 struct ttm_place *ttm_place_kunit_init(struct kunit *test, u32 mem_type, u32 flags)
 200 {
 201         struct ttm_place *place;
 202
 203         place = kunit_kzalloc(test, sizeof(*place), GFP_KERNEL);
 204         KUNIT_ASSERT_NOT_NULL(test, place);
 205
 206         place->mem_type = mem_type;
 207         place->flags = flags;
 208
 209         return place;
 210 }
 211 EXPORT_SYMBOL_GPL(ttm_place_kunit_init);
 212
 213 void dummy_ttm_bo_destroy(struct ttm_buffer_object *bo)
 214 {
 215         drm_gem_object_release(&bo->base);
 216 }
 217 EXPORT_SYMBOL_GPL(dummy_ttm_bo_destroy);
 218
 219 struct ttm_test_devices *ttm_test_devices_basic(struct kunit *test)
 220 {
 221         struct ttm_test_devices *devs;
 222
 223         devs = kunit_kzalloc(test, sizeof(*devs), GFP_KERNEL);
 224         KUNIT_ASSERT_NOT_NULL(test, devs);
 225
 226         devs->dev = drm_kunit_helper_alloc_device(test);
 227         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, devs->dev);
 228
 229         /* Set mask for alloc_coherent mappings to enable ttm_pool_alloc testing */
 230         devs->dev->coherent_dma_mask = -1;
 231
 232         devs->drm = __drm_kunit_helper_alloc_drm_device(test, devs->dev,
 233                                                         sizeof(*devs->drm), 0,
 234                                                         DRIVER_GEM);
 235         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, devs->drm);
 236
 237         return devs;
 238 }
 239 EXPORT_SYMBOL_GPL(ttm_test_devices_basic);
 240
 241 struct ttm_test_devices *ttm_test_devices_all(struct kunit *test)
 242 {
 243         struct ttm_test_devices *devs;
 244         struct ttm_device *ttm_dev;
 245         int err;
 246
 247         devs = ttm_test_devices_basic(test);
 248
 249         ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL);
 250         KUNIT_ASSERT_NOT_NULL(test, ttm_dev);
 251
 252         err = ttm_device_kunit_init(devs, ttm_dev, false, false);
 253         KUNIT_ASSERT_EQ(test, err, 0);
 254
 255         devs->ttm_dev = ttm_dev;
 256
 257         return devs;
 258 }
 259 EXPORT_SYMBOL_GPL(ttm_test_devices_all);
 260
 261 void ttm_test_devices_put(struct kunit *test, struct ttm_test_devices *devs)
 262 {
 263         if (devs->ttm_dev)
 264                 ttm_device_fini(devs->ttm_dev);
 265
 266         drm_kunit_helper_free_device(test, devs->dev);
 267 }
 268 EXPORT_SYMBOL_GPL(ttm_test_devices_put);
 269
 270 int ttm_test_devices_init(struct kunit *test)
 271 {
 272         struct ttm_test_devices *priv;
 273
 274         priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
 275         KUNIT_ASSERT_NOT_NULL(test, priv);
 276
 277         priv = ttm_test_devices_basic(test);
 278         test->priv = priv;
 279
 280         return 0;
 281 }
 282 EXPORT_SYMBOL_GPL(ttm_test_devices_init);
 283
 284 int ttm_test_devices_all_init(struct kunit *test)
 285 {
 286         struct ttm_test_devices *priv;
 287
 288         priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
 289         KUNIT_ASSERT_NOT_NULL(test, priv);
 290
 291         priv = ttm_test_devices_all(test);
 292         test->priv = priv;
 293
 294         return 0;
 295 }
 296 EXPORT_SYMBOL_GPL(ttm_test_devices_all_init);
 297
 298 void ttm_test_devices_fini(struct kunit *test)
 299 {
 300         ttm_test_devices_put(test, test->priv);
 301 }
 302 EXPORT_SYMBOL_GPL(ttm_test_devices_fini);
 303
 304 MODULE_DESCRIPTION("TTM KUnit test helper functions");
 305 MODULE_LICENSE("GPL and additional rights");