1// SPDX-License-Identifier: GPL-2.0 AND MIT
  2/*
  3 * Copyright © 2023 Intel Corporation
  4 */
  5#include <drm/ttm/ttm_resource.h>
  6#include <drm/ttm/ttm_device.h>
  7#include <drm/ttm/ttm_placement.h>
  8
  9#include "ttm_kunit_helpers.h"
 10
 11struct ttm_device_test_case {
 12	const char *description;
 13	bool use_dma_alloc;
 14	bool use_dma32;
 15	bool pools_init_expected;
 16};
 17
 18static void ttm_device_init_basic(struct kunit *test)
 19{
 20	struct ttm_test_devices *priv = test->priv;
 21	struct ttm_device *ttm_dev;
 22	struct ttm_resource_manager *ttm_sys_man;
 23	int err;
 24
 25	ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL);
 26	KUNIT_ASSERT_NOT_NULL(test, ttm_dev);
 27
 28	err = ttm_device_kunit_init(priv, ttm_dev, false, false);
 29	KUNIT_ASSERT_EQ(test, err, 0);
 30
 31	KUNIT_EXPECT_PTR_EQ(test, ttm_dev->funcs, &ttm_dev_funcs);
 32	KUNIT_ASSERT_NOT_NULL(test, ttm_dev->wq);
 33	KUNIT_ASSERT_NOT_NULL(test, ttm_dev->man_drv[TTM_PL_SYSTEM]);
 34
 35	ttm_sys_man = &ttm_dev->sysman;
 36	KUNIT_ASSERT_NOT_NULL(test, ttm_sys_man);
 37	KUNIT_EXPECT_TRUE(test, ttm_sys_man->use_tt);
 38	KUNIT_EXPECT_TRUE(test, ttm_sys_man->use_type);
 39	KUNIT_ASSERT_NOT_NULL(test, ttm_sys_man->func);
 40
 41	KUNIT_EXPECT_PTR_EQ(test, ttm_dev->dev_mapping,
 42			    priv->drm->anon_inode->i_mapping);
 43
 44	ttm_device_fini(ttm_dev);
 45}
 46
 47static void ttm_device_init_multiple(struct kunit *test)
 48{
 49	struct ttm_test_devices *priv = test->priv;
 50	struct ttm_device *ttm_devs;
 51	unsigned int i, num_dev = 3;
 52	int err;
 53
 54	ttm_devs = kunit_kcalloc(test, num_dev, sizeof(*ttm_devs), GFP_KERNEL);
 55	KUNIT_ASSERT_NOT_NULL(test, ttm_devs);
 56
 57	for (i = 0; i < num_dev; i++) {
 58		err = ttm_device_kunit_init(priv, &ttm_devs[i], false, false);
 59		KUNIT_ASSERT_EQ(test, err, 0);
 60
 61		KUNIT_EXPECT_PTR_EQ(test, ttm_devs[i].dev_mapping,
 62				    priv->drm->anon_inode->i_mapping);
 63		KUNIT_ASSERT_NOT_NULL(test, ttm_devs[i].wq);
 64		KUNIT_EXPECT_PTR_EQ(test, ttm_devs[i].funcs, &ttm_dev_funcs);
 65		KUNIT_ASSERT_NOT_NULL(test, ttm_devs[i].man_drv[TTM_PL_SYSTEM]);
 66	}
 67
 68	KUNIT_ASSERT_EQ(test, list_count_nodes(&ttm_devs[0].device_list), num_dev);
 69
 70	for (i = 0; i < num_dev; i++)
 71		ttm_device_fini(&ttm_devs[i]);
 72}
 73
 74static void ttm_device_fini_basic(struct kunit *test)
 75{
 76	struct ttm_test_devices *priv = test->priv;
 77	struct ttm_device *ttm_dev;
 78	struct ttm_resource_manager *man;
 79	int err;
 80
 81	ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL);
 82	KUNIT_ASSERT_NOT_NULL(test, ttm_dev);
 83
 84	err = ttm_device_kunit_init(priv, ttm_dev, false, false);
 85	KUNIT_ASSERT_EQ(test, err, 0);
 86
 87	man = ttm_manager_type(ttm_dev, TTM_PL_SYSTEM);
 88	KUNIT_ASSERT_NOT_NULL(test, man);
 89
 90	ttm_device_fini(ttm_dev);
 91
 92	KUNIT_ASSERT_FALSE(test, man->use_type);
 93	KUNIT_ASSERT_TRUE(test, list_empty(&man->lru[0]));
 94	KUNIT_ASSERT_NULL(test, ttm_dev->man_drv[TTM_PL_SYSTEM]);
 95}
 96
 97static void ttm_device_init_no_vma_man(struct kunit *test)
 98{
 99	struct ttm_test_devices *priv = test->priv;
100	struct drm_device *drm = priv->drm;
101	struct ttm_device *ttm_dev;
102	struct drm_vma_offset_manager *vma_man;
103	int err;
104
105	ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL);
106	KUNIT_ASSERT_NOT_NULL(test, ttm_dev);
107
108	/* Let's pretend there's no VMA manager allocated */
109	vma_man = drm->vma_offset_manager;
110	drm->vma_offset_manager = NULL;
111
112	err = ttm_device_kunit_init(priv, ttm_dev, false, false);
113	KUNIT_EXPECT_EQ(test, err, -EINVAL);
114
115	/* Bring the manager back for a graceful cleanup */
116	drm->vma_offset_manager = vma_man;
117}
118
119static const struct ttm_device_test_case ttm_device_cases[] = {
120	{
121		.description = "No DMA allocations, no DMA32 required",
122		.use_dma_alloc = false,
123		.use_dma32 = false,
124		.pools_init_expected = false,
125	},
126	{
127		.description = "DMA allocations, DMA32 required",
128		.use_dma_alloc = true,
129		.use_dma32 = true,
130		.pools_init_expected = true,
131	},
132	{
133		.description = "No DMA allocations, DMA32 required",
134		.use_dma_alloc = false,
135		.use_dma32 = true,
136		.pools_init_expected = false,
137	},
138	{
139		.description = "DMA allocations, no DMA32 required",
140		.use_dma_alloc = true,
141		.use_dma32 = false,
142		.pools_init_expected = true,
143	},
144};
145
146static void ttm_device_case_desc(const struct ttm_device_test_case *t, char *desc)
147{
148	strscpy(desc, t->description, KUNIT_PARAM_DESC_SIZE);
149}
150
151KUNIT_ARRAY_PARAM(ttm_device, ttm_device_cases, ttm_device_case_desc);
152
153static void ttm_device_init_pools(struct kunit *test)
154{
155	struct ttm_test_devices *priv = test->priv;
156	const struct ttm_device_test_case *params = test->param_value;
157	struct ttm_device *ttm_dev;
158	struct ttm_pool *pool;
159	struct ttm_pool_type pt;
160	int err;
161
162	ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL);
163	KUNIT_ASSERT_NOT_NULL(test, ttm_dev);
164
165	err = ttm_device_kunit_init(priv, ttm_dev,
166				    params->use_dma_alloc,
167				    params->use_dma32);
168	KUNIT_ASSERT_EQ(test, err, 0);
169
170	pool = &ttm_dev->pool;
171	KUNIT_ASSERT_NOT_NULL(test, pool);
172	KUNIT_EXPECT_PTR_EQ(test, pool->dev, priv->dev);
173	KUNIT_EXPECT_EQ(test, pool->use_dma_alloc, params->use_dma_alloc);
174	KUNIT_EXPECT_EQ(test, pool->use_dma32, params->use_dma32);
175
176	if (params->pools_init_expected) {
177		for (int i = 0; i < TTM_NUM_CACHING_TYPES; ++i) {
178			for (int j = 0; j < NR_PAGE_ORDERS; ++j) {
179				pt = pool->caching[i].orders[j];
180				KUNIT_EXPECT_PTR_EQ(test, pt.pool, pool);
181				KUNIT_EXPECT_EQ(test, pt.caching, i);
182				KUNIT_EXPECT_EQ(test, pt.order, j);
183
184				if (params->use_dma_alloc)
185					KUNIT_ASSERT_FALSE(test,
186							   list_empty(&pt.pages));
187			}
188		}
189	}
190
191	ttm_device_fini(ttm_dev);
192}
193
194static struct kunit_case ttm_device_test_cases[] = {
195	KUNIT_CASE(ttm_device_init_basic),
196	KUNIT_CASE(ttm_device_init_multiple),
197	KUNIT_CASE(ttm_device_fini_basic),
198	KUNIT_CASE(ttm_device_init_no_vma_man),
199	KUNIT_CASE_PARAM(ttm_device_init_pools, ttm_device_gen_params),
200	{}
201};
202
203static struct kunit_suite ttm_device_test_suite = {
204	.name = "ttm_device",
205	.init = ttm_test_devices_init,
206	.exit = ttm_test_devices_fini,
207	.test_cases = ttm_device_test_cases,
208};
209
210kunit_test_suites(&ttm_device_test_suite);
211
212MODULE_LICENSE("GPL");