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 struct ttm_tt *ttm_tt_simple_create(struct ttm_buffer_object *bo,
  10                                            uint32_t page_flags)
  11 {
  12         struct ttm_tt *tt;
  13
  14         tt = kzalloc(sizeof(*tt), GFP_KERNEL);
  15         ttm_tt_init(tt, bo, page_flags, ttm_cached, 0);
  16
  17         return tt;
  18 }
  19
  20 static void ttm_tt_simple_destroy(struct ttm_device *bdev, struct ttm_tt *ttm)
  21 {
  22         kfree(ttm);
  23 }
  24
  25 static void dummy_ttm_bo_destroy(struct ttm_buffer_object *bo)
  26 {
  27 }
  28
  29 struct ttm_device_funcs ttm_dev_funcs = {
  30         .ttm_tt_create = ttm_tt_simple_create,
  31         .ttm_tt_destroy = ttm_tt_simple_destroy,
  32 };
  33 EXPORT_SYMBOL_GPL(ttm_dev_funcs);
  34
  35 int ttm_device_kunit_init(struct ttm_test_devices *priv,
  36                           struct ttm_device *ttm,
  37                           bool use_dma_alloc,
  38                           bool use_dma32)
  39 {
  40         struct drm_device *drm = priv->drm;
  41         int err;
  42
  43         err = ttm_device_init(ttm, &ttm_dev_funcs, drm->dev,
  44                               drm->anon_inode->i_mapping,
  45                               drm->vma_offset_manager,
  46                               use_dma_alloc, use_dma32);
  47
  48         return err;
  49 }
  50 EXPORT_SYMBOL_GPL(ttm_device_kunit_init);
  51
  52 struct ttm_buffer_object *ttm_bo_kunit_init(struct kunit *test,
  53                                             struct ttm_test_devices *devs,
  54                                             size_t size)
  55 {
  56         struct drm_gem_object gem_obj = { };
  57         struct ttm_buffer_object *bo;
  58         int err;
  59
  60         bo = kunit_kzalloc(test, sizeof(*bo), GFP_KERNEL);
  61         KUNIT_ASSERT_NOT_NULL(test, bo);
  62
  63         bo->base = gem_obj;
  64         err = drm_gem_object_init(devs->drm, &bo->base, size);
  65         KUNIT_ASSERT_EQ(test, err, 0);
  66
  67         bo->bdev = devs->ttm_dev;
  68         bo->destroy = dummy_ttm_bo_destroy;
  69
  70         kref_init(&bo->kref);
  71
  72         return bo;
  73 }
  74 EXPORT_SYMBOL_GPL(ttm_bo_kunit_init);
  75
  76 struct ttm_place *ttm_place_kunit_init(struct kunit *test,
  77                                        uint32_t mem_type, uint32_t flags)
  78 {
  79         struct ttm_place *place;
  80
  81         place = kunit_kzalloc(test, sizeof(*place), GFP_KERNEL);
  82         KUNIT_ASSERT_NOT_NULL(test, place);
  83
  84         place->mem_type = mem_type;
  85         place->flags = flags;
  86
  87         return place;
  88 }
  89 EXPORT_SYMBOL_GPL(ttm_place_kunit_init);
  90
  91 struct ttm_test_devices *ttm_test_devices_basic(struct kunit *test)
  92 {
  93         struct ttm_test_devices *devs;
  94
  95         devs = kunit_kzalloc(test, sizeof(*devs), GFP_KERNEL);
  96         KUNIT_ASSERT_NOT_NULL(test, devs);
  97
  98         devs->dev = drm_kunit_helper_alloc_device(test);
  99         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, devs->dev);
 100
 101         devs->drm = __drm_kunit_helper_alloc_drm_device(test, devs->dev,
 102                                                         sizeof(*devs->drm), 0,
 103                                                         DRIVER_GEM);
 104         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, devs->drm);
 105
 106         return devs;
 107 }
 108 EXPORT_SYMBOL_GPL(ttm_test_devices_basic);
 109
 110 struct ttm_test_devices *ttm_test_devices_all(struct kunit *test)
 111 {
 112         struct ttm_test_devices *devs;
 113         struct ttm_device *ttm_dev;
 114         int err;
 115
 116         devs = ttm_test_devices_basic(test);
 117
 118         ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL);
 119         KUNIT_ASSERT_NOT_NULL(test, ttm_dev);
 120
 121         err = ttm_device_kunit_init(devs, ttm_dev, false, false);
 122         KUNIT_ASSERT_EQ(test, err, 0);
 123
 124         devs->ttm_dev = ttm_dev;
 125
 126         return devs;
 127 }
 128 EXPORT_SYMBOL_GPL(ttm_test_devices_all);
 129
 130 void ttm_test_devices_put(struct kunit *test, struct ttm_test_devices *devs)
 131 {
 132         if (devs->ttm_dev)
 133                 ttm_device_fini(devs->ttm_dev);
 134
 135         drm_kunit_helper_free_device(test, devs->dev);
 136 }
 137 EXPORT_SYMBOL_GPL(ttm_test_devices_put);
 138
 139 int ttm_test_devices_init(struct kunit *test)
 140 {
 141         struct ttm_test_devices *priv;
 142
 143         priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
 144         KUNIT_ASSERT_NOT_NULL(test, priv);
 145
 146         priv = ttm_test_devices_basic(test);
 147         test->priv = priv;
 148
 149         return 0;
 150 }
 151 EXPORT_SYMBOL_GPL(ttm_test_devices_init);
 152
 153 void ttm_test_devices_fini(struct kunit *test)
 154 {
 155         ttm_test_devices_put(test, test->priv);
 156 }
 157 EXPORT_SYMBOL_GPL(ttm_test_devices_fini);
 158
 159 MODULE_LICENSE("GPL");