linux-cryptodev-2.6/drivers/gpu/drm/ttm/tests/ttm_device_test.c

// SPDX-License-Identifier: GPL-2.0 AND MIT
/*
 * Copyright © 2023 Intel Corporation
 */
#include <drm/ttm/ttm_resource.h>
#include <drm/ttm/ttm_device.h>
#include <drm/ttm/ttm_placement.h>

#include "ttm_kunit_helpers.h"
#include "../ttm_pool_internal.h"

struct ttm_device_test_case {
	const char *description;
	unsigned int alloc_flags;
	bool pools_init_expected;
};

static void ttm_device_init_basic(struct kunit *test)
{
	struct ttm_test_devices *priv = test->priv;
	struct ttm_device *ttm_dev;
	struct ttm_resource_manager *ttm_sys_man;
	int err;

	ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, ttm_dev);

	err = ttm_device_kunit_init(priv, ttm_dev, 0);
	KUNIT_ASSERT_EQ(test, err, 0);

	KUNIT_EXPECT_PTR_EQ(test, ttm_dev->funcs, &ttm_dev_funcs);
	KUNIT_ASSERT_NOT_NULL(test, ttm_dev->wq);
	KUNIT_ASSERT_NOT_NULL(test, ttm_dev->man_drv[TTM_PL_SYSTEM]);

	ttm_sys_man = &ttm_dev->sysman;
	KUNIT_ASSERT_NOT_NULL(test, ttm_sys_man);
	KUNIT_EXPECT_TRUE(test, ttm_sys_man->use_tt);
	KUNIT_EXPECT_TRUE(test, ttm_sys_man->use_type);
	KUNIT_ASSERT_NOT_NULL(test, ttm_sys_man->func);

	KUNIT_EXPECT_PTR_EQ(test, ttm_dev->dev_mapping,
			    priv->drm->anon_inode->i_mapping);

	ttm_device_fini(ttm_dev);
}

static void ttm_device_init_multiple(struct kunit *test)
{
	struct ttm_test_devices *priv = test->priv;
	struct ttm_device *ttm_devs;
	unsigned int i, num_dev = 3;
	int err;

	ttm_devs = kunit_kcalloc(test, num_dev, sizeof(*ttm_devs), GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, ttm_devs);

	for (i = 0; i < num_dev; i++) {
		err = ttm_device_kunit_init(priv, &ttm_devs[i], 0);
		KUNIT_ASSERT_EQ(test, err, 0);

		KUNIT_EXPECT_PTR_EQ(test, ttm_devs[i].dev_mapping,
				    priv->drm->anon_inode->i_mapping);
		KUNIT_ASSERT_NOT_NULL(test, ttm_devs[i].wq);
		KUNIT_EXPECT_PTR_EQ(test, ttm_devs[i].funcs, &ttm_dev_funcs);
		KUNIT_ASSERT_NOT_NULL(test, ttm_devs[i].man_drv[TTM_PL_SYSTEM]);
	}

	KUNIT_ASSERT_EQ(test, list_count_nodes(&ttm_devs[0].device_list), num_dev);

	for (i = 0; i < num_dev; i++)
		ttm_device_fini(&ttm_devs[i]);
}

static void ttm_device_fini_basic(struct kunit *test)
{
	struct ttm_test_devices *priv = test->priv;
	struct ttm_device *ttm_dev;
	struct ttm_resource_manager *man;
	int err;

	ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, ttm_dev);

	err = ttm_device_kunit_init(priv, ttm_dev, 0);
	KUNIT_ASSERT_EQ(test, err, 0);

	man = ttm_manager_type(ttm_dev, TTM_PL_SYSTEM);
	KUNIT_ASSERT_NOT_NULL(test, man);

	ttm_device_fini(ttm_dev);

	KUNIT_ASSERT_FALSE(test, man->use_type);
	KUNIT_ASSERT_TRUE(test, list_empty(&man->lru[0]));
	KUNIT_ASSERT_NULL(test, ttm_dev->man_drv[TTM_PL_SYSTEM]);
}

static void ttm_device_init_no_vma_man(struct kunit *test)
{
	struct ttm_test_devices *priv = test->priv;
	struct drm_device *drm = priv->drm;
	struct ttm_device *ttm_dev;
	struct drm_vma_offset_manager *vma_man;
	int err;

	ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, ttm_dev);

	/* Let's pretend there's no VMA manager allocated */
	vma_man = drm->vma_offset_manager;
	drm->vma_offset_manager = NULL;

	err = ttm_device_kunit_init(priv, ttm_dev, 0);
	KUNIT_EXPECT_EQ(test, err, -EINVAL);

	/* Bring the manager back for a graceful cleanup */
	drm->vma_offset_manager = vma_man;
}

static const struct ttm_device_test_case ttm_device_cases[] = {
	{
		.description = "No DMA allocations, no DMA32 required",
		.pools_init_expected = false,
	},
	{
		.description = "DMA allocations, DMA32 required",
		.alloc_flags = TTM_ALLOCATION_POOL_USE_DMA_ALLOC |
			       TTM_ALLOCATION_POOL_USE_DMA32,
		.pools_init_expected = true,
	},
	{
		.description = "No DMA allocations, DMA32 required",
		.alloc_flags = TTM_ALLOCATION_POOL_USE_DMA32,
		.pools_init_expected = false,
	},
	{
		.description = "DMA allocations, no DMA32 required",
		.alloc_flags = TTM_ALLOCATION_POOL_USE_DMA_ALLOC,
		.pools_init_expected = true,
	},
};

static void ttm_device_case_desc(const struct ttm_device_test_case *t, char *desc)
{
	strscpy(desc, t->description, KUNIT_PARAM_DESC_SIZE);
}

KUNIT_ARRAY_PARAM(ttm_device, ttm_device_cases, ttm_device_case_desc);

static void ttm_device_init_pools(struct kunit *test)
{
	struct ttm_test_devices *priv = test->priv;
	const struct ttm_device_test_case *params = test->param_value;
	struct ttm_device *ttm_dev;
	struct ttm_pool *pool;
	struct ttm_pool_type pt;
	int err;

	ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, ttm_dev);

	err = ttm_device_kunit_init(priv, ttm_dev, params->alloc_flags);
	KUNIT_ASSERT_EQ(test, err, 0);

	pool = &ttm_dev->pool;
	KUNIT_ASSERT_NOT_NULL(test, pool);
	KUNIT_EXPECT_PTR_EQ(test, pool->dev, priv->dev);
	KUNIT_EXPECT_EQ(test, pool->alloc_flags, params->alloc_flags);

	if (params->pools_init_expected) {
		for (int i = 0; i < TTM_NUM_CACHING_TYPES; ++i) {
			for (int j = 0; j < NR_PAGE_ORDERS; ++j) {
				pt = pool->caching[i].orders[j];
				KUNIT_EXPECT_PTR_EQ(test, pt.pool, pool);
				KUNIT_EXPECT_EQ(test, pt.caching, i);
				KUNIT_EXPECT_EQ(test, pt.order, j);

				if (ttm_pool_uses_dma_alloc(pool))
					KUNIT_ASSERT_FALSE(test,
							   list_empty(&pt.pages));
			}
		}
	}

	ttm_device_fini(ttm_dev);
}

static struct kunit_case ttm_device_test_cases[] = {
	KUNIT_CASE(ttm_device_init_basic),
	KUNIT_CASE(ttm_device_init_multiple),
	KUNIT_CASE(ttm_device_fini_basic),
	KUNIT_CASE(ttm_device_init_no_vma_man),
	KUNIT_CASE_PARAM(ttm_device_init_pools, ttm_device_gen_params),
	{}
};

static struct kunit_suite ttm_device_test_suite = {
	.name = "ttm_device",
	.init = ttm_test_devices_init,
	.exit = ttm_test_devices_fini,
	.test_cases = ttm_device_test_cases,
};

kunit_test_suites(&ttm_device_test_suite);

MODULE_DESCRIPTION("KUnit tests for ttm_device APIs");
MODULE_LICENSE("GPL and additional rights");